bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004
   3    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 2 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    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "bfd.h"
  29 #include "sysdep.h"
  30 #include "bfdlink.h"
  31 #include "libbfd.h"
  32 #include "elf-bfd.h"
  33 #include "elf/ppc64.h"
  34 #include "elf64-ppc.h"
  35
  36 static bfd_reloc_status_type ppc64_elf_ha_reloc
  37   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  38 static bfd_reloc_status_type ppc64_elf_branch_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_toc_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_vma opd_entry_value
  55   (asection *, bfd_vma, asection **, bfd_vma *);
  56
  57 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  58 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  59 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  60 #define TARGET_BIG_NAME         "elf64-powerpc"
  61 #define ELF_ARCH                bfd_arch_powerpc
  62 #define ELF_MACHINE_CODE        EM_PPC64
  63 #define ELF_MAXPAGESIZE         0x10000
  64 #define elf_info_to_howto       ppc64_elf_info_to_howto
  65
  66 #define elf_backend_want_got_sym 0
  67 #define elf_backend_want_plt_sym 0
  68 #define elf_backend_plt_alignment 3
  69 #define elf_backend_plt_not_loaded 1
  70 #define elf_backend_got_symbol_offset 0
  71 #define elf_backend_got_header_size 8
  72 #define elf_backend_can_gc_sections 1
  73 #define elf_backend_can_refcount 1
  74 #define elf_backend_rela_normal 1
  75
  76 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  77 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  78 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  79 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  80 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  81 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  82 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  83
  84 #define elf_backend_object_p                  ppc64_elf_object_p
  85 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  86 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  87 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  88 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  89 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  90 #define elf_backend_check_directives          ppc64_elf_check_directives
  91 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
  92 #define elf_backend_check_relocs              ppc64_elf_check_relocs
  93 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
  94 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
  95 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
  96 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
  97 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
  98 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
  99 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 100 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 101 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 102 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 103 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 104 #define elf_backend_special_sections          ppc64_elf_special_sections
 105
 106 /* The name of the dynamic interpreter.  This is put in the .interp
 107    section.  */
 108 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 109
 110 /* The size in bytes of an entry in the procedure linkage table.  */
 111 #define PLT_ENTRY_SIZE 24
 112
 113 /* The initial size of the plt reserved for the dynamic linker.  */
 114 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 115
 116 /* TOC base pointers offset from start of TOC.  */
 117 #define TOC_BASE_OFF    0x8000
 118
 119 /* Offset of tp and dtp pointers from start of TLS block.  */
 120 #define TP_OFFSET       0x7000
 121 #define DTP_OFFSET      0x8000
 122
 123 /* .plt call stub instructions.  The normal stub is like this, but
 124    sometimes the .plt entry crosses a 64k boundary and we need to
 125    insert an addis to adjust r12.  */
 126 #define PLT_CALL_STUB_SIZE (7*4)
 127 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 128 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 129 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 130 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 131 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 132                                         /* ld    %r11,xxx+16@l(%r12) */
 133 #define BCTR            0x4e800420      /* bctr                      */
 134
 135
 136 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 137 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 138
 139 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 140
 141 /* glink call stub instructions.  We enter with the index in R0, and the
 142    address of glink entry in CTR.  From that, we can calculate PLT0.  */
 143 #define GLINK_CALL_STUB_SIZE (16*4)
 144 #define MFCTR_R12       0x7d8902a6      /* mfctr  %r12                  */
 145 #define SLDI_R11_R0_3   0x780b1f24      /* sldi   %r11,%r0,3            */
 146 #define ADDIC_R2_R0_32K 0x34408000      /* addic. %r2,%r0,-32768        */
 147 #define SUB_R12_R12_R11 0x7d8b6050      /* sub    %r12,%r12,%r11        */
 148 #define SRADI_R2_R2_63  0x7c42fe76      /* sradi  %r2,%r2,63            */
 149 #define SLDI_R11_R0_2   0x780b1764      /* sldi   %r11,%r0,2            */
 150 #define AND_R2_R2_R11   0x7c425838      /* and    %r2,%r2,%r11          */
 151                                         /* sub    %r12,%r12,%r11        */
 152 #define ADD_R12_R12_R2  0x7d8c1214      /* add    %r12,%r12,%r2         */
 153 #define ADDIS_R12_R12   0x3d8c0000      /* addis  %r12,%r12,xxx@ha      */
 154                                         /* ld     %r11,xxx@l(%r12)      */
 155 #define ADDI_R12_R12    0x398c0000      /* addi   %r12,%r12,xxx@l       */
 156                                         /* ld     %r2,8(%r12)           */
 157                                         /* mtctr  %r11                  */
 158                                         /* ld     %r11,16(%r12)         */
 159                                         /* bctr                         */
 160
 161 /* Pad with this.  */
 162 #define NOP             0x60000000
 163
 164 /* Some other nops.  */
 165 #define CROR_151515     0x4def7b82
 166 #define CROR_313131     0x4ffffb82
 167
 168 /* .glink entries for the first 32k functions are two instructions.  */
 169 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 170 #define B_DOT           0x48000000      /* b     .              */
 171
 172 /* After that, we need two instructions to load the index, followed by
 173    a branch.  */
 174 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 175 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 176
 177 /* Instructions used by the save and restore reg functions.  */
 178 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 179 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 180 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 181 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 182 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 183 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 184 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 185 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 186 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 187 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 188 #define BLR             0x4e800020      /* blr                  */
 189
 190 /* Since .opd is an array of descriptors and each entry will end up
 191    with identical R_PPC64_RELATIVE relocs, there is really no need to
 192    propagate .opd relocs;  The dynamic linker should be taught to
 193    relocate .opd without reloc entries.  */
 194 #ifndef NO_OPD_RELOCS
 195 #define NO_OPD_RELOCS 0
 196 #endif
 197 \f
 198 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 199
 200 /* Relocation HOWTO's.  */
 201 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 202
 203 static reloc_howto_type ppc64_elf_howto_raw[] = {
 204   /* This reloc does nothing.  */
 205   HOWTO (R_PPC64_NONE,          /* type */
 206          0,                     /* rightshift */
 207          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 208          32,                    /* bitsize */
 209          FALSE,                 /* pc_relative */
 210          0,                     /* bitpos */
 211          complain_overflow_dont, /* complain_on_overflow */
 212          bfd_elf_generic_reloc, /* special_function */
 213          "R_PPC64_NONE",        /* name */
 214          FALSE,                 /* partial_inplace */
 215          0,                     /* src_mask */
 216          0,                     /* dst_mask */
 217          FALSE),                /* pcrel_offset */
 218
 219   /* A standard 32 bit relocation.  */
 220   HOWTO (R_PPC64_ADDR32,        /* type */
 221          0,                     /* rightshift */
 222          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 223          32,                    /* bitsize */
 224          FALSE,                 /* pc_relative */
 225          0,                     /* bitpos */
 226          complain_overflow_bitfield, /* complain_on_overflow */
 227          bfd_elf_generic_reloc, /* special_function */
 228          "R_PPC64_ADDR32",      /* name */
 229          FALSE,                 /* partial_inplace */
 230          0,                     /* src_mask */
 231          0xffffffff,            /* dst_mask */
 232          FALSE),                /* pcrel_offset */
 233
 234   /* An absolute 26 bit branch; the lower two bits must be zero.
 235      FIXME: we don't check that, we just clear them.  */
 236   HOWTO (R_PPC64_ADDR24,        /* type */
 237          0,                     /* rightshift */
 238          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 239          26,                    /* bitsize */
 240          FALSE,                 /* pc_relative */
 241          0,                     /* bitpos */
 242          complain_overflow_bitfield, /* complain_on_overflow */
 243          bfd_elf_generic_reloc, /* special_function */
 244          "R_PPC64_ADDR24",      /* name */
 245          FALSE,                 /* partial_inplace */
 246          0,                     /* src_mask */
 247          0x03fffffc,            /* dst_mask */
 248          FALSE),                /* pcrel_offset */
 249
 250   /* A standard 16 bit relocation.  */
 251   HOWTO (R_PPC64_ADDR16,        /* type */
 252          0,                     /* rightshift */
 253          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 254          16,                    /* bitsize */
 255          FALSE,                 /* pc_relative */
 256          0,                     /* bitpos */
 257          complain_overflow_bitfield, /* complain_on_overflow */
 258          bfd_elf_generic_reloc, /* special_function */
 259          "R_PPC64_ADDR16",      /* name */
 260          FALSE,                 /* partial_inplace */
 261          0,                     /* src_mask */
 262          0xffff,                /* dst_mask */
 263          FALSE),                /* pcrel_offset */
 264
 265   /* A 16 bit relocation without overflow.  */
 266   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 267          0,                     /* rightshift */
 268          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 269          16,                    /* bitsize */
 270          FALSE,                 /* pc_relative */
 271          0,                     /* bitpos */
 272          complain_overflow_dont,/* complain_on_overflow */
 273          bfd_elf_generic_reloc, /* special_function */
 274          "R_PPC64_ADDR16_LO",   /* name */
 275          FALSE,                 /* partial_inplace */
 276          0,                     /* src_mask */
 277          0xffff,                /* dst_mask */
 278          FALSE),                /* pcrel_offset */
 279
 280   /* Bits 16-31 of an address.  */
 281   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 282          16,                    /* rightshift */
 283          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 284          16,                    /* bitsize */
 285          FALSE,                 /* pc_relative */
 286          0,                     /* bitpos */
 287          complain_overflow_dont, /* complain_on_overflow */
 288          bfd_elf_generic_reloc, /* special_function */
 289          "R_PPC64_ADDR16_HI",   /* name */
 290          FALSE,                 /* partial_inplace */
 291          0,                     /* src_mask */
 292          0xffff,                /* dst_mask */
 293          FALSE),                /* pcrel_offset */
 294
 295   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 296      bits, treated as a signed number, is negative.  */
 297   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 298          16,                    /* rightshift */
 299          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 300          16,                    /* bitsize */
 301          FALSE,                 /* pc_relative */
 302          0,                     /* bitpos */
 303          complain_overflow_dont, /* complain_on_overflow */
 304          ppc64_elf_ha_reloc,    /* special_function */
 305          "R_PPC64_ADDR16_HA",   /* name */
 306          FALSE,                 /* partial_inplace */
 307          0,                     /* src_mask */
 308          0xffff,                /* dst_mask */
 309          FALSE),                /* pcrel_offset */
 310
 311   /* An absolute 16 bit branch; the lower two bits must be zero.
 312      FIXME: we don't check that, we just clear them.  */
 313   HOWTO (R_PPC64_ADDR14,        /* type */
 314          0,                     /* rightshift */
 315          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 316          16,                    /* bitsize */
 317          FALSE,                 /* pc_relative */
 318          0,                     /* bitpos */
 319          complain_overflow_bitfield, /* complain_on_overflow */
 320          ppc64_elf_branch_reloc, /* special_function */
 321          "R_PPC64_ADDR14",      /* name */
 322          FALSE,                 /* partial_inplace */
 323          0,                     /* src_mask */
 324          0x0000fffc,            /* dst_mask */
 325          FALSE),                /* pcrel_offset */
 326
 327   /* An absolute 16 bit branch, for which bit 10 should be set to
 328      indicate that the branch is expected to be taken.  The lower two
 329      bits must be zero.  */
 330   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 331          0,                     /* rightshift */
 332          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_bitfield, /* complain_on_overflow */
 337          ppc64_elf_brtaken_reloc, /* special_function */
 338          "R_PPC64_ADDR14_BRTAKEN",/* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0x0000fffc,            /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* An absolute 16 bit branch, for which bit 10 should be set to
 345      indicate that the branch is not expected to be taken.  The lower
 346      two bits must be zero.  */
 347   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 348          0,                     /* rightshift */
 349          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 350          16,                    /* bitsize */
 351          FALSE,                 /* pc_relative */
 352          0,                     /* bitpos */
 353          complain_overflow_bitfield, /* complain_on_overflow */
 354          ppc64_elf_brtaken_reloc, /* special_function */
 355          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 356          FALSE,                 /* partial_inplace */
 357          0,                     /* src_mask */
 358          0x0000fffc,            /* dst_mask */
 359          FALSE),                /* pcrel_offset */
 360
 361   /* A relative 26 bit branch; the lower two bits must be zero.  */
 362   HOWTO (R_PPC64_REL24,         /* type */
 363          0,                     /* rightshift */
 364          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 365          26,                    /* bitsize */
 366          TRUE,                  /* pc_relative */
 367          0,                     /* bitpos */
 368          complain_overflow_signed, /* complain_on_overflow */
 369          ppc64_elf_branch_reloc, /* special_function */
 370          "R_PPC64_REL24",       /* name */
 371          FALSE,                 /* partial_inplace */
 372          0,                     /* src_mask */
 373          0x03fffffc,            /* dst_mask */
 374          TRUE),                 /* pcrel_offset */
 375
 376   /* A relative 16 bit branch; the lower two bits must be zero.  */
 377   HOWTO (R_PPC64_REL14,         /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          TRUE,                  /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_REL14",       /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          TRUE),                 /* pcrel_offset */
 390
 391   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 392      the branch is expected to be taken.  The lower two bits must be
 393      zero.  */
 394   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          TRUE,                  /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_REL14_BRTAKEN", /* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          TRUE),                 /* pcrel_offset */
 407
 408   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 409      the branch is not expected to be taken.  The lower two bits must
 410      be zero.  */
 411   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          TRUE,                  /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_REL14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          TRUE),                 /* pcrel_offset */
 424
 425   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 426      symbol.  */
 427   HOWTO (R_PPC64_GOT16,         /* type */
 428          0,                     /* rightshift */
 429          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 430          16,                    /* bitsize */
 431          FALSE,                 /* pc_relative */
 432          0,                     /* bitpos */
 433          complain_overflow_signed, /* complain_on_overflow */
 434          ppc64_elf_unhandled_reloc, /* special_function */
 435          "R_PPC64_GOT16",       /* name */
 436          FALSE,                 /* partial_inplace */
 437          0,                     /* src_mask */
 438          0xffff,                /* dst_mask */
 439          FALSE),                /* pcrel_offset */
 440
 441   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 442      the symbol.  */
 443   HOWTO (R_PPC64_GOT16_LO,      /* type */
 444          0,                     /* rightshift */
 445          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 446          16,                    /* bitsize */
 447          FALSE,                 /* pc_relative */
 448          0,                     /* bitpos */
 449          complain_overflow_dont, /* complain_on_overflow */
 450          ppc64_elf_unhandled_reloc, /* special_function */
 451          "R_PPC64_GOT16_LO",    /* name */
 452          FALSE,                 /* partial_inplace */
 453          0,                     /* src_mask */
 454          0xffff,                /* dst_mask */
 455          FALSE),                /* pcrel_offset */
 456
 457   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 458      the symbol.  */
 459   HOWTO (R_PPC64_GOT16_HI,      /* type */
 460          16,                    /* rightshift */
 461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 462          16,                    /* bitsize */
 463          FALSE,                 /* pc_relative */
 464          0,                     /* bitpos */
 465          complain_overflow_dont,/* complain_on_overflow */
 466          ppc64_elf_unhandled_reloc, /* special_function */
 467          "R_PPC64_GOT16_HI",    /* name */
 468          FALSE,                 /* partial_inplace */
 469          0,                     /* src_mask */
 470          0xffff,                /* dst_mask */
 471          FALSE),                /* pcrel_offset */
 472
 473   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 474      the symbol.  */
 475   HOWTO (R_PPC64_GOT16_HA,      /* type */
 476          16,                    /* rightshift */
 477          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          FALSE,                 /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_dont,/* complain_on_overflow */
 482          ppc64_elf_unhandled_reloc, /* special_function */
 483          "R_PPC64_GOT16_HA",    /* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0xffff,                /* dst_mask */
 487          FALSE),                /* pcrel_offset */
 488
 489   /* This is used only by the dynamic linker.  The symbol should exist
 490      both in the object being run and in some shared library.  The
 491      dynamic linker copies the data addressed by the symbol from the
 492      shared library into the object, because the object being
 493      run has to have the data at some particular address.  */
 494   HOWTO (R_PPC64_COPY,          /* type */
 495          0,                     /* rightshift */
 496          0,                     /* this one is variable size */
 497          0,                     /* bitsize */
 498          FALSE,                 /* pc_relative */
 499          0,                     /* bitpos */
 500          complain_overflow_dont, /* complain_on_overflow */
 501          ppc64_elf_unhandled_reloc, /* special_function */
 502          "R_PPC64_COPY",        /* name */
 503          FALSE,                 /* partial_inplace */
 504          0,                     /* src_mask */
 505          0,                     /* dst_mask */
 506          FALSE),                /* pcrel_offset */
 507
 508   /* Like R_PPC64_ADDR64, but used when setting global offset table
 509      entries.  */
 510   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 511          0,                     /* rightshift */
 512          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 513          64,                    /* bitsize */
 514          FALSE,                 /* pc_relative */
 515          0,                     /* bitpos */
 516          complain_overflow_dont, /* complain_on_overflow */
 517          ppc64_elf_unhandled_reloc,  /* special_function */
 518          "R_PPC64_GLOB_DAT",    /* name */
 519          FALSE,                 /* partial_inplace */
 520          0,                     /* src_mask */
 521          ONES (64),             /* dst_mask */
 522          FALSE),                /* pcrel_offset */
 523
 524   /* Created by the link editor.  Marks a procedure linkage table
 525      entry for a symbol.  */
 526   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 527          0,                     /* rightshift */
 528          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 529          0,                     /* bitsize */
 530          FALSE,                 /* pc_relative */
 531          0,                     /* bitpos */
 532          complain_overflow_dont, /* complain_on_overflow */
 533          ppc64_elf_unhandled_reloc, /* special_function */
 534          "R_PPC64_JMP_SLOT",    /* name */
 535          FALSE,                 /* partial_inplace */
 536          0,                     /* src_mask */
 537          0,                     /* dst_mask */
 538          FALSE),                /* pcrel_offset */
 539
 540   /* Used only by the dynamic linker.  When the object is run, this
 541      doubleword64 is set to the load address of the object, plus the
 542      addend.  */
 543   HOWTO (R_PPC64_RELATIVE,      /* type */
 544          0,                     /* rightshift */
 545          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 546          64,                    /* bitsize */
 547          FALSE,                 /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_dont, /* complain_on_overflow */
 550          bfd_elf_generic_reloc, /* special_function */
 551          "R_PPC64_RELATIVE",    /* name */
 552          FALSE,                 /* partial_inplace */
 553          0,                     /* src_mask */
 554          ONES (64),             /* dst_mask */
 555          FALSE),                /* pcrel_offset */
 556
 557   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 558   HOWTO (R_PPC64_UADDR32,       /* type */
 559          0,                     /* rightshift */
 560          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 561          32,                    /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_bitfield, /* complain_on_overflow */
 565          bfd_elf_generic_reloc, /* special_function */
 566          "R_PPC64_UADDR32",     /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0xffffffff,            /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 573   HOWTO (R_PPC64_UADDR16,       /* type */
 574          0,                     /* rightshift */
 575          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 576          16,                    /* bitsize */
 577          FALSE,                 /* pc_relative */
 578          0,                     /* bitpos */
 579          complain_overflow_bitfield, /* complain_on_overflow */
 580          bfd_elf_generic_reloc, /* special_function */
 581          "R_PPC64_UADDR16",     /* name */
 582          FALSE,                 /* partial_inplace */
 583          0,                     /* src_mask */
 584          0xffff,                /* dst_mask */
 585          FALSE),                /* pcrel_offset */
 586
 587   /* 32-bit PC relative.  */
 588   HOWTO (R_PPC64_REL32,         /* type */
 589          0,                     /* rightshift */
 590          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 591          32,                    /* bitsize */
 592          TRUE,                  /* pc_relative */
 593          0,                     /* bitpos */
 594          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 595          complain_overflow_signed, /* complain_on_overflow */
 596          bfd_elf_generic_reloc, /* special_function */
 597          "R_PPC64_REL32",       /* name */
 598          FALSE,                 /* partial_inplace */
 599          0,                     /* src_mask */
 600          0xffffffff,            /* dst_mask */
 601          TRUE),                 /* pcrel_offset */
 602
 603   /* 32-bit relocation to the symbol's procedure linkage table.  */
 604   HOWTO (R_PPC64_PLT32,         /* type */
 605          0,                     /* rightshift */
 606          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 607          32,                    /* bitsize */
 608          FALSE,                 /* pc_relative */
 609          0,                     /* bitpos */
 610          complain_overflow_bitfield, /* complain_on_overflow */
 611          ppc64_elf_unhandled_reloc, /* special_function */
 612          "R_PPC64_PLT32",       /* name */
 613          FALSE,                 /* partial_inplace */
 614          0,                     /* src_mask */
 615          0xffffffff,            /* dst_mask */
 616          FALSE),                /* pcrel_offset */
 617
 618   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 619      FIXME: R_PPC64_PLTREL32 not supported.  */
 620   HOWTO (R_PPC64_PLTREL32,      /* type */
 621          0,                     /* rightshift */
 622          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 623          32,                    /* bitsize */
 624          TRUE,                  /* pc_relative */
 625          0,                     /* bitpos */
 626          complain_overflow_signed, /* complain_on_overflow */
 627          bfd_elf_generic_reloc, /* special_function */
 628          "R_PPC64_PLTREL32",    /* name */
 629          FALSE,                 /* partial_inplace */
 630          0,                     /* src_mask */
 631          0xffffffff,            /* dst_mask */
 632          TRUE),                 /* pcrel_offset */
 633
 634   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 635      the symbol.  */
 636   HOWTO (R_PPC64_PLT16_LO,      /* type */
 637          0,                     /* rightshift */
 638          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 639          16,                    /* bitsize */
 640          FALSE,                 /* pc_relative */
 641          0,                     /* bitpos */
 642          complain_overflow_dont, /* complain_on_overflow */
 643          ppc64_elf_unhandled_reloc, /* special_function */
 644          "R_PPC64_PLT16_LO",    /* name */
 645          FALSE,                 /* partial_inplace */
 646          0,                     /* src_mask */
 647          0xffff,                /* dst_mask */
 648          FALSE),                /* pcrel_offset */
 649
 650   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 651      the symbol.  */
 652   HOWTO (R_PPC64_PLT16_HI,      /* type */
 653          16,                    /* rightshift */
 654          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          16,                    /* bitsize */
 656          FALSE,                 /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_dont, /* complain_on_overflow */
 659          ppc64_elf_unhandled_reloc, /* special_function */
 660          "R_PPC64_PLT16_HI",    /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffff,                /* dst_mask */
 664          FALSE),                /* pcrel_offset */
 665
 666   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 667      the symbol.  */
 668   HOWTO (R_PPC64_PLT16_HA,      /* type */
 669          16,                    /* rightshift */
 670          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 671          16,                    /* bitsize */
 672          FALSE,                 /* pc_relative */
 673          0,                     /* bitpos */
 674          complain_overflow_dont, /* complain_on_overflow */
 675          ppc64_elf_unhandled_reloc, /* special_function */
 676          "R_PPC64_PLT16_HA",    /* name */
 677          FALSE,                 /* partial_inplace */
 678          0,                     /* src_mask */
 679          0xffff,                /* dst_mask */
 680          FALSE),                /* pcrel_offset */
 681
 682   /* 16-bit section relative relocation.  */
 683   HOWTO (R_PPC64_SECTOFF,       /* type */
 684          0,                     /* rightshift */
 685          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          16,                    /* bitsize */
 687          FALSE,                 /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_bitfield, /* complain_on_overflow */
 690          ppc64_elf_sectoff_reloc, /* special_function */
 691          "R_PPC64_SECTOFF",     /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffff,                /* dst_mask */
 695          FALSE),                /* pcrel_offset */
 696
 697   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 698   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 699          0,                     /* rightshift */
 700          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 701          16,                    /* bitsize */
 702          FALSE,                 /* pc_relative */
 703          0,                     /* bitpos */
 704          complain_overflow_dont, /* complain_on_overflow */
 705          ppc64_elf_sectoff_reloc, /* special_function */
 706          "R_PPC64_SECTOFF_LO",  /* name */
 707          FALSE,                 /* partial_inplace */
 708          0,                     /* src_mask */
 709          0xffff,                /* dst_mask */
 710          FALSE),                /* pcrel_offset */
 711
 712   /* 16-bit upper half section relative relocation.  */
 713   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 714          16,                    /* rightshift */
 715          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 716          16,                    /* bitsize */
 717          FALSE,                 /* pc_relative */
 718          0,                     /* bitpos */
 719          complain_overflow_dont, /* complain_on_overflow */
 720          ppc64_elf_sectoff_reloc, /* special_function */
 721          "R_PPC64_SECTOFF_HI",  /* name */
 722          FALSE,                 /* partial_inplace */
 723          0,                     /* src_mask */
 724          0xffff,                /* dst_mask */
 725          FALSE),                /* pcrel_offset */
 726
 727   /* 16-bit upper half adjusted section relative relocation.  */
 728   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 729          16,                    /* rightshift */
 730          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 731          16,                    /* bitsize */
 732          FALSE,                 /* pc_relative */
 733          0,                     /* bitpos */
 734          complain_overflow_dont, /* complain_on_overflow */
 735          ppc64_elf_sectoff_ha_reloc, /* special_function */
 736          "R_PPC64_SECTOFF_HA",  /* name */
 737          FALSE,                 /* partial_inplace */
 738          0,                     /* src_mask */
 739          0xffff,                /* dst_mask */
 740          FALSE),                /* pcrel_offset */
 741
 742   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 743   HOWTO (R_PPC64_REL30,         /* type */
 744          2,                     /* rightshift */
 745          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 746          30,                    /* bitsize */
 747          TRUE,                  /* pc_relative */
 748          0,                     /* bitpos */
 749          complain_overflow_dont, /* complain_on_overflow */
 750          bfd_elf_generic_reloc, /* special_function */
 751          "R_PPC64_REL30",       /* name */
 752          FALSE,                 /* partial_inplace */
 753          0,                     /* src_mask */
 754          0xfffffffc,            /* dst_mask */
 755          TRUE),                 /* pcrel_offset */
 756
 757   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 758
 759   /* A standard 64-bit relocation.  */
 760   HOWTO (R_PPC64_ADDR64,        /* type */
 761          0,                     /* rightshift */
 762          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 763          64,                    /* bitsize */
 764          FALSE,                 /* pc_relative */
 765          0,                     /* bitpos */
 766          complain_overflow_dont, /* complain_on_overflow */
 767          bfd_elf_generic_reloc, /* special_function */
 768          "R_PPC64_ADDR64",      /* name */
 769          FALSE,                 /* partial_inplace */
 770          0,                     /* src_mask */
 771          ONES (64),             /* dst_mask */
 772          FALSE),                /* pcrel_offset */
 773
 774   /* The bits 32-47 of an address.  */
 775   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 776          32,                    /* rightshift */
 777          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 778          16,                    /* bitsize */
 779          FALSE,                 /* pc_relative */
 780          0,                     /* bitpos */
 781          complain_overflow_dont, /* complain_on_overflow */
 782          bfd_elf_generic_reloc, /* special_function */
 783          "R_PPC64_ADDR16_HIGHER", /* name */
 784          FALSE,                 /* partial_inplace */
 785          0,                     /* src_mask */
 786          0xffff,                /* dst_mask */
 787          FALSE),                /* pcrel_offset */
 788
 789   /* The bits 32-47 of an address, plus 1 if the contents of the low
 790      16 bits, treated as a signed number, is negative.  */
 791   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 792          32,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_dont, /* complain_on_overflow */
 798          ppc64_elf_ha_reloc,    /* special_function */
 799          "R_PPC64_ADDR16_HIGHERA", /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* The bits 48-63 of an address.  */
 806   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 807          48,                    /* rightshift */
 808          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          16,                    /* bitsize */
 810          FALSE,                 /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_ADDR16_HIGHEST", /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xffff,                /* dst_mask */
 818          FALSE),                /* pcrel_offset */
 819
 820   /* The bits 48-63 of an address, plus 1 if the contents of the low
 821      16 bits, treated as a signed number, is negative.  */
 822   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 823          48,                    /* rightshift */
 824          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 825          16,                    /* bitsize */
 826          FALSE,                 /* pc_relative */
 827          0,                     /* bitpos */
 828          complain_overflow_dont, /* complain_on_overflow */
 829          ppc64_elf_ha_reloc,    /* special_function */
 830          "R_PPC64_ADDR16_HIGHESTA", /* name */
 831          FALSE,                 /* partial_inplace */
 832          0,                     /* src_mask */
 833          0xffff,                /* dst_mask */
 834          FALSE),                /* pcrel_offset */
 835
 836   /* Like ADDR64, but may be unaligned.  */
 837   HOWTO (R_PPC64_UADDR64,       /* type */
 838          0,                     /* rightshift */
 839          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 840          64,                    /* bitsize */
 841          FALSE,                 /* pc_relative */
 842          0,                     /* bitpos */
 843          complain_overflow_dont, /* complain_on_overflow */
 844          bfd_elf_generic_reloc, /* special_function */
 845          "R_PPC64_UADDR64",     /* name */
 846          FALSE,                 /* partial_inplace */
 847          0,                     /* src_mask */
 848          ONES (64),             /* dst_mask */
 849          FALSE),                /* pcrel_offset */
 850
 851   /* 64-bit relative relocation.  */
 852   HOWTO (R_PPC64_REL64,         /* type */
 853          0,                     /* rightshift */
 854          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 855          64,                    /* bitsize */
 856          TRUE,                  /* pc_relative */
 857          0,                     /* bitpos */
 858          complain_overflow_dont, /* complain_on_overflow */
 859          bfd_elf_generic_reloc, /* special_function */
 860          "R_PPC64_REL64",       /* name */
 861          FALSE,                 /* partial_inplace */
 862          0,                     /* src_mask */
 863          ONES (64),             /* dst_mask */
 864          TRUE),                 /* pcrel_offset */
 865
 866   /* 64-bit relocation to the symbol's procedure linkage table.  */
 867   HOWTO (R_PPC64_PLT64,         /* type */
 868          0,                     /* rightshift */
 869          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 870          64,                    /* bitsize */
 871          FALSE,                 /* pc_relative */
 872          0,                     /* bitpos */
 873          complain_overflow_dont, /* complain_on_overflow */
 874          ppc64_elf_unhandled_reloc, /* special_function */
 875          "R_PPC64_PLT64",       /* name */
 876          FALSE,                 /* partial_inplace */
 877          0,                     /* src_mask */
 878          ONES (64),             /* dst_mask */
 879          FALSE),                /* pcrel_offset */
 880
 881   /* 64-bit PC relative relocation to the symbol's procedure linkage
 882      table.  */
 883   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 884   HOWTO (R_PPC64_PLTREL64,      /* type */
 885          0,                     /* rightshift */
 886          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 887          64,                    /* bitsize */
 888          TRUE,                  /* pc_relative */
 889          0,                     /* bitpos */
 890          complain_overflow_dont, /* complain_on_overflow */
 891          ppc64_elf_unhandled_reloc, /* special_function */
 892          "R_PPC64_PLTREL64",    /* name */
 893          FALSE,                 /* partial_inplace */
 894          0,                     /* src_mask */
 895          ONES (64),             /* dst_mask */
 896          TRUE),                 /* pcrel_offset */
 897
 898   /* 16 bit TOC-relative relocation.  */
 899
 900   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 901   HOWTO (R_PPC64_TOC16,         /* type */
 902          0,                     /* rightshift */
 903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 904          16,                    /* bitsize */
 905          FALSE,                 /* pc_relative */
 906          0,                     /* bitpos */
 907          complain_overflow_signed, /* complain_on_overflow */
 908          ppc64_elf_toc_reloc,   /* special_function */
 909          "R_PPC64_TOC16",       /* name */
 910          FALSE,                 /* partial_inplace */
 911          0,                     /* src_mask */
 912          0xffff,                /* dst_mask */
 913          FALSE),                /* pcrel_offset */
 914
 915   /* 16 bit TOC-relative relocation without overflow.  */
 916
 917   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 918   HOWTO (R_PPC64_TOC16_LO,      /* type */
 919          0,                     /* rightshift */
 920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 921          16,                    /* bitsize */
 922          FALSE,                 /* pc_relative */
 923          0,                     /* bitpos */
 924          complain_overflow_dont, /* complain_on_overflow */
 925          ppc64_elf_toc_reloc,   /* special_function */
 926          "R_PPC64_TOC16_LO",    /* name */
 927          FALSE,                 /* partial_inplace */
 928          0,                     /* src_mask */
 929          0xffff,                /* dst_mask */
 930          FALSE),                /* pcrel_offset */
 931
 932   /* 16 bit TOC-relative relocation, high 16 bits.  */
 933
 934   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 935   HOWTO (R_PPC64_TOC16_HI,      /* type */
 936          16,                    /* rightshift */
 937          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 938          16,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_toc_reloc,   /* special_function */
 943          "R_PPC64_TOC16_HI",    /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          0xffff,                /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 950      contents of the low 16 bits, treated as a signed number, is
 951      negative.  */
 952
 953   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 954   HOWTO (R_PPC64_TOC16_HA,      /* type */
 955          16,                    /* rightshift */
 956          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 957          16,                    /* bitsize */
 958          FALSE,                 /* pc_relative */
 959          0,                     /* bitpos */
 960          complain_overflow_dont, /* complain_on_overflow */
 961          ppc64_elf_toc_ha_reloc, /* special_function */
 962          "R_PPC64_TOC16_HA",    /* name */
 963          FALSE,                 /* partial_inplace */
 964          0,                     /* src_mask */
 965          0xffff,                /* dst_mask */
 966          FALSE),                /* pcrel_offset */
 967
 968   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 969
 970   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 971   HOWTO (R_PPC64_TOC,           /* type */
 972          0,                     /* rightshift */
 973          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 974          64,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_bitfield, /* complain_on_overflow */
 978          ppc64_elf_toc64_reloc, /* special_function */
 979          "R_PPC64_TOC",         /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          ONES (64),             /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* Like R_PPC64_GOT16, but also informs the link editor that the
 986      value to relocate may (!) refer to a PLT entry which the link
 987      editor (a) may replace with the symbol value.  If the link editor
 988      is unable to fully resolve the symbol, it may (b) create a PLT
 989      entry and store the address to the new PLT entry in the GOT.
 990      This permits lazy resolution of function symbols at run time.
 991      The link editor may also skip all of this and just (c) emit a
 992      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
 993   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
 994     HOWTO (R_PPC64_PLTGOT16,    /* type */
 995          0,                     /* rightshift */
 996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 997          16,                    /* bitsize */
 998          FALSE,                 /* pc_relative */
 999          0,                     /* bitpos */
1000          complain_overflow_signed, /* complain_on_overflow */
1001          ppc64_elf_unhandled_reloc, /* special_function */
1002          "R_PPC64_PLTGOT16",    /* name */
1003          FALSE,                 /* partial_inplace */
1004          0,                     /* src_mask */
1005          0xffff,                /* dst_mask */
1006          FALSE),                /* pcrel_offset */
1007
1008   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1009   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1010   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1011          0,                     /* rightshift */
1012          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1013          16,                    /* bitsize */
1014          FALSE,                 /* pc_relative */
1015          0,                     /* bitpos */
1016          complain_overflow_dont, /* complain_on_overflow */
1017          ppc64_elf_unhandled_reloc, /* special_function */
1018          "R_PPC64_PLTGOT16_LO", /* name */
1019          FALSE,                 /* partial_inplace */
1020          0,                     /* src_mask */
1021          0xffff,                /* dst_mask */
1022          FALSE),                /* pcrel_offset */
1023
1024   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1025   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1026   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1027          16,                    /* rightshift */
1028          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1029          16,                    /* bitsize */
1030          FALSE,                 /* pc_relative */
1031          0,                     /* bitpos */
1032          complain_overflow_dont, /* complain_on_overflow */
1033          ppc64_elf_unhandled_reloc, /* special_function */
1034          "R_PPC64_PLTGOT16_HI", /* name */
1035          FALSE,                 /* partial_inplace */
1036          0,                     /* src_mask */
1037          0xffff,                /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1041      1 if the contents of the low 16 bits, treated as a signed number,
1042      is negative.  */
1043   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1044   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1045          16,                    /* rightshift */
1046          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1047          16,                    /* bitsize */
1048          FALSE,                 /* pc_relative */
1049          0,                     /* bitpos */
1050          complain_overflow_dont,/* complain_on_overflow */
1051          ppc64_elf_unhandled_reloc, /* special_function */
1052          "R_PPC64_PLTGOT16_HA", /* name */
1053          FALSE,                 /* partial_inplace */
1054          0,                     /* src_mask */
1055          0xffff,                /* dst_mask */
1056          FALSE),                /* pcrel_offset */
1057
1058   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1059   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1060          0,                     /* rightshift */
1061          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1062          16,                    /* bitsize */
1063          FALSE,                 /* pc_relative */
1064          0,                     /* bitpos */
1065          complain_overflow_bitfield, /* complain_on_overflow */
1066          bfd_elf_generic_reloc, /* special_function */
1067          "R_PPC64_ADDR16_DS",   /* name */
1068          FALSE,                 /* partial_inplace */
1069          0,                     /* src_mask */
1070          0xfffc,                /* dst_mask */
1071          FALSE),                /* pcrel_offset */
1072
1073   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1074   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1075          0,                     /* rightshift */
1076          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1077          16,                    /* bitsize */
1078          FALSE,                 /* pc_relative */
1079          0,                     /* bitpos */
1080          complain_overflow_dont,/* complain_on_overflow */
1081          bfd_elf_generic_reloc, /* special_function */
1082          "R_PPC64_ADDR16_LO_DS",/* name */
1083          FALSE,                 /* partial_inplace */
1084          0,                     /* src_mask */
1085          0xfffc,                /* dst_mask */
1086          FALSE),                /* pcrel_offset */
1087
1088   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1089   HOWTO (R_PPC64_GOT16_DS,      /* type */
1090          0,                     /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_GOT16_DS",    /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xfffc,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1104   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1105          0,                     /* rightshift */
1106          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1107          16,                    /* bitsize */
1108          FALSE,                 /* pc_relative */
1109          0,                     /* bitpos */
1110          complain_overflow_dont, /* complain_on_overflow */
1111          ppc64_elf_unhandled_reloc, /* special_function */
1112          "R_PPC64_GOT16_LO_DS", /* name */
1113          FALSE,                 /* partial_inplace */
1114          0,                     /* src_mask */
1115          0xfffc,                /* dst_mask */
1116          FALSE),                /* pcrel_offset */
1117
1118   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1119   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1120          0,                     /* rightshift */
1121          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1122          16,                    /* bitsize */
1123          FALSE,                 /* pc_relative */
1124          0,                     /* bitpos */
1125          complain_overflow_dont, /* complain_on_overflow */
1126          ppc64_elf_unhandled_reloc, /* special_function */
1127          "R_PPC64_PLT16_LO_DS", /* name */
1128          FALSE,                 /* partial_inplace */
1129          0,                     /* src_mask */
1130          0xfffc,                /* dst_mask */
1131          FALSE),                /* pcrel_offset */
1132
1133   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1134   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1135          0,                     /* rightshift */
1136          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1137          16,                    /* bitsize */
1138          FALSE,                 /* pc_relative */
1139          0,                     /* bitpos */
1140          complain_overflow_bitfield, /* complain_on_overflow */
1141          ppc64_elf_sectoff_reloc, /* special_function */
1142          "R_PPC64_SECTOFF_DS",  /* name */
1143          FALSE,                 /* partial_inplace */
1144          0,                     /* src_mask */
1145          0xfffc,                /* dst_mask */
1146          FALSE),                /* pcrel_offset */
1147
1148   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1149   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1150          0,                     /* rightshift */
1151          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1152          16,                    /* bitsize */
1153          FALSE,                 /* pc_relative */
1154          0,                     /* bitpos */
1155          complain_overflow_dont, /* complain_on_overflow */
1156          ppc64_elf_sectoff_reloc, /* special_function */
1157          "R_PPC64_SECTOFF_LO_DS",/* name */
1158          FALSE,                 /* partial_inplace */
1159          0,                     /* src_mask */
1160          0xfffc,                /* dst_mask */
1161          FALSE),                /* pcrel_offset */
1162
1163   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1164   HOWTO (R_PPC64_TOC16_DS,      /* type */
1165          0,                     /* rightshift */
1166          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1167          16,                    /* bitsize */
1168          FALSE,                 /* pc_relative */
1169          0,                     /* bitpos */
1170          complain_overflow_signed, /* complain_on_overflow */
1171          ppc64_elf_toc_reloc,   /* special_function */
1172          "R_PPC64_TOC16_DS",    /* name */
1173          FALSE,                 /* partial_inplace */
1174          0,                     /* src_mask */
1175          0xfffc,                /* dst_mask */
1176          FALSE),                /* pcrel_offset */
1177
1178   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1179   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1180          0,                     /* rightshift */
1181          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1182          16,                    /* bitsize */
1183          FALSE,                 /* pc_relative */
1184          0,                     /* bitpos */
1185          complain_overflow_dont, /* complain_on_overflow */
1186          ppc64_elf_toc_reloc,   /* special_function */
1187          "R_PPC64_TOC16_LO_DS", /* name */
1188          FALSE,                 /* partial_inplace */
1189          0,                     /* src_mask */
1190          0xfffc,                /* dst_mask */
1191          FALSE),                /* pcrel_offset */
1192
1193   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1194   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1195     HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1196          0,                     /* rightshift */
1197          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1198          16,                    /* bitsize */
1199          FALSE,                 /* pc_relative */
1200          0,                     /* bitpos */
1201          complain_overflow_signed, /* complain_on_overflow */
1202          ppc64_elf_unhandled_reloc, /* special_function */
1203          "R_PPC64_PLTGOT16_DS", /* name */
1204          FALSE,                 /* partial_inplace */
1205          0,                     /* src_mask */
1206          0xfffc,                /* dst_mask */
1207          FALSE),                /* pcrel_offset */
1208
1209   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1210   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1211   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1212          0,                     /* rightshift */
1213          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1214          16,                    /* bitsize */
1215          FALSE,                 /* pc_relative */
1216          0,                     /* bitpos */
1217          complain_overflow_dont, /* complain_on_overflow */
1218          ppc64_elf_unhandled_reloc, /* special_function */
1219          "R_PPC64_PLTGOT16_LO_DS",/* name */
1220          FALSE,                 /* partial_inplace */
1221          0,                     /* src_mask */
1222          0xfffc,                /* dst_mask */
1223          FALSE),                /* pcrel_offset */
1224
1225   /* Marker reloc for TLS.  */
1226   HOWTO (R_PPC64_TLS,
1227          0,                     /* rightshift */
1228          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1229          32,                    /* bitsize */
1230          FALSE,                 /* pc_relative */
1231          0,                     /* bitpos */
1232          complain_overflow_dont, /* complain_on_overflow */
1233          bfd_elf_generic_reloc, /* special_function */
1234          "R_PPC64_TLS",         /* name */
1235          FALSE,                 /* partial_inplace */
1236          0,                     /* src_mask */
1237          0,                     /* dst_mask */
1238          FALSE),                /* pcrel_offset */
1239
1240   /* Computes the load module index of the load module that contains the
1241      definition of its TLS sym.  */
1242   HOWTO (R_PPC64_DTPMOD64,
1243          0,                     /* rightshift */
1244          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          64,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_unhandled_reloc, /* special_function */
1250          "R_PPC64_DTPMOD64",    /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          ONES (64),             /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Computes a dtv-relative displacement, the difference between the value
1257      of sym+add and the base address of the thread-local storage block that
1258      contains the definition of sym, minus 0x8000.  */
1259   HOWTO (R_PPC64_DTPREL64,
1260          0,                     /* rightshift */
1261          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1262          64,                    /* bitsize */
1263          FALSE,                 /* pc_relative */
1264          0,                     /* bitpos */
1265          complain_overflow_dont, /* complain_on_overflow */
1266          ppc64_elf_unhandled_reloc, /* special_function */
1267          "R_PPC64_DTPREL64",    /* name */
1268          FALSE,                 /* partial_inplace */
1269          0,                     /* src_mask */
1270          ONES (64),             /* dst_mask */
1271          FALSE),                /* pcrel_offset */
1272
1273   /* A 16 bit dtprel reloc.  */
1274   HOWTO (R_PPC64_DTPREL16,
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_signed, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_DTPREL16",    /* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xffff,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Like DTPREL16, but no overflow.  */
1289   HOWTO (R_PPC64_DTPREL16_LO,
1290          0,                     /* rightshift */
1291          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          16,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          ppc64_elf_unhandled_reloc, /* special_function */
1297          "R_PPC64_DTPREL16_LO", /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0xffff,                /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1304   HOWTO (R_PPC64_DTPREL16_HI,
1305          16,                    /* rightshift */
1306          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1307          16,                    /* bitsize */
1308          FALSE,                 /* pc_relative */
1309          0,                     /* bitpos */
1310          complain_overflow_dont, /* complain_on_overflow */
1311          ppc64_elf_unhandled_reloc, /* special_function */
1312          "R_PPC64_DTPREL16_HI", /* name */
1313          FALSE,                 /* partial_inplace */
1314          0,                     /* src_mask */
1315          0xffff,                /* dst_mask */
1316          FALSE),                /* pcrel_offset */
1317
1318   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1319   HOWTO (R_PPC64_DTPREL16_HA,
1320          16,                    /* rightshift */
1321          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1322          16,                    /* bitsize */
1323          FALSE,                 /* pc_relative */
1324          0,                     /* bitpos */
1325          complain_overflow_dont, /* complain_on_overflow */
1326          ppc64_elf_unhandled_reloc, /* special_function */
1327          "R_PPC64_DTPREL16_HA", /* name */
1328          FALSE,                 /* partial_inplace */
1329          0,                     /* src_mask */
1330          0xffff,                /* dst_mask */
1331          FALSE),                /* pcrel_offset */
1332
1333   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1334   HOWTO (R_PPC64_DTPREL16_HIGHER,
1335          32,                    /* rightshift */
1336          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1337          16,                    /* bitsize */
1338          FALSE,                 /* pc_relative */
1339          0,                     /* bitpos */
1340          complain_overflow_dont, /* complain_on_overflow */
1341          ppc64_elf_unhandled_reloc, /* special_function */
1342          "R_PPC64_DTPREL16_HIGHER", /* name */
1343          FALSE,                 /* partial_inplace */
1344          0,                     /* src_mask */
1345          0xffff,                /* dst_mask */
1346          FALSE),                /* pcrel_offset */
1347
1348   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1349   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1350          32,                    /* rightshift */
1351          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1352          16,                    /* bitsize */
1353          FALSE,                 /* pc_relative */
1354          0,                     /* bitpos */
1355          complain_overflow_dont, /* complain_on_overflow */
1356          ppc64_elf_unhandled_reloc, /* special_function */
1357          "R_PPC64_DTPREL16_HIGHERA", /* name */
1358          FALSE,                 /* partial_inplace */
1359          0,                     /* src_mask */
1360          0xffff,                /* dst_mask */
1361          FALSE),                /* pcrel_offset */
1362
1363   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1364   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1365          48,                    /* rightshift */
1366          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          16,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL16_HIGHEST", /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          0xffff,                /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1379   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1380          48,                    /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_dont, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but for insns with a DS field.  */
1394   HOWTO (R_PPC64_DTPREL16_DS,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_signed, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_DS", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xfffc,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_DS, but no overflow.  */
1409   HOWTO (R_PPC64_DTPREL16_LO_DS,
1410          0,                     /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_dont, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_LO_DS", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xfffc,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Computes a tp-relative displacement, the difference between the value of
1424      sym+add and the value of the thread pointer (r13).  */
1425   HOWTO (R_PPC64_TPREL64,
1426          0,                     /* rightshift */
1427          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1428          64,                    /* bitsize */
1429          FALSE,                 /* pc_relative */
1430          0,                     /* bitpos */
1431          complain_overflow_dont, /* complain_on_overflow */
1432          ppc64_elf_unhandled_reloc, /* special_function */
1433          "R_PPC64_TPREL64",     /* name */
1434          FALSE,                 /* partial_inplace */
1435          0,                     /* src_mask */
1436          ONES (64),             /* dst_mask */
1437          FALSE),                /* pcrel_offset */
1438
1439   /* A 16 bit tprel reloc.  */
1440   HOWTO (R_PPC64_TPREL16,
1441          0,                     /* rightshift */
1442          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1443          16,                    /* bitsize */
1444          FALSE,                 /* pc_relative */
1445          0,                     /* bitpos */
1446          complain_overflow_signed, /* complain_on_overflow */
1447          ppc64_elf_unhandled_reloc, /* special_function */
1448          "R_PPC64_TPREL16",     /* name */
1449          FALSE,                 /* partial_inplace */
1450          0,                     /* src_mask */
1451          0xffff,                /* dst_mask */
1452          FALSE),                /* pcrel_offset */
1453
1454   /* Like TPREL16, but no overflow.  */
1455   HOWTO (R_PPC64_TPREL16_LO,
1456          0,                     /* rightshift */
1457          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1458          16,                    /* bitsize */
1459          FALSE,                 /* pc_relative */
1460          0,                     /* bitpos */
1461          complain_overflow_dont, /* complain_on_overflow */
1462          ppc64_elf_unhandled_reloc, /* special_function */
1463          "R_PPC64_TPREL16_LO",  /* name */
1464          FALSE,                 /* partial_inplace */
1465          0,                     /* src_mask */
1466          0xffff,                /* dst_mask */
1467          FALSE),                /* pcrel_offset */
1468
1469   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1470   HOWTO (R_PPC64_TPREL16_HI,
1471          16,                    /* rightshift */
1472          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1473          16,                    /* bitsize */
1474          FALSE,                 /* pc_relative */
1475          0,                     /* bitpos */
1476          complain_overflow_dont, /* complain_on_overflow */
1477          ppc64_elf_unhandled_reloc, /* special_function */
1478          "R_PPC64_TPREL16_HI",  /* name */
1479          FALSE,                 /* partial_inplace */
1480          0,                     /* src_mask */
1481          0xffff,                /* dst_mask */
1482          FALSE),                /* pcrel_offset */
1483
1484   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1485   HOWTO (R_PPC64_TPREL16_HA,
1486          16,                    /* rightshift */
1487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1488          16,                    /* bitsize */
1489          FALSE,                 /* pc_relative */
1490          0,                     /* bitpos */
1491          complain_overflow_dont, /* complain_on_overflow */
1492          ppc64_elf_unhandled_reloc, /* special_function */
1493          "R_PPC64_TPREL16_HA",  /* name */
1494          FALSE,                 /* partial_inplace */
1495          0,                     /* src_mask */
1496          0xffff,                /* dst_mask */
1497          FALSE),                /* pcrel_offset */
1498
1499   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1500   HOWTO (R_PPC64_TPREL16_HIGHER,
1501          32,                    /* rightshift */
1502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1503          16,                    /* bitsize */
1504          FALSE,                 /* pc_relative */
1505          0,                     /* bitpos */
1506          complain_overflow_dont, /* complain_on_overflow */
1507          ppc64_elf_unhandled_reloc, /* special_function */
1508          "R_PPC64_TPREL16_HIGHER",      /* name */
1509          FALSE,                 /* partial_inplace */
1510          0,                     /* src_mask */
1511          0xffff,                /* dst_mask */
1512          FALSE),                /* pcrel_offset */
1513
1514   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1515   HOWTO (R_PPC64_TPREL16_HIGHERA,
1516          32,                    /* rightshift */
1517          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1518          16,                    /* bitsize */
1519          FALSE,                 /* pc_relative */
1520          0,                     /* bitpos */
1521          complain_overflow_dont, /* complain_on_overflow */
1522          ppc64_elf_unhandled_reloc, /* special_function */
1523          "R_PPC64_TPREL16_HIGHERA", /* name */
1524          FALSE,                 /* partial_inplace */
1525          0,                     /* src_mask */
1526          0xffff,                /* dst_mask */
1527          FALSE),                /* pcrel_offset */
1528
1529   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1530   HOWTO (R_PPC64_TPREL16_HIGHEST,
1531          48,                    /* rightshift */
1532          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          16,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL16_HIGHEST", /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          0xffff,                /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1545   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1546          48,                    /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_dont, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16_HIGHESTA", /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but for insns with a DS field.  */
1560   HOWTO (R_PPC64_TPREL16_DS,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_signed, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_DS",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xfffc,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_DS, but no overflow.  */
1575   HOWTO (R_PPC64_TPREL16_LO_DS,
1576          0,                     /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_dont, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_LO_DS", /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xfffc,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1590      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1591      to the first entry relative to the TOC base (r2).  */
1592   HOWTO (R_PPC64_GOT_TLSGD16,
1593          0,                     /* rightshift */
1594          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1595          16,                    /* bitsize */
1596          FALSE,                 /* pc_relative */
1597          0,                     /* bitpos */
1598          complain_overflow_signed, /* complain_on_overflow */
1599          ppc64_elf_unhandled_reloc, /* special_function */
1600          "R_PPC64_GOT_TLSGD16", /* name */
1601          FALSE,                 /* partial_inplace */
1602          0,                     /* src_mask */
1603          0xffff,                /* dst_mask */
1604          FALSE),                /* pcrel_offset */
1605
1606   /* Like GOT_TLSGD16, but no overflow.  */
1607   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1608          0,                     /* rightshift */
1609          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1610          16,                    /* bitsize */
1611          FALSE,                 /* pc_relative */
1612          0,                     /* bitpos */
1613          complain_overflow_dont, /* complain_on_overflow */
1614          ppc64_elf_unhandled_reloc, /* special_function */
1615          "R_PPC64_GOT_TLSGD16_LO", /* name */
1616          FALSE,                 /* partial_inplace */
1617          0,                     /* src_mask */
1618          0xffff,                /* dst_mask */
1619          FALSE),                /* pcrel_offset */
1620
1621   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1622   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1623          16,                    /* rightshift */
1624          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1625          16,                    /* bitsize */
1626          FALSE,                 /* pc_relative */
1627          0,                     /* bitpos */
1628          complain_overflow_dont, /* complain_on_overflow */
1629          ppc64_elf_unhandled_reloc, /* special_function */
1630          "R_PPC64_GOT_TLSGD16_HI", /* name */
1631          FALSE,                 /* partial_inplace */
1632          0,                     /* src_mask */
1633          0xffff,                /* dst_mask */
1634          FALSE),                /* pcrel_offset */
1635
1636   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1637   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1638          16,                    /* rightshift */
1639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1640          16,                    /* bitsize */
1641          FALSE,                 /* pc_relative */
1642          0,                     /* bitpos */
1643          complain_overflow_dont, /* complain_on_overflow */
1644          ppc64_elf_unhandled_reloc, /* special_function */
1645          "R_PPC64_GOT_TLSGD16_HA", /* name */
1646          FALSE,                 /* partial_inplace */
1647          0,                     /* src_mask */
1648          0xffff,                /* dst_mask */
1649          FALSE),                /* pcrel_offset */
1650
1651   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1652      with values (sym+add)@dtpmod and zero, and computes the offset to the
1653      first entry relative to the TOC base (r2).  */
1654   HOWTO (R_PPC64_GOT_TLSLD16,
1655          0,                     /* rightshift */
1656          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1657          16,                    /* bitsize */
1658          FALSE,                 /* pc_relative */
1659          0,                     /* bitpos */
1660          complain_overflow_signed, /* complain_on_overflow */
1661          ppc64_elf_unhandled_reloc, /* special_function */
1662          "R_PPC64_GOT_TLSLD16", /* name */
1663          FALSE,                 /* partial_inplace */
1664          0,                     /* src_mask */
1665          0xffff,                /* dst_mask */
1666          FALSE),                /* pcrel_offset */
1667
1668   /* Like GOT_TLSLD16, but no overflow.  */
1669   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1670          0,                     /* rightshift */
1671          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1672          16,                    /* bitsize */
1673          FALSE,                 /* pc_relative */
1674          0,                     /* bitpos */
1675          complain_overflow_dont, /* complain_on_overflow */
1676          ppc64_elf_unhandled_reloc, /* special_function */
1677          "R_PPC64_GOT_TLSLD16_LO", /* name */
1678          FALSE,                 /* partial_inplace */
1679          0,                     /* src_mask */
1680          0xffff,                /* dst_mask */
1681          FALSE),                /* pcrel_offset */
1682
1683   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1684   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1685          16,                    /* rightshift */
1686          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1687          16,                    /* bitsize */
1688          FALSE,                 /* pc_relative */
1689          0,                     /* bitpos */
1690          complain_overflow_dont, /* complain_on_overflow */
1691          ppc64_elf_unhandled_reloc, /* special_function */
1692          "R_PPC64_GOT_TLSLD16_HI", /* name */
1693          FALSE,                 /* partial_inplace */
1694          0,                     /* src_mask */
1695          0xffff,                /* dst_mask */
1696          FALSE),                /* pcrel_offset */
1697
1698   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1699   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1700          16,                    /* rightshift */
1701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1702          16,                    /* bitsize */
1703          FALSE,                 /* pc_relative */
1704          0,                     /* bitpos */
1705          complain_overflow_dont, /* complain_on_overflow */
1706          ppc64_elf_unhandled_reloc, /* special_function */
1707          "R_PPC64_GOT_TLSLD16_HA", /* name */
1708          FALSE,                 /* partial_inplace */
1709          0,                     /* src_mask */
1710          0xffff,                /* dst_mask */
1711          FALSE),                /* pcrel_offset */
1712
1713   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1714      the offset to the entry relative to the TOC base (r2).  */
1715   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1716          0,                     /* rightshift */
1717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1718          16,                    /* bitsize */
1719          FALSE,                 /* pc_relative */
1720          0,                     /* bitpos */
1721          complain_overflow_signed, /* complain_on_overflow */
1722          ppc64_elf_unhandled_reloc, /* special_function */
1723          "R_PPC64_GOT_DTPREL16_DS", /* name */
1724          FALSE,                 /* partial_inplace */
1725          0,                     /* src_mask */
1726          0xfffc,                /* dst_mask */
1727          FALSE),                /* pcrel_offset */
1728
1729   /* Like GOT_DTPREL16_DS, but no overflow.  */
1730   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1731          0,                     /* rightshift */
1732          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1733          16,                    /* bitsize */
1734          FALSE,                 /* pc_relative */
1735          0,                     /* bitpos */
1736          complain_overflow_dont, /* complain_on_overflow */
1737          ppc64_elf_unhandled_reloc, /* special_function */
1738          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1739          FALSE,                 /* partial_inplace */
1740          0,                     /* src_mask */
1741          0xfffc,                /* dst_mask */
1742          FALSE),                /* pcrel_offset */
1743
1744   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1745   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1746          16,                    /* rightshift */
1747          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1748          16,                    /* bitsize */
1749          FALSE,                 /* pc_relative */
1750          0,                     /* bitpos */
1751          complain_overflow_dont, /* complain_on_overflow */
1752          ppc64_elf_unhandled_reloc, /* special_function */
1753          "R_PPC64_GOT_DTPREL16_HI", /* name */
1754          FALSE,                 /* partial_inplace */
1755          0,                     /* src_mask */
1756          0xffff,                /* dst_mask */
1757          FALSE),                /* pcrel_offset */
1758
1759   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1760   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1761          16,                    /* rightshift */
1762          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1763          16,                    /* bitsize */
1764          FALSE,                 /* pc_relative */
1765          0,                     /* bitpos */
1766          complain_overflow_dont, /* complain_on_overflow */
1767          ppc64_elf_unhandled_reloc, /* special_function */
1768          "R_PPC64_GOT_DTPREL16_HA", /* name */
1769          FALSE,                 /* partial_inplace */
1770          0,                     /* src_mask */
1771          0xffff,                /* dst_mask */
1772          FALSE),                /* pcrel_offset */
1773
1774   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1775      offset to the entry relative to the TOC base (r2).  */
1776   HOWTO (R_PPC64_GOT_TPREL16_DS,
1777          0,                     /* rightshift */
1778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1779          16,                    /* bitsize */
1780          FALSE,                 /* pc_relative */
1781          0,                     /* bitpos */
1782          complain_overflow_signed, /* complain_on_overflow */
1783          ppc64_elf_unhandled_reloc, /* special_function */
1784          "R_PPC64_GOT_TPREL16_DS", /* name */
1785          FALSE,                 /* partial_inplace */
1786          0,                     /* src_mask */
1787          0xfffc,                /* dst_mask */
1788          FALSE),                /* pcrel_offset */
1789
1790   /* Like GOT_TPREL16_DS, but no overflow.  */
1791   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1792          0,                     /* rightshift */
1793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1794          16,                    /* bitsize */
1795          FALSE,                 /* pc_relative */
1796          0,                     /* bitpos */
1797          complain_overflow_dont, /* complain_on_overflow */
1798          ppc64_elf_unhandled_reloc, /* special_function */
1799          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1800          FALSE,                 /* partial_inplace */
1801          0,                     /* src_mask */
1802          0xfffc,                /* dst_mask */
1803          FALSE),                /* pcrel_offset */
1804
1805   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1806   HOWTO (R_PPC64_GOT_TPREL16_HI,
1807          16,                    /* rightshift */
1808          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1809          16,                    /* bitsize */
1810          FALSE,                 /* pc_relative */
1811          0,                     /* bitpos */
1812          complain_overflow_dont, /* complain_on_overflow */
1813          ppc64_elf_unhandled_reloc, /* special_function */
1814          "R_PPC64_GOT_TPREL16_HI", /* name */
1815          FALSE,                 /* partial_inplace */
1816          0,                     /* src_mask */
1817          0xffff,                /* dst_mask */
1818          FALSE),                /* pcrel_offset */
1819
1820   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1821   HOWTO (R_PPC64_GOT_TPREL16_HA,
1822          16,                    /* rightshift */
1823          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1824          16,                    /* bitsize */
1825          FALSE,                 /* pc_relative */
1826          0,                     /* bitpos */
1827          complain_overflow_dont, /* complain_on_overflow */
1828          ppc64_elf_unhandled_reloc, /* special_function */
1829          "R_PPC64_GOT_TPREL16_HA", /* name */
1830          FALSE,                 /* partial_inplace */
1831          0,                     /* src_mask */
1832          0xffff,                /* dst_mask */
1833          FALSE),                /* pcrel_offset */
1834
1835   /* GNU extension to record C++ vtable hierarchy.  */
1836   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1837          0,                     /* rightshift */
1838          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1839          0,                     /* bitsize */
1840          FALSE,                 /* pc_relative */
1841          0,                     /* bitpos */
1842          complain_overflow_dont, /* complain_on_overflow */
1843          NULL,                  /* special_function */
1844          "R_PPC64_GNU_VTINHERIT", /* name */
1845          FALSE,                 /* partial_inplace */
1846          0,                     /* src_mask */
1847          0,                     /* dst_mask */
1848          FALSE),                /* pcrel_offset */
1849
1850   /* GNU extension to record C++ vtable member usage.  */
1851   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1852          0,                     /* rightshift */
1853          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1854          0,                     /* bitsize */
1855          FALSE,                 /* pc_relative */
1856          0,                     /* bitpos */
1857          complain_overflow_dont, /* complain_on_overflow */
1858          NULL,                  /* special_function */
1859          "R_PPC64_GNU_VTENTRY", /* name */
1860          FALSE,                 /* partial_inplace */
1861          0,                     /* src_mask */
1862          0,                     /* dst_mask */
1863          FALSE),                /* pcrel_offset */
1864 };
1865
1866 \f
1867 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1868    be done.  */
1869
1870 static void
1871 ppc_howto_init (void)
1872 {
1873   unsigned int i, type;
1874
1875   for (i = 0;
1876        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1877        i++)
1878     {
1879       type = ppc64_elf_howto_raw[i].type;
1880       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1881                           / sizeof (ppc64_elf_howto_table[0])));
1882       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1883     }
1884 }
1885
1886 static reloc_howto_type *
1887 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1888                              bfd_reloc_code_real_type code)
1889 {
1890   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1891
1892   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1893     /* Initialize howto table if needed.  */
1894     ppc_howto_init ();
1895
1896   switch (code)
1897     {
1898     default:
1899       return NULL;
1900
1901     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
1902       break;
1903     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
1904       break;
1905     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
1906       break;
1907     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
1908       break;
1909     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
1910       break;
1911     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
1912       break;
1913     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
1914       break;
1915     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
1916       break;
1917     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
1918       break;
1919     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
1920       break;
1921     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
1922       break;
1923     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
1924       break;
1925     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
1926       break;
1927     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
1928       break;
1929     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
1930       break;
1931     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
1932       break;
1933     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
1934       break;
1935     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
1936       break;
1937     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
1938       break;
1939     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
1940       break;
1941     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
1942       break;
1943     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
1944       break;
1945     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
1946       break;
1947     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
1948       break;
1949     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
1950       break;
1951     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
1952       break;
1953     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
1954       break;
1955     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
1956       break;
1957     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
1958       break;
1959     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
1960       break;
1961     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
1962       break;
1963     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
1964       break;
1965     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
1966       break;
1967     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
1968       break;
1969     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
1970       break;
1971     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
1972       break;
1973     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
1974       break;
1975     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
1976       break;
1977     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
1978       break;
1979     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
1980       break;
1981     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
1982       break;
1983     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
1984       break;
1985     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
1986       break;
1987     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
1988       break;
1989     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
1990       break;
1991     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
1992       break;
1993     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
1994       break;
1995     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
1996       break;
1997     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
1998       break;
1999     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2000       break;
2001     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2002       break;
2003     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2004       break;
2005     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2006       break;
2007     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2008       break;
2009     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2010       break;
2011     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2012       break;
2013     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2014       break;
2015     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2016       break;
2017     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2018       break;
2019     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2020       break;
2021     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2022       break;
2023     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2024       break;
2025     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2026       break;
2027     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2028       break;
2029     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2030       break;
2031     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2032       break;
2033     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2034       break;
2035     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2036       break;
2037     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2038       break;
2039     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2040       break;
2041     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2042       break;
2043     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2044       break;
2045     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2046       break;
2047     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2048       break;
2049     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2050       break;
2051     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2052       break;
2053     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2054       break;
2055     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2056       break;
2057     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2058       break;
2059     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2060       break;
2061     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2062       break;
2063     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2064       break;
2065     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2066       break;
2067     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2068       break;
2069     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2070       break;
2071     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2072       break;
2073     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2074       break;
2075     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2076       break;
2077     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2078       break;
2079     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2080       break;
2081     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2082       break;
2083     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2084       break;
2085     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2086       break;
2087     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2088       break;
2089     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2090       break;
2091     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2092       break;
2093     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2094       break;
2095     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2096       break;
2097     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2098       break;
2099     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2100       break;
2101     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2102       break;
2103     }
2104
2105   return ppc64_elf_howto_table[r];
2106 };
2107
2108 /* Set the howto pointer for a PowerPC ELF reloc.  */
2109
2110 static void
2111 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2112                          Elf_Internal_Rela *dst)
2113 {
2114   unsigned int type;
2115
2116   /* Initialize howto table if needed.  */
2117   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2118     ppc_howto_init ();
2119
2120   type = ELF64_R_TYPE (dst->r_info);
2121   BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2122                       / sizeof (ppc64_elf_howto_table[0])));
2123   cache_ptr->howto = ppc64_elf_howto_table[type];
2124 }
2125
2126 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2127
2128 static bfd_reloc_status_type
2129 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2130                     void *data, asection *input_section,
2131                     bfd *output_bfd, char **error_message)
2132 {
2133   /* If this is a relocatable link (output_bfd test tells us), just
2134      call the generic function.  Any adjustment will be done at final
2135      link time.  */
2136   if (output_bfd != NULL)
2137     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2138                                   input_section, output_bfd, error_message);
2139
2140   /* Adjust the addend for sign extension of the low 16 bits.
2141      We won't actually be using the low 16 bits, so trashing them
2142      doesn't matter.  */
2143   reloc_entry->addend += 0x8000;
2144   return bfd_reloc_continue;
2145 }
2146
2147 static bfd_reloc_status_type
2148 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2149                         void *data, asection *input_section,
2150                         bfd *output_bfd, char **error_message)
2151 {
2152   if (output_bfd != NULL)
2153     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2154                                   input_section, output_bfd, error_message);
2155
2156   if (strcmp (symbol->section->name, ".opd") == 0
2157       && (symbol->section->owner->flags & DYNAMIC) == 0)
2158     {
2159       bfd_vma dest = opd_entry_value (symbol->section,
2160                                       symbol->value + reloc_entry->addend,
2161                                       NULL, NULL);
2162       if (dest != (bfd_vma) -1)
2163         reloc_entry->addend = dest - (symbol->value
2164                                       + symbol->section->output_section->vma
2165                                       + symbol->section->output_offset);
2166     }
2167   return bfd_reloc_continue;
2168 }
2169
2170 static bfd_reloc_status_type
2171 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2172                          void *data, asection *input_section,
2173                          bfd *output_bfd, char **error_message)
2174 {
2175   long insn;
2176   enum elf_ppc64_reloc_type r_type;
2177   bfd_size_type octets;
2178   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2179   bfd_boolean is_power4 = FALSE;
2180
2181   /* If this is a relocatable link (output_bfd test tells us), just
2182      call the generic function.  Any adjustment will be done at final
2183      link time.  */
2184   if (output_bfd != NULL)
2185     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2186                                   input_section, output_bfd, error_message);
2187
2188   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2189   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2190   insn &= ~(0x01 << 21);
2191   r_type = reloc_entry->howto->type;
2192   if (r_type == R_PPC64_ADDR14_BRTAKEN
2193       || r_type == R_PPC64_REL14_BRTAKEN)
2194     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2195
2196   if (is_power4)
2197     {
2198       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2199          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2200          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2201       if ((insn & (0x14 << 21)) == (0x04 << 21))
2202         insn |= 0x02 << 21;
2203       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2204         insn |= 0x08 << 21;
2205       else
2206         goto out;
2207     }
2208   else
2209     {
2210       bfd_vma target = 0;
2211       bfd_vma from;
2212
2213       if (!bfd_is_com_section (symbol->section))
2214         target = symbol->value;
2215       target += symbol->section->output_section->vma;
2216       target += symbol->section->output_offset;
2217       target += reloc_entry->addend;
2218
2219       from = (reloc_entry->address
2220               + input_section->output_offset
2221               + input_section->output_section->vma);
2222
2223       /* Invert 'y' bit if not the default.  */
2224       if ((bfd_signed_vma) (target - from) < 0)
2225         insn ^= 0x01 << 21;
2226     }
2227   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2228  out:
2229   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2230                                  input_section, output_bfd, error_message);
2231 }
2232
2233 static bfd_reloc_status_type
2234 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2235                          void *data, asection *input_section,
2236                          bfd *output_bfd, char **error_message)
2237 {
2238   /* If this is a relocatable link (output_bfd test tells us), just
2239      call the generic function.  Any adjustment will be done at final
2240      link time.  */
2241   if (output_bfd != NULL)
2242     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2243                                   input_section, output_bfd, error_message);
2244
2245   /* Subtract the symbol section base address.  */
2246   reloc_entry->addend -= symbol->section->output_section->vma;
2247   return bfd_reloc_continue;
2248 }
2249
2250 static bfd_reloc_status_type
2251 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2252                             void *data, asection *input_section,
2253                             bfd *output_bfd, char **error_message)
2254 {
2255   /* If this is a relocatable link (output_bfd test tells us), just
2256      call the generic function.  Any adjustment will be done at final
2257      link time.  */
2258   if (output_bfd != NULL)
2259     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2260                                   input_section, output_bfd, error_message);
2261
2262   /* Subtract the symbol section base address.  */
2263   reloc_entry->addend -= symbol->section->output_section->vma;
2264
2265   /* Adjust the addend for sign extension of the low 16 bits.  */
2266   reloc_entry->addend += 0x8000;
2267   return bfd_reloc_continue;
2268 }
2269
2270 static bfd_reloc_status_type
2271 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2272                      void *data, asection *input_section,
2273                      bfd *output_bfd, char **error_message)
2274 {
2275   bfd_vma TOCstart;
2276
2277   /* If this is a relocatable link (output_bfd test tells us), just
2278      call the generic function.  Any adjustment will be done at final
2279      link time.  */
2280   if (output_bfd != NULL)
2281     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2282                                   input_section, output_bfd, error_message);
2283
2284   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2285   if (TOCstart == 0)
2286     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2287
2288   /* Subtract the TOC base address.  */
2289   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2290   return bfd_reloc_continue;
2291 }
2292
2293 static bfd_reloc_status_type
2294 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2295                         void *data, asection *input_section,
2296                         bfd *output_bfd, char **error_message)
2297 {
2298   bfd_vma TOCstart;
2299
2300   /* If this is a relocatable link (output_bfd test tells us), just
2301      call the generic function.  Any adjustment will be done at final
2302      link time.  */
2303   if (output_bfd != NULL)
2304     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2305                                   input_section, output_bfd, error_message);
2306
2307   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2308   if (TOCstart == 0)
2309     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2310
2311   /* Subtract the TOC base address.  */
2312   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2313
2314   /* Adjust the addend for sign extension of the low 16 bits.  */
2315   reloc_entry->addend += 0x8000;
2316   return bfd_reloc_continue;
2317 }
2318
2319 static bfd_reloc_status_type
2320 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2321                        void *data, asection *input_section,
2322                        bfd *output_bfd, char **error_message)
2323 {
2324   bfd_vma TOCstart;
2325   bfd_size_type octets;
2326
2327   /* If this is a relocatable link (output_bfd test tells us), just
2328      call the generic function.  Any adjustment will be done at final
2329      link time.  */
2330   if (output_bfd != NULL)
2331     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2332                                   input_section, output_bfd, error_message);
2333
2334   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2335   if (TOCstart == 0)
2336     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2337
2338   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2339   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2340   return bfd_reloc_ok;
2341 }
2342
2343 static bfd_reloc_status_type
2344 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2345                            void *data, asection *input_section,
2346                            bfd *output_bfd, char **error_message)
2347 {
2348   /* If this is a relocatable link (output_bfd test tells us), just
2349      call the generic function.  Any adjustment will be done at final
2350      link time.  */
2351   if (output_bfd != NULL)
2352     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2353                                   input_section, output_bfd, error_message);
2354
2355   if (error_message != NULL)
2356     {
2357       static char buf[60];
2358       sprintf (buf, "generic linker can't handle %s",
2359                reloc_entry->howto->name);
2360       *error_message = buf;
2361     }
2362   return bfd_reloc_dangerous;
2363 }
2364
2365 struct ppc64_elf_obj_tdata
2366 {
2367   struct elf_obj_tdata elf;
2368
2369   /* Shortcuts to dynamic linker sections.  */
2370   asection *got;
2371   asection *relgot;
2372
2373   /* Used during garbage collection.  We attach global symbols defined
2374      on removed .opd entries to this section so that the sym is removed.  */
2375   asection *deleted_section;
2376
2377   /* TLS local dynamic got entry handling.  Suppose for multiple GOT
2378      sections means we potentially need one of these for each input bfd.  */
2379   union {
2380     bfd_signed_vma refcount;
2381     bfd_vma offset;
2382   } tlsld_got;
2383 };
2384
2385 #define ppc64_elf_tdata(bfd) \
2386   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2387
2388 #define ppc64_tlsld_got(bfd) \
2389   (&ppc64_elf_tdata (bfd)->tlsld_got)
2390
2391 /* Override the generic function because we store some extras.  */
2392
2393 static bfd_boolean
2394 ppc64_elf_mkobject (bfd *abfd)
2395 {
2396   bfd_size_type amt = sizeof (struct ppc64_elf_obj_tdata);
2397   abfd->tdata.any = bfd_zalloc (abfd, amt);
2398   if (abfd->tdata.any == NULL)
2399     return FALSE;
2400   return TRUE;
2401 }
2402
2403 /* Return 1 if target is one of ours.  */
2404
2405 static bfd_boolean
2406 is_ppc64_elf_target (const struct bfd_target *targ)
2407 {
2408   extern const bfd_target bfd_elf64_powerpc_vec;
2409   extern const bfd_target bfd_elf64_powerpcle_vec;
2410
2411   return targ == &bfd_elf64_powerpc_vec || targ == &bfd_elf64_powerpcle_vec;
2412 }
2413
2414 /* Fix bad default arch selected for a 64 bit input bfd when the
2415    default is 32 bit.  */
2416
2417 static bfd_boolean
2418 ppc64_elf_object_p (bfd *abfd)
2419 {
2420   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2421     {
2422       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2423
2424       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2425         {
2426           /* Relies on arch after 32 bit default being 64 bit default.  */
2427           abfd->arch_info = abfd->arch_info->next;
2428           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2429         }
2430     }
2431   return TRUE;
2432 }
2433
2434 /* Support for core dump NOTE sections.  */
2435
2436 static bfd_boolean
2437 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2438 {
2439   size_t offset, size;
2440
2441   if (note->descsz != 504)
2442     return FALSE;
2443
2444   /* pr_cursig */
2445   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2446
2447   /* pr_pid */
2448   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2449
2450   /* pr_reg */
2451   offset = 112;
2452   size = 384;
2453
2454   /* Make a ".reg/999" section.  */
2455   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2456                                           size, note->descpos + offset);
2457 }
2458
2459 static bfd_boolean
2460 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2461 {
2462   if (note->descsz != 136)
2463     return FALSE;
2464
2465   elf_tdata (abfd)->core_program
2466     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2467   elf_tdata (abfd)->core_command
2468     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2469
2470   return TRUE;
2471 }
2472
2473 /* Merge backend specific data from an object file to the output
2474    object file when linking.  */
2475
2476 static bfd_boolean
2477 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2478 {
2479   /* Check if we have the same endianess.  */
2480   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2481       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2482       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2483     {
2484       const char *msg;
2485
2486       if (bfd_big_endian (ibfd))
2487         msg = _("%B: compiled for a big endian system "
2488                 "and target is little endian");
2489       else
2490         msg = _("%B: compiled for a little endian system "
2491                 "and target is big endian");
2492
2493       (*_bfd_error_handler) (msg, ibfd);
2494
2495       bfd_set_error (bfd_error_wrong_format);
2496       return FALSE;
2497     }
2498
2499   return TRUE;
2500 }
2501
2502 /* Add extra PPC sections.  */
2503
2504 static struct bfd_elf_special_section const ppc64_elf_special_sections[]=
2505 {
2506   { ".sdata",   6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2507   { ".sbss",    5, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2508   { ".plt",     4,  0, SHT_NOBITS,   0 },
2509   { ".toc",     4,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2510   { ".toc1",    5,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2511   { ".tocbss",  7,  0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2512   { NULL,       0,  0, 0,            0 }
2513 };
2514
2515 struct _ppc64_elf_section_data
2516 {
2517   struct bfd_elf_section_data elf;
2518
2519   /* An array with one entry for each opd function descriptor.  */
2520   union
2521   {
2522     /* Points to the function code section for local opd entries.  */
2523     asection **func_sec;
2524     /* After editing .opd, adjust references to opd local syms.  */
2525     long *adjust;
2526   } opd;
2527
2528   /* An array for toc sections, indexed by offset/8.
2529      Specifies the relocation symbol index used at a given toc offset.  */
2530   unsigned *t_symndx;
2531 };
2532
2533 #define ppc64_elf_section_data(sec) \
2534   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2535
2536 static bfd_boolean
2537 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2538 {
2539   struct _ppc64_elf_section_data *sdata;
2540   bfd_size_type amt = sizeof (*sdata);
2541
2542   sdata = bfd_zalloc (abfd, amt);
2543   if (sdata == NULL)
2544     return FALSE;
2545   sec->used_by_bfd = sdata;
2546
2547   return _bfd_elf_new_section_hook (abfd, sec);
2548 }
2549
2550 static void *
2551 get_opd_info (asection * sec)
2552 {
2553   if (sec != NULL
2554       && ppc64_elf_section_data (sec) != NULL
2555       && ppc64_elf_section_data (sec)->opd.adjust != NULL)
2556     return ppc64_elf_section_data (sec)->opd.adjust;
2557   return NULL;
2558 }
2559 \f
2560 /* Parameters for the qsort hook.  */
2561 static asection *synthetic_opd;
2562 static bfd_boolean synthetic_relocatable;
2563
2564 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2565
2566 static int
2567 compare_symbols (const void *ap, const void *bp)
2568 {
2569   const asymbol *a = * (const asymbol **) ap;
2570   const asymbol *b = * (const asymbol **) bp;
2571
2572   /* Section symbols first.  */
2573   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2574     return -1;
2575   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2576     return 1;
2577
2578   /* then .opd symbols.  */
2579   if (a->section == synthetic_opd && b->section != synthetic_opd)
2580     return -1;
2581   if (a->section != synthetic_opd && b->section == synthetic_opd)
2582     return 1;
2583
2584   /* then other code symbols.  */
2585   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2586       == (SEC_CODE | SEC_ALLOC)
2587       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2588          != (SEC_CODE | SEC_ALLOC))
2589     return -1;
2590
2591   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2592       != (SEC_CODE | SEC_ALLOC)
2593       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2594          == (SEC_CODE | SEC_ALLOC))
2595     return 1;
2596
2597   if (synthetic_relocatable)
2598     {
2599       if (a->section->id < b->section->id)
2600         return -1;
2601
2602       if (a->section->id > b->section->id)
2603         return 1;
2604     }
2605
2606   if (a->value + a->section->vma < b->value + b->section->vma)
2607     return -1;
2608
2609   if (a->value + a->section->vma > b->value + b->section->vma)
2610     return 1;
2611
2612   return 0;
2613 }
2614
2615 /* Search SYMS for a symbol of the given VALUE.  */
2616
2617 static asymbol *
2618 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2619 {
2620   long mid;
2621
2622   if (id == -1)
2623     {
2624       while (lo < hi)
2625         {
2626           mid = (lo + hi) >> 1;
2627           if (syms[mid]->value + syms[mid]->section->vma < value)
2628             lo = mid + 1;
2629           else if (syms[mid]->value + syms[mid]->section->vma > value)
2630             hi = mid;
2631           else
2632             return syms[mid];
2633         }
2634     }
2635   else
2636     {
2637       while (lo < hi)
2638         {
2639           mid = (lo + hi) >> 1;
2640           if (syms[mid]->section->id < id)
2641             lo = mid + 1;
2642           else if (syms[mid]->section->id > id)
2643             hi = mid;
2644           else if (syms[mid]->value < value)
2645             lo = mid + 1;
2646           else if (syms[mid]->value > value)
2647             hi = mid;
2648           else
2649             return syms[mid];
2650         }
2651     }
2652   return NULL;
2653 }
2654
2655 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2656    entry syms.  */
2657
2658 static long
2659 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2660                                 long static_count, asymbol **static_syms,
2661                                 long dyn_count, asymbol **dyn_syms,
2662                                 asymbol **ret)
2663 {
2664   asymbol *s;
2665   long i;
2666   long count;
2667   char *names;
2668   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2669   asection *opd;
2670   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2671   asymbol **syms;
2672
2673   *ret = NULL;
2674
2675   opd = bfd_get_section_by_name (abfd, ".opd");
2676   if (opd == NULL)
2677     return 0;
2678
2679   symcount = static_count;
2680   if (!relocatable)
2681     symcount += dyn_count;
2682   if (symcount == 0)
2683     return 0;
2684
2685   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2686   if (syms == NULL)
2687     return 0;
2688
2689   if (!relocatable && static_count != 0 && dyn_count != 0)
2690     {
2691       /* Use both symbol tables.  */
2692       memcpy (syms, static_syms, static_count * sizeof (*syms));
2693       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2694     }
2695   else if (!relocatable && static_count == 0)
2696     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2697   else
2698     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2699
2700   synthetic_opd = opd;
2701   synthetic_relocatable = relocatable;
2702   qsort (syms, symcount, sizeof (*syms), compare_symbols);
2703
2704   if (!relocatable && symcount > 1)
2705     {
2706       long j;
2707       /* Trim duplicate syms, since we may have merged the normal and
2708          dynamic symbols.  Actually, we only care about syms that have
2709          different values, so trim any with the same value.  */
2710       for (i = 1, j = 1; i < symcount; ++i)
2711         if (syms[i - 1]->value + syms[i - 1]->section->vma
2712             != syms[i]->value + syms[i]->section->vma)
2713           syms[j++] = syms[i];
2714       symcount = j;
2715     }
2716
2717   i = 0;
2718   if (syms[i]->section == opd)
2719     ++i;
2720   codesecsym = i;
2721
2722   for (; i < symcount; ++i)
2723     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2724          != (SEC_CODE | SEC_ALLOC))
2725         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2726       break;
2727   codesecsymend = i;
2728
2729   for (; i < symcount; ++i)
2730     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2731       break;
2732   secsymend = i;
2733
2734   for (; i < symcount; ++i)
2735     if (syms[i]->section != opd)
2736       break;
2737   opdsymend = i;
2738
2739   for (; i < symcount; ++i)
2740     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2741         != (SEC_CODE | SEC_ALLOC))
2742       break;
2743   symcount = i;
2744
2745   count = 0;
2746   if (opdsymend == secsymend)
2747     goto done;
2748
2749   if (relocatable)
2750     {
2751       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2752       arelent *r;
2753       size_t size;
2754       long relcount;
2755
2756       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2757       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2758
2759       if (! relcount
2760           || ! (*slurp_relocs) (abfd, opd, static_syms, FALSE))
2761         goto done;
2762
2763       size = 0;
2764       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2765         {
2766           asymbol *sym;
2767
2768           while (r < opd->relocation + relcount
2769                  && r->address < syms[i]->value + opd->vma)
2770             ++r;
2771
2772           if (r == opd->relocation + relcount)
2773             break;
2774
2775           if (r->address != syms[i]->value + opd->vma)
2776             continue;
2777
2778           if (r->howto->type != R_PPC64_ADDR64)
2779             continue;
2780
2781           sym = *r->sym_ptr_ptr;
2782           if (!sym_exists_at (syms, opdsymend, symcount,
2783                               sym->section->id, sym->value + r->addend))
2784             {
2785               ++count;
2786               size += sizeof (asymbol);
2787               size += strlen (syms[i]->name) + 2;
2788             }
2789         }
2790
2791       s = *ret = bfd_malloc (size);
2792       if (s == NULL)
2793         {
2794           count = 0;
2795           goto done;
2796         }
2797
2798       names = (char *) (s + count);
2799
2800       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2801         {
2802           asymbol *sym;
2803
2804           while (r < opd->relocation + relcount
2805                  && r->address < syms[i]->value + opd->vma)
2806             ++r;
2807
2808           if (r == opd->relocation + relcount)
2809             break;
2810
2811           if (r->address != syms[i]->value + opd->vma)
2812             continue;
2813
2814           if (r->howto->type != R_PPC64_ADDR64)
2815             continue;
2816
2817           sym = *r->sym_ptr_ptr;
2818           if (!sym_exists_at (syms, opdsymend, symcount,
2819                               sym->section->id, sym->value + r->addend))
2820             {
2821               size_t len;
2822
2823               *s = *syms[i];
2824               s->section = sym->section;
2825               s->value = sym->value + r->addend;
2826               s->name = names;
2827               *names++ = '.';
2828               len = strlen (syms[i]->name);
2829               memcpy (names, syms[i]->name, len + 1);
2830               names += len + 1;
2831               s++;
2832             }
2833         }
2834     }
2835   else
2836     {
2837       bfd_byte *contents;
2838       size_t size;
2839
2840       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
2841         {
2842           if (contents)
2843             {
2844             free_contents_and_exit:
2845               free (contents);
2846             }
2847           goto done;
2848         }
2849
2850       size = 0;
2851       for (i = secsymend; i < opdsymend; ++i)
2852         {
2853           bfd_vma ent;
2854
2855           ent = bfd_get_64 (abfd, contents + syms[i]->value);
2856           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2857             {
2858               ++count;
2859               size += sizeof (asymbol);
2860               size += strlen (syms[i]->name) + 2;
2861             }
2862         }
2863
2864       s = *ret = bfd_malloc (size);
2865       if (s == NULL)
2866         {
2867           count = 0;
2868           goto free_contents_and_exit;
2869         }
2870
2871       names = (char *) (s + count);
2872
2873       for (i = secsymend; i < opdsymend; ++i)
2874         {
2875           bfd_vma ent;
2876
2877           ent = bfd_get_64 (abfd, contents + syms[i]->value);
2878           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2879             {
2880               long lo, hi;
2881               size_t len;
2882               asection *sec = abfd->sections;
2883
2884               *s = *syms[i];
2885               lo = codesecsym;
2886               hi = codesecsymend;
2887               while (lo < hi)
2888                 {
2889                   long mid = (lo + hi) >> 1;
2890                   if (syms[mid]->section->vma < ent)
2891                     lo = mid + 1;
2892                   else if (syms[mid]->section->vma > ent)
2893                     hi = mid;
2894                   else
2895                     {
2896                       sec = syms[mid]->section;
2897                       break;
2898                     }
2899                 }
2900
2901               if (lo >= hi && lo > codesecsym)
2902                 sec = syms[lo - 1]->section;
2903
2904               for (; sec != NULL; sec = sec->next)
2905                 {
2906                   if (sec->vma > ent)
2907                     break;
2908                   if ((sec->flags & SEC_ALLOC) == 0
2909                       || (sec->flags & SEC_LOAD) == 0)
2910                     break;
2911                   if ((sec->flags & SEC_CODE) != 0)
2912                     s->section = sec;
2913                 }
2914               s->value = ent - s->section->vma;
2915               s->name = names;
2916               *names++ = '.';
2917               len = strlen (syms[i]->name);
2918               memcpy (names, syms[i]->name, len + 1);
2919               names += len + 1;
2920               s++;
2921             }
2922         }
2923       free (contents);
2924     }
2925
2926  done:
2927   free (syms);
2928   return count;
2929 }
2930 \f
2931 /* The following functions are specific to the ELF linker, while
2932    functions above are used generally.  Those named ppc64_elf_* are
2933    called by the main ELF linker code.  They appear in this file more
2934    or less in the order in which they are called.  eg.
2935    ppc64_elf_check_relocs is called early in the link process,
2936    ppc64_elf_finish_dynamic_sections is one of the last functions
2937    called.
2938
2939    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2940    functions have both a function code symbol and a function descriptor
2941    symbol.  A call to foo in a relocatable object file looks like:
2942
2943    .            .text
2944    .    x:
2945    .            bl      .foo
2946    .            nop
2947
2948    The function definition in another object file might be:
2949
2950    .            .section .opd
2951    .    foo:    .quad   .foo
2952    .            .quad   .TOC.@tocbase
2953    .            .quad   0
2954    .
2955    .            .text
2956    .    .foo:   blr
2957
2958    When the linker resolves the call during a static link, the branch
2959    unsurprisingly just goes to .foo and the .opd information is unused.
2960    If the function definition is in a shared library, things are a little
2961    different:  The call goes via a plt call stub, the opd information gets
2962    copied to the plt, and the linker patches the nop.
2963
2964    .    x:
2965    .            bl      .foo_stub
2966    .            ld      2,40(1)
2967    .
2968    .
2969    .    .foo_stub:
2970    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
2971    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
2972    .            std     2,40(1)                 # this is the general idea
2973    .            ld      11,0(12)
2974    .            ld      2,8(12)
2975    .            mtctr   11
2976    .            ld      11,16(12)
2977    .            bctr
2978    .
2979    .            .section .plt
2980    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
2981
2982    The "reloc ()" notation is supposed to indicate that the linker emits
2983    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
2984    copying.
2985
2986    What are the difficulties here?  Well, firstly, the relocations
2987    examined by the linker in check_relocs are against the function code
2988    sym .foo, while the dynamic relocation in the plt is emitted against
2989    the function descriptor symbol, foo.  Somewhere along the line, we need
2990    to carefully copy dynamic link information from one symbol to the other.
2991    Secondly, the generic part of the elf linker will make .foo a dynamic
2992    symbol as is normal for most other backends.  We need foo dynamic
2993    instead, at least for an application final link.  However, when
2994    creating a shared library containing foo, we need to have both symbols
2995    dynamic so that references to .foo are satisfied during the early
2996    stages of linking.  Otherwise the linker might decide to pull in a
2997    definition from some other object, eg. a static library.
2998
2999    Update: As of August 2004, we support a new convention.  Function
3000    calls may use the function descriptor symbol, ie. "bl foo".  This
3001    behaves exactly as "bl .foo".  */
3002
3003 /* The linker needs to keep track of the number of relocs that it
3004    decides to copy as dynamic relocs in check_relocs for each symbol.
3005    This is so that it can later discard them if they are found to be
3006    unnecessary.  We store the information in a field extending the
3007    regular ELF linker hash table.  */
3008
3009 struct ppc_dyn_relocs
3010 {
3011   struct ppc_dyn_relocs *next;
3012
3013   /* The input section of the reloc.  */
3014   asection *sec;
3015
3016   /* Total number of relocs copied for the input section.  */
3017   bfd_size_type count;
3018
3019   /* Number of pc-relative relocs copied for the input section.  */
3020   bfd_size_type pc_count;
3021 };
3022
3023 /* Track GOT entries needed for a given symbol.  We might need more
3024    than one got entry per symbol.  */
3025 struct got_entry
3026 {
3027   struct got_entry *next;
3028
3029   /* The symbol addend that we'll be placing in the GOT.  */
3030   bfd_vma addend;
3031
3032   /* Unlike other ELF targets, we use separate GOT entries for the same
3033      symbol referenced from different input files.  This is to support
3034      automatic multiple TOC/GOT sections, where the TOC base can vary
3035      from one input file to another.
3036
3037      Point to the BFD owning this GOT entry.  */
3038   bfd *owner;
3039
3040   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3041      TLS_TPREL or TLS_DTPREL for tls entries.  */
3042   char tls_type;
3043
3044   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
3045   union
3046     {
3047       bfd_signed_vma refcount;
3048       bfd_vma offset;
3049     } got;
3050 };
3051
3052 /* The same for PLT.  */
3053 struct plt_entry
3054 {
3055   struct plt_entry *next;
3056
3057   bfd_vma addend;
3058
3059   union
3060     {
3061       bfd_signed_vma refcount;
3062       bfd_vma offset;
3063     } plt;
3064 };
3065
3066 /* Of those relocs that might be copied as dynamic relocs, this macro
3067    selects those that must be copied when linking a shared library,
3068    even when the symbol is local.  */
3069
3070 #define MUST_BE_DYN_RELOC(RTYPE)                \
3071   ((RTYPE) != R_PPC64_REL32                     \
3072    && (RTYPE) != R_PPC64_REL64                  \
3073    && (RTYPE) != R_PPC64_REL30)
3074
3075 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3076    copying dynamic variables from a shared lib into an app's dynbss
3077    section, and instead use a dynamic relocation to point into the
3078    shared lib.  With code that gcc generates, it's vital that this be
3079    enabled;  In the PowerPC64 ABI, the address of a function is actually
3080    the address of a function descriptor, which resides in the .opd
3081    section.  gcc uses the descriptor directly rather than going via the
3082    GOT as some other ABI's do, which means that initialized function
3083    pointers must reference the descriptor.  Thus, a function pointer
3084    initialized to the address of a function in a shared library will
3085    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3086    redefines the function descriptor symbol to point to the copy.  This
3087    presents a problem as a plt entry for that function is also
3088    initialized from the function descriptor symbol and the copy reloc
3089    may not be initialized first.  */
3090 #define ELIMINATE_COPY_RELOCS 1
3091
3092 /* Section name for stubs is the associated section name plus this
3093    string.  */
3094 #define STUB_SUFFIX ".stub"
3095
3096 /* Linker stubs.
3097    ppc_stub_long_branch:
3098    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3099    destination, but a 24 bit branch in a stub section will reach.
3100    .    b       dest
3101
3102    ppc_stub_plt_branch:
3103    Similar to the above, but a 24 bit branch in the stub section won't
3104    reach its destination.
3105    .    addis   %r12,%r2,xxx@toc@ha
3106    .    ld      %r11,xxx@toc@l(%r12)
3107    .    mtctr   %r11
3108    .    bctr
3109
3110    ppc_stub_plt_call:
3111    Used to call a function in a shared library.  If it so happens that
3112    the plt entry referenced crosses a 64k boundary, then an extra
3113    "addis %r12,%r12,1" will be inserted before the load at xxx+8 or
3114    xxx+16 as appropriate.
3115    .    addis   %r12,%r2,xxx@toc@ha
3116    .    std     %r2,40(%r1)
3117    .    ld      %r11,xxx+0@toc@l(%r12)
3118    .    ld      %r2,xxx+8@toc@l(%r12)
3119    .    mtctr   %r11
3120    .    ld      %r11,xxx+16@toc@l(%r12)
3121    .    bctr
3122
3123    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3124    code to adjust the value and save r2 to support multiple toc sections.
3125    A ppc_stub_long_branch with an r2 offset looks like:
3126    .    std     %r2,40(%r1)
3127    .    addis   %r2,%r2,off@ha
3128    .    addi    %r2,%r2,off@l
3129    .    b       dest
3130
3131    A ppc_stub_plt_branch with an r2 offset looks like:
3132    .    std     %r2,40(%r1)
3133    .    addis   %r12,%r2,xxx@toc@ha
3134    .    ld      %r11,xxx@toc@l(%r12)
3135    .    addis   %r2,%r2,off@ha
3136    .    addi    %r2,%r2,off@l
3137    .    mtctr   %r11
3138    .    bctr
3139 */
3140
3141 enum ppc_stub_type {
3142   ppc_stub_none,
3143   ppc_stub_long_branch,
3144   ppc_stub_long_branch_r2off,
3145   ppc_stub_plt_branch,
3146   ppc_stub_plt_branch_r2off,
3147   ppc_stub_plt_call
3148 };
3149
3150 struct ppc_stub_hash_entry {
3151
3152   /* Base hash table entry structure.  */
3153   struct bfd_hash_entry root;
3154
3155   enum ppc_stub_type stub_type;
3156
3157   /* The stub section.  */
3158   asection *stub_sec;
3159
3160   /* Offset within stub_sec of the beginning of this stub.  */
3161   bfd_vma stub_offset;
3162
3163   /* Given the symbol's value and its section we can determine its final
3164      value when building the stubs (so the stub knows where to jump.  */
3165   bfd_vma target_value;
3166   asection *target_section;
3167
3168   /* The symbol table entry, if any, that this was derived from.  */
3169   struct ppc_link_hash_entry *h;
3170
3171   /* And the reloc addend that this was derived from.  */
3172   bfd_vma addend;
3173
3174   /* Where this stub is being called from, or, in the case of combined
3175      stub sections, the first input section in the group.  */
3176   asection *id_sec;
3177 };
3178
3179 struct ppc_branch_hash_entry {
3180
3181   /* Base hash table entry structure.  */
3182   struct bfd_hash_entry root;
3183
3184   /* Offset within .branch_lt.  */
3185   unsigned int offset;
3186
3187   /* Generation marker.  */
3188   unsigned int iter;
3189 };
3190
3191 struct ppc_link_hash_entry
3192 {
3193   struct elf_link_hash_entry elf;
3194
3195   /* A pointer to the most recently used stub hash entry against this
3196      symbol.  */
3197   struct ppc_stub_hash_entry *stub_cache;
3198
3199   /* Track dynamic relocs copied for this symbol.  */
3200   struct ppc_dyn_relocs *dyn_relocs;
3201
3202   /* Link between function code and descriptor symbols.  */
3203   struct ppc_link_hash_entry *oh;
3204
3205   /* Flag function code and descriptor symbols.  */
3206   unsigned int is_func:1;
3207   unsigned int is_func_descriptor:1;
3208
3209   /* Whether global opd sym has been adjusted or not.
3210      After ppc64_elf_edit_opd has run, this flag should be set for all
3211      globals defined in any opd section.  */
3212   unsigned int adjust_done:1;
3213
3214   /* Set if we twiddled this symbol to weak at some stage.  */
3215   unsigned int was_undefined:1;
3216
3217   /* Contexts in which symbol is used in the GOT (or TOC).
3218      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3219      corresponding relocs are encountered during check_relocs.
3220      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3221      indicate the corresponding GOT entry type is not needed.
3222      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3223      a TPREL one.  We use a separate flag rather than setting TPREL
3224      just for convenience in distinguishing the two cases.  */
3225 #define TLS_GD           1      /* GD reloc. */
3226 #define TLS_LD           2      /* LD reloc. */
3227 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3228 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3229 #define TLS_TLS         16      /* Any TLS reloc.  */
3230 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3231 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3232   char tls_mask;
3233 };
3234
3235 /* ppc64 ELF linker hash table.  */
3236
3237 struct ppc_link_hash_table
3238 {
3239   struct elf_link_hash_table elf;
3240
3241   /* The stub hash table.  */
3242   struct bfd_hash_table stub_hash_table;
3243
3244   /* Another hash table for plt_branch stubs.  */
3245   struct bfd_hash_table branch_hash_table;
3246
3247   /* Linker stub bfd.  */
3248   bfd *stub_bfd;
3249
3250   /* Linker call-backs.  */
3251   asection * (*add_stub_section) (const char *, asection *);
3252   void (*layout_sections_again) (void);
3253
3254   /* Array to keep track of which stub sections have been created, and
3255      information on stub grouping.  */
3256   struct map_stub {
3257     /* This is the section to which stubs in the group will be attached.  */
3258     asection *link_sec;
3259     /* The stub section.  */
3260     asection *stub_sec;
3261     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3262     bfd_vma toc_off;
3263   } *stub_group;
3264
3265   /* Temp used when calculating TOC pointers.  */
3266   bfd_vma toc_curr;
3267
3268   /* Highest input section id.  */
3269   int top_id;
3270
3271   /* Highest output section index.  */
3272   int top_index;
3273
3274   /* List of input sections for each output section.  */
3275   asection **input_list;
3276
3277   /* Short-cuts to get to dynamic linker sections.  */
3278   asection *got;
3279   asection *plt;
3280   asection *relplt;
3281   asection *dynbss;
3282   asection *relbss;
3283   asection *glink;
3284   asection *sfpr;
3285   asection *brlt;
3286   asection *relbrlt;
3287
3288   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3289   struct ppc_link_hash_entry *tls_get_addr;
3290   struct ppc_link_hash_entry *tls_get_addr_fd;
3291
3292   /* Statistics.  */
3293   unsigned long stub_count[ppc_stub_plt_call];
3294
3295   /* Number of stubs against global syms.  */
3296   unsigned long stub_globals;
3297
3298   /* Set if we should emit symbols for stubs.  */
3299   unsigned int emit_stub_syms:1;
3300
3301   /* Set on error.  */
3302   unsigned int stub_error:1;
3303
3304   /* Flag set when small branches are detected.  Used to
3305      select suitable defaults for the stub group size.  */
3306   unsigned int has_14bit_branch:1;
3307
3308   /* Temp used by ppc64_elf_check_directives.  */
3309   unsigned int twiddled_syms:1;
3310
3311   /* Incremented every time we size stubs.  */
3312   unsigned int stub_iteration;
3313
3314   /* Small local sym to section mapping cache.  */
3315   struct sym_sec_cache sym_sec;
3316 };
3317
3318 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3319
3320 #define ppc_hash_table(p) \
3321   ((struct ppc_link_hash_table *) ((p)->hash))
3322
3323 #define ppc_stub_hash_lookup(table, string, create, copy) \
3324   ((struct ppc_stub_hash_entry *) \
3325    bfd_hash_lookup ((table), (string), (create), (copy)))
3326
3327 #define ppc_branch_hash_lookup(table, string, create, copy) \
3328   ((struct ppc_branch_hash_entry *) \
3329    bfd_hash_lookup ((table), (string), (create), (copy)))
3330
3331 /* Create an entry in the stub hash table.  */
3332
3333 static struct bfd_hash_entry *
3334 stub_hash_newfunc (struct bfd_hash_entry *entry,
3335                    struct bfd_hash_table *table,
3336                    const char *string)
3337 {
3338   /* Allocate the structure if it has not already been allocated by a
3339      subclass.  */
3340   if (entry == NULL)
3341     {
3342       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3343       if (entry == NULL)
3344         return entry;
3345     }
3346
3347   /* Call the allocation method of the superclass.  */
3348   entry = bfd_hash_newfunc (entry, table, string);
3349   if (entry != NULL)
3350     {
3351       struct ppc_stub_hash_entry *eh;
3352
3353       /* Initialize the local fields.  */
3354       eh = (struct ppc_stub_hash_entry *) entry;
3355       eh->stub_type = ppc_stub_none;
3356       eh->stub_sec = NULL;
3357       eh->stub_offset = 0;
3358       eh->target_value = 0;
3359       eh->target_section = NULL;
3360       eh->h = NULL;
3361       eh->id_sec = NULL;
3362     }
3363
3364   return entry;
3365 }
3366
3367 /* Create an entry in the branch hash table.  */
3368
3369 static struct bfd_hash_entry *
3370 branch_hash_newfunc (struct bfd_hash_entry *entry,
3371                      struct bfd_hash_table *table,
3372                      const char *string)
3373 {
3374   /* Allocate the structure if it has not already been allocated by a
3375      subclass.  */
3376   if (entry == NULL)
3377     {
3378       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3379       if (entry == NULL)
3380         return entry;
3381     }
3382
3383   /* Call the allocation method of the superclass.  */
3384   entry = bfd_hash_newfunc (entry, table, string);
3385   if (entry != NULL)
3386     {
3387       struct ppc_branch_hash_entry *eh;
3388
3389       /* Initialize the local fields.  */
3390       eh = (struct ppc_branch_hash_entry *) entry;
3391       eh->offset = 0;
3392       eh->iter = 0;
3393     }
3394
3395   return entry;
3396 }
3397
3398 /* Create an entry in a ppc64 ELF linker hash table.  */
3399
3400 static struct bfd_hash_entry *
3401 link_hash_newfunc (struct bfd_hash_entry *entry,
3402                    struct bfd_hash_table *table,
3403                    const char *string)
3404 {
3405   /* Allocate the structure if it has not already been allocated by a
3406      subclass.  */
3407   if (entry == NULL)
3408     {
3409       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3410       if (entry == NULL)
3411         return entry;
3412     }
3413
3414   /* Call the allocation method of the superclass.  */
3415   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3416   if (entry != NULL)
3417     {
3418       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3419
3420       eh->stub_cache = NULL;
3421       eh->dyn_relocs = NULL;
3422       eh->oh = NULL;
3423       eh->is_func = 0;
3424       eh->is_func_descriptor = 0;
3425       eh->adjust_done = 0;
3426       eh->was_undefined = 0;
3427       eh->tls_mask = 0;
3428     }
3429
3430   return entry;
3431 }
3432
3433 /* Create a ppc64 ELF linker hash table.  */
3434
3435 static struct bfd_link_hash_table *
3436 ppc64_elf_link_hash_table_create (bfd *abfd)
3437 {
3438   struct ppc_link_hash_table *htab;
3439   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3440
3441   htab = bfd_zmalloc (amt);
3442   if (htab == NULL)
3443     return NULL;
3444
3445   if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
3446     {
3447       free (htab);
3448       return NULL;
3449     }
3450
3451   /* Init the stub hash table too.  */
3452   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc))
3453     return NULL;
3454
3455   /* And the branch hash table.  */
3456   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc))
3457     return NULL;
3458
3459   /* Initializing two fields of the union is just cosmetic.  We really
3460      only care about glist, but when compiled on a 32-bit host the
3461      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3462      debugger inspection of these fields look nicer.  */
3463   htab->elf.init_refcount.refcount = 0;
3464   htab->elf.init_refcount.glist = NULL;
3465   htab->elf.init_offset.offset = 0;
3466   htab->elf.init_offset.glist = NULL;
3467
3468   return &htab->elf.root;
3469 }
3470
3471 /* Free the derived linker hash table.  */
3472
3473 static void
3474 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3475 {
3476   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3477
3478   bfd_hash_table_free (&ret->stub_hash_table);
3479   bfd_hash_table_free (&ret->branch_hash_table);
3480   _bfd_generic_link_hash_table_free (hash);
3481 }
3482
3483 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3484
3485 void
3486 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3487 {
3488   struct ppc_link_hash_table *htab;
3489
3490   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3491
3492 /* Always hook our dynamic sections into the first bfd, which is the
3493    linker created stub bfd.  This ensures that the GOT header is at
3494    the start of the output TOC section.  */
3495   htab = ppc_hash_table (info);
3496   htab->stub_bfd = abfd;
3497   htab->elf.dynobj = abfd;
3498 }
3499
3500 /* Build a name for an entry in the stub hash table.  */
3501
3502 static char *
3503 ppc_stub_name (const asection *input_section,
3504                const asection *sym_sec,
3505                const struct ppc_link_hash_entry *h,
3506                const Elf_Internal_Rela *rel)
3507 {
3508   char *stub_name;
3509   bfd_size_type len;
3510
3511   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3512      offsets from a sym as a branch target?  In fact, we could
3513      probably assume the addend is always zero.  */
3514   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3515
3516   if (h)
3517     {
3518       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3519       stub_name = bfd_malloc (len);
3520       if (stub_name != NULL)
3521         {
3522           sprintf (stub_name, "%08x.%s+%x",
3523                    input_section->id & 0xffffffff,
3524                    h->elf.root.root.string,
3525                    (int) rel->r_addend & 0xffffffff);
3526         }
3527     }
3528   else
3529     {
3530       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3531       stub_name = bfd_malloc (len);
3532       if (stub_name != NULL)
3533         {
3534           sprintf (stub_name, "%08x.%x:%x+%x",
3535                    input_section->id & 0xffffffff,
3536                    sym_sec->id & 0xffffffff,
3537                    (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3538                    (int) rel->r_addend & 0xffffffff);
3539         }
3540     }
3541   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3542     stub_name[len - 2] = 0;
3543   return stub_name;
3544 }
3545
3546 /* Look up an entry in the stub hash.  Stub entries are cached because
3547    creating the stub name takes a bit of time.  */
3548
3549 static struct ppc_stub_hash_entry *
3550 ppc_get_stub_entry (const asection *input_section,
3551                     const asection *sym_sec,
3552                     struct ppc_link_hash_entry *h,
3553                     const Elf_Internal_Rela *rel,
3554                     struct ppc_link_hash_table *htab)
3555 {
3556   struct ppc_stub_hash_entry *stub_entry;
3557   const asection *id_sec;
3558
3559   /* If this input section is part of a group of sections sharing one
3560      stub section, then use the id of the first section in the group.
3561      Stub names need to include a section id, as there may well be
3562      more than one stub used to reach say, printf, and we need to
3563      distinguish between them.  */
3564   id_sec = htab->stub_group[input_section->id].link_sec;
3565
3566   if (h != NULL && h->stub_cache != NULL
3567       && h->stub_cache->h == h
3568       && h->stub_cache->id_sec == id_sec)
3569     {
3570       stub_entry = h->stub_cache;
3571     }
3572   else
3573     {
3574       char *stub_name;
3575
3576       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3577       if (stub_name == NULL)
3578         return NULL;
3579
3580       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3581                                          stub_name, FALSE, FALSE);
3582       if (h != NULL)
3583         h->stub_cache = stub_entry;
3584
3585       free (stub_name);
3586     }
3587
3588   return stub_entry;
3589 }
3590
3591 /* Add a new stub entry to the stub hash.  Not all fields of the new
3592    stub entry are initialised.  */
3593
3594 static struct ppc_stub_hash_entry *
3595 ppc_add_stub (const char *stub_name,
3596               asection *section,
3597               struct ppc_link_hash_table *htab)
3598 {
3599   asection *link_sec;
3600   asection *stub_sec;
3601   struct ppc_stub_hash_entry *stub_entry;
3602
3603   link_sec = htab->stub_group[section->id].link_sec;
3604   stub_sec = htab->stub_group[section->id].stub_sec;
3605   if (stub_sec == NULL)
3606     {
3607       stub_sec = htab->stub_group[link_sec->id].stub_sec;
3608       if (stub_sec == NULL)
3609         {
3610           size_t namelen;
3611           bfd_size_type len;
3612           char *s_name;
3613
3614           namelen = strlen (link_sec->name);
3615           len = namelen + sizeof (STUB_SUFFIX);
3616           s_name = bfd_alloc (htab->stub_bfd, len);
3617           if (s_name == NULL)
3618             return NULL;
3619
3620           memcpy (s_name, link_sec->name, namelen);
3621           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3622           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3623           if (stub_sec == NULL)
3624             return NULL;
3625           htab->stub_group[link_sec->id].stub_sec = stub_sec;
3626         }
3627       htab->stub_group[section->id].stub_sec = stub_sec;
3628     }
3629
3630   /* Enter this entry into the linker stub hash table.  */
3631   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3632                                      TRUE, FALSE);
3633   if (stub_entry == NULL)
3634     {
3635       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3636                              section->owner, stub_name);
3637       return NULL;
3638     }
3639
3640   stub_entry->stub_sec = stub_sec;
3641   stub_entry->stub_offset = 0;
3642   stub_entry->id_sec = link_sec;
3643   return stub_entry;
3644 }
3645
3646 /* Create sections for linker generated code.  */
3647
3648 static bfd_boolean
3649 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3650 {
3651   struct ppc_link_hash_table *htab;
3652   flagword flags;
3653
3654   htab = ppc_hash_table (info);
3655
3656   /* Create .sfpr for code to save and restore fp regs.  */
3657   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3658            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3659   htab->sfpr = bfd_make_section_anyway (dynobj, ".sfpr");
3660   if (htab->sfpr == NULL
3661       || ! bfd_set_section_flags (dynobj, htab->sfpr, flags)
3662       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3663     return FALSE;
3664
3665   /* Create .glink for lazy dynamic linking support.  */
3666   htab->glink = bfd_make_section_anyway (dynobj, ".glink");
3667   if (htab->glink == NULL
3668       || ! bfd_set_section_flags (dynobj, htab->glink, flags)
3669       || ! bfd_set_section_alignment (dynobj, htab->glink, 2))
3670     return FALSE;
3671
3672   /* Create .branch_lt for plt_branch stubs.  */
3673   flags = (SEC_ALLOC | SEC_LOAD
3674            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3675   htab->brlt = bfd_make_section_anyway (dynobj, ".branch_lt");
3676   if (htab->brlt == NULL
3677       || ! bfd_set_section_flags (dynobj, htab->brlt, flags)
3678       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
3679     return FALSE;
3680
3681   if (info->shared || info->emitrelocations)
3682     {
3683       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3684                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3685       htab->relbrlt = bfd_make_section_anyway (dynobj, ".rela.branch_lt");
3686       if (!htab->relbrlt
3687           || ! bfd_set_section_flags (dynobj, htab->relbrlt, flags)
3688           || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3689         return FALSE;
3690     }
3691   return TRUE;
3692 }
3693
3694 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3695    not already done.  */
3696
3697 static bfd_boolean
3698 create_got_section (bfd *abfd, struct bfd_link_info *info)
3699 {
3700   asection *got, *relgot;
3701   flagword flags;
3702   struct ppc_link_hash_table *htab = ppc_hash_table (info);
3703
3704   if (!htab->got)
3705     {
3706       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
3707         return FALSE;
3708
3709       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
3710       if (!htab->got)
3711         abort ();
3712     }
3713
3714   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3715            | SEC_LINKER_CREATED);
3716
3717   got = bfd_make_section (abfd, ".got");
3718   if (!got
3719       || !bfd_set_section_flags (abfd, got, flags)
3720       || !bfd_set_section_alignment (abfd, got, 3))
3721     return FALSE;
3722
3723   relgot = bfd_make_section (abfd, ".rela.got");
3724   if (!relgot
3725       || ! bfd_set_section_flags (abfd, relgot, flags | SEC_READONLY)
3726       || ! bfd_set_section_alignment (abfd, relgot, 3))
3727     return FALSE;
3728
3729   ppc64_elf_tdata (abfd)->got = got;
3730   ppc64_elf_tdata (abfd)->relgot = relgot;
3731   return TRUE;
3732 }
3733
3734 /* Create the dynamic sections, and set up shortcuts.  */
3735
3736 static bfd_boolean
3737 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3738 {
3739   struct ppc_link_hash_table *htab;
3740
3741   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3742     return FALSE;
3743
3744   htab = ppc_hash_table (info);
3745   if (!htab->got)
3746     htab->got = bfd_get_section_by_name (dynobj, ".got");
3747   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
3748   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
3749   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
3750   if (!info->shared)
3751     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
3752
3753   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
3754       || (!info->shared && !htab->relbss))
3755     abort ();
3756
3757   return TRUE;
3758 }
3759
3760 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3761
3762 static void
3763 ppc64_elf_copy_indirect_symbol
3764   (const struct elf_backend_data *bed ATTRIBUTE_UNUSED,
3765    struct elf_link_hash_entry *dir,
3766    struct elf_link_hash_entry *ind)
3767 {
3768   struct ppc_link_hash_entry *edir, *eind;
3769
3770   edir = (struct ppc_link_hash_entry *) dir;
3771   eind = (struct ppc_link_hash_entry *) ind;
3772
3773   /* Copy over any dynamic relocs we may have on the indirect sym.  */
3774   if (eind->dyn_relocs != NULL)
3775     {
3776       if (edir->dyn_relocs != NULL)
3777         {
3778           struct ppc_dyn_relocs **pp;
3779           struct ppc_dyn_relocs *p;
3780
3781           if (eind->elf.root.type == bfd_link_hash_indirect)
3782             abort ();
3783
3784           /* Add reloc counts against the weak sym to the strong sym
3785              list.  Merge any entries against the same section.  */
3786           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3787             {
3788               struct ppc_dyn_relocs *q;
3789
3790               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3791                 if (q->sec == p->sec)
3792                   {
3793                     q->pc_count += p->pc_count;
3794                     q->count += p->count;
3795                     *pp = p->next;
3796                     break;
3797                   }
3798               if (q == NULL)
3799                 pp = &p->next;
3800             }
3801           *pp = edir->dyn_relocs;
3802         }
3803
3804       edir->dyn_relocs = eind->dyn_relocs;
3805       eind->dyn_relocs = NULL;
3806     }
3807
3808   edir->is_func |= eind->is_func;
3809   edir->is_func_descriptor |= eind->is_func_descriptor;
3810   edir->tls_mask |= eind->tls_mask;
3811
3812   /* If called to transfer flags for a weakdef during processing
3813      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
3814      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
3815   if (!(ELIMINATE_COPY_RELOCS
3816         && eind->elf.root.type != bfd_link_hash_indirect
3817         && edir->elf.dynamic_adjusted))
3818     edir->elf.non_got_ref |= eind->elf.non_got_ref;
3819
3820   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3821   edir->elf.ref_regular |= eind->elf.ref_regular;
3822   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3823   edir->elf.needs_plt |= eind->elf.needs_plt;
3824
3825   /* If we were called to copy over info for a weak sym, that's all.  */
3826   if (eind->elf.root.type != bfd_link_hash_indirect)
3827     return;
3828
3829   /* Copy over got entries that we may have already seen to the
3830      symbol which just became indirect.  */
3831   if (eind->elf.got.glist != NULL)
3832     {
3833       if (edir->elf.got.glist != NULL)
3834         {
3835           struct got_entry **entp;
3836           struct got_entry *ent;
3837
3838           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3839             {
3840               struct got_entry *dent;
3841
3842               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3843                 if (dent->addend == ent->addend
3844                     && dent->owner == ent->owner
3845                     && dent->tls_type == ent->tls_type)
3846                   {
3847                     dent->got.refcount += ent->got.refcount;
3848                     *entp = ent->next;
3849                     break;
3850                   }
3851               if (dent == NULL)
3852                 entp = &ent->next;
3853             }
3854           *entp = edir->elf.got.glist;
3855         }
3856
3857       edir->elf.got.glist = eind->elf.got.glist;
3858       eind->elf.got.glist = NULL;
3859     }
3860
3861   /* And plt entries.  */
3862   if (eind->elf.plt.plist != NULL)
3863     {
3864       if (edir->elf.plt.plist != NULL)
3865         {
3866           struct plt_entry **entp;
3867           struct plt_entry *ent;
3868
3869           for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; )
3870             {
3871               struct plt_entry *dent;
3872
3873               for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next)
3874                 if (dent->addend == ent->addend)
3875                   {
3876                     dent->plt.refcount += ent->plt.refcount;
3877                     *entp = ent->next;
3878                     break;
3879                   }
3880               if (dent == NULL)
3881                 entp = &ent->next;
3882             }
3883           *entp = edir->elf.plt.plist;
3884         }
3885
3886       edir->elf.plt.plist = eind->elf.plt.plist;
3887       eind->elf.plt.plist = NULL;
3888     }
3889
3890   if (edir->elf.dynindx == -1)
3891     {
3892       edir->elf.dynindx = eind->elf.dynindx;
3893       edir->elf.dynstr_index = eind->elf.dynstr_index;
3894       eind->elf.dynindx = -1;
3895       eind->elf.dynstr_index = 0;
3896     }
3897   else
3898     BFD_ASSERT (eind->elf.dynindx == -1);
3899 }
3900
3901 /* Find the function descriptor hash entry from the given function code
3902    hash entry FH.  Link the entries via their OH fields.  */
3903
3904 static struct ppc_link_hash_entry *
3905 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
3906 {
3907   struct ppc_link_hash_entry *fdh = fh->oh;
3908
3909   if (fdh == NULL)
3910     {
3911       const char *fd_name = fh->elf.root.root.string + 1;
3912
3913       fdh = (struct ppc_link_hash_entry *)
3914         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
3915       if (fdh != NULL)
3916         {
3917           fdh->is_func_descriptor = 1;
3918           fdh->oh = fh;
3919           fh->is_func = 1;
3920           fh->oh = fdh;
3921         }
3922     }
3923
3924   return fdh;
3925 }
3926
3927 /* Hacks to support old ABI code.
3928    When making function calls, old ABI code references function entry
3929    points (dot symbols), while new ABI code references the function
3930    descriptor symbol.  We need to make any combination of reference and
3931    definition work together, without breaking archive linking.
3932
3933    For a defined function "foo" and an undefined call to "bar":
3934    An old object defines "foo" and ".foo", references ".bar" (possibly
3935    "bar" too).
3936    A new object defines "foo" and references "bar".
3937
3938    A new object thus has no problem with its undefined symbols being
3939    satisfied by definitions in an old object.  On the other hand, the
3940    old object won't have ".bar" satisfied by a new object.  */
3941
3942 /* Fix function descriptor symbols defined in .opd sections to be
3943    function type.  */
3944
3945 static bfd_boolean
3946 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
3947                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
3948                            Elf_Internal_Sym *isym,
3949                            const char **name ATTRIBUTE_UNUSED,
3950                            flagword *flags ATTRIBUTE_UNUSED,
3951                            asection **sec,
3952                            bfd_vma *value ATTRIBUTE_UNUSED)
3953 {
3954   if (*sec != NULL
3955       && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
3956     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
3957   return TRUE;
3958 }
3959
3960 /* This function makes an old ABI object reference to ".bar" cause the
3961    inclusion of a new ABI object archive that defines "bar".  */
3962
3963 static struct elf_link_hash_entry *
3964 ppc64_elf_archive_symbol_lookup (bfd *abfd,
3965                                  struct bfd_link_info *info,
3966                                  const char *name)
3967 {
3968   struct elf_link_hash_entry *h;
3969   char *dot_name;
3970   size_t len;
3971
3972   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
3973   if (h != NULL)
3974     return h;
3975
3976   if (name[0] == '.')
3977     return h;
3978
3979   len = strlen (name);
3980   dot_name = bfd_alloc (abfd, len + 2);
3981   if (dot_name == NULL)
3982     return (struct elf_link_hash_entry *) 0 - 1;
3983   dot_name[0] = '.';
3984   memcpy (dot_name + 1, name, len + 1);
3985   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
3986   bfd_release (abfd, dot_name);
3987   return h;
3988 }
3989
3990 /* This function satisfies all old ABI object references to ".bar" if a
3991    new ABI object defines "bar".  Well, at least, undefined dot symbols
3992    are made weak.  This stops later archive searches from including an
3993    object if we already have a function descriptor definition.  It also
3994    prevents the linker complaining about undefined symbols.
3995    We also check and correct mismatched symbol visibility here.  The
3996    most restrictive visibility of the function descriptor and the
3997    function entry symbol is used.  */
3998
3999 static bfd_boolean
4000 add_symbol_adjust (struct elf_link_hash_entry *h, void *inf)
4001 {
4002   struct bfd_link_info *info;
4003   struct ppc_link_hash_table *htab;
4004   struct ppc_link_hash_entry *eh;
4005   struct ppc_link_hash_entry *fdh;
4006
4007   if (h->root.type == bfd_link_hash_indirect)
4008     return TRUE;
4009
4010   if (h->root.type == bfd_link_hash_warning)
4011     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4012
4013   if (h->root.root.string[0] != '.')
4014     return TRUE;
4015
4016   info = inf;
4017   htab = ppc_hash_table (info);
4018   eh = (struct ppc_link_hash_entry *) h;
4019   fdh = get_fdh (eh, htab);
4020   if (fdh != NULL)
4021     {
4022       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4023       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4024       if (entry_vis < descr_vis)
4025         fdh->elf.other += entry_vis - descr_vis;
4026       else if (entry_vis > descr_vis)
4027         eh->elf.other += descr_vis - entry_vis;
4028
4029       if (eh->elf.root.type == bfd_link_hash_undefined)
4030         {
4031           eh->elf.root.type = bfd_link_hash_undefweak;
4032           eh->was_undefined = 1;
4033           htab->twiddled_syms = 1;
4034         }
4035     }
4036
4037   return TRUE;
4038 }
4039
4040 static bfd_boolean
4041 ppc64_elf_check_directives (bfd *abfd ATTRIBUTE_UNUSED,
4042                             struct bfd_link_info *info)
4043 {
4044   struct ppc_link_hash_table *htab;
4045
4046   htab = ppc_hash_table (info);
4047   if (!is_ppc64_elf_target (htab->elf.root.creator))
4048     return TRUE;
4049
4050   elf_link_hash_traverse (&htab->elf, add_symbol_adjust, info);
4051
4052   /* We need to fix the undefs list for any syms we have twiddled to
4053      undef_weak.  */
4054   if (htab->twiddled_syms)
4055     {
4056       struct bfd_link_hash_entry **pun;
4057
4058       pun = &htab->elf.root.undefs;
4059       while (*pun != NULL)
4060         {
4061           struct bfd_link_hash_entry *h = *pun;
4062
4063           if (h->type != bfd_link_hash_undefined
4064               && h->type != bfd_link_hash_common)
4065             {
4066               *pun = h->und_next;
4067               h->und_next = NULL;
4068               if (h == htab->elf.root.undefs_tail)
4069                 {
4070                   if (pun == &htab->elf.root.undefs)
4071                     htab->elf.root.undefs_tail = NULL;
4072                   else
4073                     /* pun points at an und_next field.  Go back to
4074                        the start of the link_hash_entry.  */
4075                     htab->elf.root.undefs_tail = (struct bfd_link_hash_entry *)
4076                       ((char *) pun - ((char *) &h->und_next - (char *) h));
4077                   break;
4078                 }
4079             }
4080           else
4081             pun = &h->und_next;
4082         }
4083
4084       htab->twiddled_syms = 0;
4085     }
4086   return TRUE;
4087 }
4088
4089 static bfd_boolean
4090 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4091                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4092 {
4093   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4094   char *local_got_tls_masks;
4095
4096   if (local_got_ents == NULL)
4097     {
4098       bfd_size_type size = symtab_hdr->sh_info;
4099
4100       size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4101       local_got_ents = bfd_zalloc (abfd, size);
4102       if (local_got_ents == NULL)
4103         return FALSE;
4104       elf_local_got_ents (abfd) = local_got_ents;
4105     }
4106
4107   if ((tls_type & TLS_EXPLICIT) == 0)
4108     {
4109       struct got_entry *ent;
4110
4111       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4112         if (ent->addend == r_addend
4113             && ent->owner == abfd
4114             && ent->tls_type == tls_type)
4115           break;
4116       if (ent == NULL)
4117         {
4118           bfd_size_type amt = sizeof (*ent);
4119           ent = bfd_alloc (abfd, amt);
4120           if (ent == NULL)
4121             return FALSE;
4122           ent->next = local_got_ents[r_symndx];
4123           ent->addend = r_addend;
4124           ent->owner = abfd;
4125           ent->tls_type = tls_type;
4126           ent->got.refcount = 0;
4127           local_got_ents[r_symndx] = ent;
4128         }
4129       ent->got.refcount += 1;
4130     }
4131
4132   local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4133   local_got_tls_masks[r_symndx] |= tls_type;
4134   return TRUE;
4135 }
4136
4137 static bfd_boolean
4138 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
4139 {
4140   struct plt_entry *ent;
4141
4142   for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4143     if (ent->addend == addend)
4144       break;
4145   if (ent == NULL)
4146     {
4147       bfd_size_type amt = sizeof (*ent);
4148       ent = bfd_alloc (abfd, amt);
4149       if (ent == NULL)
4150         return FALSE;
4151       ent->next = eh->elf.plt.plist;
4152       ent->addend = addend;
4153       ent->plt.refcount = 0;
4154       eh->elf.plt.plist = ent;
4155     }
4156   ent->plt.refcount += 1;
4157   eh->elf.needs_plt = 1;
4158   eh->is_func = 1;
4159   return TRUE;
4160 }
4161
4162 /* Look through the relocs for a section during the first phase, and
4163    calculate needed space in the global offset table, procedure
4164    linkage table, and dynamic reloc sections.  */
4165
4166 static bfd_boolean
4167 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4168                         asection *sec, const Elf_Internal_Rela *relocs)
4169 {
4170   struct ppc_link_hash_table *htab;
4171   Elf_Internal_Shdr *symtab_hdr;
4172   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4173   const Elf_Internal_Rela *rel;
4174   const Elf_Internal_Rela *rel_end;
4175   asection *sreloc;
4176   asection **opd_sym_map;
4177
4178   if (info->relocatable)
4179     return TRUE;
4180
4181   /* Don't do anything special with non-loaded, non-alloced sections.
4182      In particular, any relocs in such sections should not affect GOT
4183      and PLT reference counting (ie. we don't allow them to create GOT
4184      or PLT entries), there's no possibility or desire to optimize TLS
4185      relocs, and there's not much point in propagating relocs to shared
4186      libs that the dynamic linker won't relocate.  */
4187   if ((sec->flags & SEC_ALLOC) == 0)
4188     return TRUE;
4189
4190   htab = ppc_hash_table (info);
4191   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4192
4193   sym_hashes = elf_sym_hashes (abfd);
4194   sym_hashes_end = (sym_hashes
4195                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4196                     - symtab_hdr->sh_info);
4197
4198   sreloc = NULL;
4199   opd_sym_map = NULL;
4200   if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4201     {
4202       /* Garbage collection needs some extra help with .opd sections.
4203          We don't want to necessarily keep everything referenced by
4204          relocs in .opd, as that would keep all functions.  Instead,
4205          if we reference an .opd symbol (a function descriptor), we
4206          want to keep the function code symbol's section.  This is
4207          easy for global symbols, but for local syms we need to keep
4208          information about the associated function section.  Later, if
4209          edit_opd deletes entries, we'll use this array to adjust
4210          local syms in .opd.  */
4211       union opd_info {
4212         asection *func_section;
4213         long entry_adjust;
4214       };
4215       bfd_size_type amt;
4216
4217       amt = sec->size * sizeof (union opd_info) / 8;
4218       opd_sym_map = bfd_zalloc (abfd, amt);
4219       if (opd_sym_map == NULL)
4220         return FALSE;
4221       ppc64_elf_section_data (sec)->opd.func_sec = opd_sym_map;
4222     }
4223
4224   if (htab->sfpr == NULL
4225       && !create_linkage_sections (htab->elf.dynobj, info))
4226     return FALSE;
4227
4228   rel_end = relocs + sec->reloc_count;
4229   for (rel = relocs; rel < rel_end; rel++)
4230     {
4231       unsigned long r_symndx;
4232       struct elf_link_hash_entry *h;
4233       enum elf_ppc64_reloc_type r_type;
4234       int tls_type = 0;
4235
4236       r_symndx = ELF64_R_SYM (rel->r_info);
4237       if (r_symndx < symtab_hdr->sh_info)
4238         h = NULL;
4239       else
4240         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4241
4242       r_type = ELF64_R_TYPE (rel->r_info);
4243       switch (r_type)
4244         {
4245         case R_PPC64_GOT_TLSLD16:
4246         case R_PPC64_GOT_TLSLD16_LO:
4247         case R_PPC64_GOT_TLSLD16_HI:
4248         case R_PPC64_GOT_TLSLD16_HA:
4249           ppc64_tlsld_got (abfd)->refcount += 1;
4250           tls_type = TLS_TLS | TLS_LD;
4251           goto dogottls;
4252
4253         case R_PPC64_GOT_TLSGD16:
4254         case R_PPC64_GOT_TLSGD16_LO:
4255         case R_PPC64_GOT_TLSGD16_HI:
4256         case R_PPC64_GOT_TLSGD16_HA:
4257           tls_type = TLS_TLS | TLS_GD;
4258           goto dogottls;
4259
4260         case R_PPC64_GOT_TPREL16_DS:
4261         case R_PPC64_GOT_TPREL16_LO_DS:
4262         case R_PPC64_GOT_TPREL16_HI:
4263         case R_PPC64_GOT_TPREL16_HA:
4264           if (info->shared)
4265             info->flags |= DF_STATIC_TLS;
4266           tls_type = TLS_TLS | TLS_TPREL;
4267           goto dogottls;
4268
4269         case R_PPC64_GOT_DTPREL16_DS:
4270         case R_PPC64_GOT_DTPREL16_LO_DS:
4271         case R_PPC64_GOT_DTPREL16_HI:
4272         case R_PPC64_GOT_DTPREL16_HA:
4273           tls_type = TLS_TLS | TLS_DTPREL;
4274         dogottls:
4275           sec->has_tls_reloc = 1;
4276           /* Fall thru */
4277
4278         case R_PPC64_GOT16:
4279         case R_PPC64_GOT16_DS:
4280         case R_PPC64_GOT16_HA:
4281         case R_PPC64_GOT16_HI:
4282         case R_PPC64_GOT16_LO:
4283         case R_PPC64_GOT16_LO_DS:
4284           /* This symbol requires a global offset table entry.  */
4285           sec->has_gp_reloc = 1;
4286           if (ppc64_elf_tdata (abfd)->got == NULL
4287               && !create_got_section (abfd, info))
4288             return FALSE;
4289
4290           if (h != NULL)
4291             {
4292               struct ppc_link_hash_entry *eh;
4293               struct got_entry *ent;
4294
4295               eh = (struct ppc_link_hash_entry *) h;
4296               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4297                 if (ent->addend == rel->r_addend
4298                     && ent->owner == abfd
4299                     && ent->tls_type == tls_type)
4300                   break;
4301               if (ent == NULL)
4302                 {
4303                   bfd_size_type amt = sizeof (*ent);
4304                   ent = bfd_alloc (abfd, amt);
4305                   if (ent == NULL)
4306                     return FALSE;
4307                   ent->next = eh->elf.got.glist;
4308                   ent->addend = rel->r_addend;
4309                   ent->owner = abfd;
4310                   ent->tls_type = tls_type;
4311                   ent->got.refcount = 0;
4312                   eh->elf.got.glist = ent;
4313                 }
4314               ent->got.refcount += 1;
4315               eh->tls_mask |= tls_type;
4316             }
4317           else
4318             /* This is a global offset table entry for a local symbol.  */
4319             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4320                                         rel->r_addend, tls_type))
4321               return FALSE;
4322           break;
4323
4324         case R_PPC64_PLT16_HA:
4325         case R_PPC64_PLT16_HI:
4326         case R_PPC64_PLT16_LO:
4327         case R_PPC64_PLT32:
4328         case R_PPC64_PLT64:
4329           /* This symbol requires a procedure linkage table entry.  We
4330              actually build the entry in adjust_dynamic_symbol,
4331              because this might be a case of linking PIC code without
4332              linking in any dynamic objects, in which case we don't
4333              need to generate a procedure linkage table after all.  */
4334           if (h == NULL)
4335             {
4336               /* It does not make sense to have a procedure linkage
4337                  table entry for a local symbol.  */
4338               bfd_set_error (bfd_error_bad_value);
4339               return FALSE;
4340             }
4341           else
4342             if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4343                                   rel->r_addend))
4344               return FALSE;
4345           break;
4346
4347           /* The following relocations don't need to propagate the
4348              relocation if linking a shared object since they are
4349              section relative.  */
4350         case R_PPC64_SECTOFF:
4351         case R_PPC64_SECTOFF_LO:
4352         case R_PPC64_SECTOFF_HI:
4353         case R_PPC64_SECTOFF_HA:
4354         case R_PPC64_SECTOFF_DS:
4355         case R_PPC64_SECTOFF_LO_DS:
4356         case R_PPC64_DTPREL16:
4357         case R_PPC64_DTPREL16_LO:
4358         case R_PPC64_DTPREL16_HI:
4359         case R_PPC64_DTPREL16_HA:
4360         case R_PPC64_DTPREL16_DS:
4361         case R_PPC64_DTPREL16_LO_DS:
4362         case R_PPC64_DTPREL16_HIGHER:
4363         case R_PPC64_DTPREL16_HIGHERA:
4364         case R_PPC64_DTPREL16_HIGHEST:
4365         case R_PPC64_DTPREL16_HIGHESTA:
4366           break;
4367
4368           /* Nor do these.  */
4369         case R_PPC64_TOC16:
4370         case R_PPC64_TOC16_LO:
4371         case R_PPC64_TOC16_HI:
4372         case R_PPC64_TOC16_HA:
4373         case R_PPC64_TOC16_DS:
4374         case R_PPC64_TOC16_LO_DS:
4375           sec->has_gp_reloc = 1;
4376           break;
4377
4378           /* This relocation describes the C++ object vtable hierarchy.
4379              Reconstruct it for later use during GC.  */
4380         case R_PPC64_GNU_VTINHERIT:
4381           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4382             return FALSE;
4383           break;
4384
4385           /* This relocation describes which C++ vtable entries are actually
4386              used.  Record for later use during GC.  */
4387         case R_PPC64_GNU_VTENTRY:
4388           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4389             return FALSE;
4390           break;
4391
4392         case R_PPC64_REL14:
4393         case R_PPC64_REL14_BRTAKEN:
4394         case R_PPC64_REL14_BRNTAKEN:
4395           htab->has_14bit_branch = 1;
4396           /* Fall through.  */
4397
4398         case R_PPC64_REL24:
4399           if (h != NULL)
4400             {
4401               /* We may need a .plt entry if the function this reloc
4402                  refers to is in a shared lib.  */
4403               if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4404                                     rel->r_addend))
4405                 return FALSE;
4406               if (h == &htab->tls_get_addr->elf
4407                   || h == &htab->tls_get_addr_fd->elf)
4408                 sec->has_tls_reloc = 1;
4409               else if (htab->tls_get_addr == NULL
4410                        && !strncmp (h->root.root.string, ".__tls_get_addr", 15)
4411                        && (h->root.root.string[15] == 0
4412                            || h->root.root.string[15] == '@'))
4413                 {
4414                   htab->tls_get_addr = (struct ppc_link_hash_entry *) h;
4415                   sec->has_tls_reloc = 1;
4416                 }
4417               else if (htab->tls_get_addr_fd == NULL
4418                        && !strncmp (h->root.root.string, "__tls_get_addr", 14)
4419                        && (h->root.root.string[14] == 0
4420                            || h->root.root.string[14] == '@'))
4421                 {
4422                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) h;
4423                   sec->has_tls_reloc = 1;
4424                 }
4425             }
4426           break;
4427
4428         case R_PPC64_TPREL64:
4429           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4430           if (info->shared)
4431             info->flags |= DF_STATIC_TLS;
4432           goto dotlstoc;
4433
4434         case R_PPC64_DTPMOD64:
4435           if (rel + 1 < rel_end
4436               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4437               && rel[1].r_offset == rel->r_offset + 8)
4438             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4439           else
4440             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4441           goto dotlstoc;
4442
4443         case R_PPC64_DTPREL64:
4444           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4445           if (rel != relocs
4446               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4447               && rel[-1].r_offset == rel->r_offset - 8)
4448             /* This is the second reloc of a dtpmod, dtprel pair.
4449                Don't mark with TLS_DTPREL.  */
4450             goto dodyn;
4451
4452         dotlstoc:
4453           sec->has_tls_reloc = 1;
4454           if (h != NULL)
4455             {
4456               struct ppc_link_hash_entry *eh;
4457               eh = (struct ppc_link_hash_entry *) h;
4458               eh->tls_mask |= tls_type;
4459             }
4460           else
4461             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4462                                         rel->r_addend, tls_type))
4463               return FALSE;
4464
4465           if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4466             {
4467               /* One extra to simplify get_tls_mask.  */
4468               bfd_size_type amt = sec->size * sizeof (unsigned) / 8 + 1;
4469               ppc64_elf_section_data (sec)->t_symndx = bfd_zalloc (abfd, amt);
4470               if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4471                 return FALSE;
4472             }
4473           BFD_ASSERT (rel->r_offset % 8 == 0);
4474           ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8] = r_symndx;
4475
4476           /* Mark the second slot of a GD or LD entry.
4477              -1 to indicate GD and -2 to indicate LD.  */
4478           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4479             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -1;
4480           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4481             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -2;
4482           goto dodyn;
4483
4484         case R_PPC64_TPREL16:
4485         case R_PPC64_TPREL16_LO:
4486         case R_PPC64_TPREL16_HI:
4487         case R_PPC64_TPREL16_HA:
4488         case R_PPC64_TPREL16_DS:
4489         case R_PPC64_TPREL16_LO_DS:
4490         case R_PPC64_TPREL16_HIGHER:
4491         case R_PPC64_TPREL16_HIGHERA:
4492         case R_PPC64_TPREL16_HIGHEST:
4493         case R_PPC64_TPREL16_HIGHESTA:
4494           if (info->shared)
4495             {
4496               info->flags |= DF_STATIC_TLS;
4497               goto dodyn;
4498             }
4499           break;
4500
4501         case R_PPC64_ADDR64:
4502           if (opd_sym_map != NULL
4503               && rel + 1 < rel_end
4504               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
4505             {
4506               if (h != NULL)
4507                 {
4508                   if (h->root.root.string[0] == '.'
4509                       && h->root.root.string[1] != 0
4510                       && get_fdh ((struct ppc_link_hash_entry *) h, htab))
4511                     ;
4512                   else
4513                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
4514                 }
4515               else
4516                 {
4517                   asection *s;
4518
4519                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
4520                                                  r_symndx);
4521                   if (s == NULL)
4522                     return FALSE;
4523                   else if (s != sec)
4524                     opd_sym_map[rel->r_offset / 8] = s;
4525                 }
4526             }
4527           /* Fall through.  */
4528
4529         case R_PPC64_REL30:
4530         case R_PPC64_REL32:
4531         case R_PPC64_REL64:
4532         case R_PPC64_ADDR14:
4533         case R_PPC64_ADDR14_BRNTAKEN:
4534         case R_PPC64_ADDR14_BRTAKEN:
4535         case R_PPC64_ADDR16:
4536         case R_PPC64_ADDR16_DS:
4537         case R_PPC64_ADDR16_HA:
4538         case R_PPC64_ADDR16_HI:
4539         case R_PPC64_ADDR16_HIGHER:
4540         case R_PPC64_ADDR16_HIGHERA:
4541         case R_PPC64_ADDR16_HIGHEST:
4542         case R_PPC64_ADDR16_HIGHESTA:
4543         case R_PPC64_ADDR16_LO:
4544         case R_PPC64_ADDR16_LO_DS:
4545         case R_PPC64_ADDR24:
4546         case R_PPC64_ADDR32:
4547         case R_PPC64_UADDR16:
4548         case R_PPC64_UADDR32:
4549         case R_PPC64_UADDR64:
4550         case R_PPC64_TOC:
4551           if (h != NULL && !info->shared)
4552             /* We may need a copy reloc.  */
4553             h->non_got_ref = 1;
4554
4555           /* Don't propagate .opd relocs.  */
4556           if (NO_OPD_RELOCS && opd_sym_map != NULL)
4557             break;
4558
4559           /* If we are creating a shared library, and this is a reloc
4560              against a global symbol, or a non PC relative reloc
4561              against a local symbol, then we need to copy the reloc
4562              into the shared library.  However, if we are linking with
4563              -Bsymbolic, we do not need to copy a reloc against a
4564              global symbol which is defined in an object we are
4565              including in the link (i.e., DEF_REGULAR is set).  At
4566              this point we have not seen all the input files, so it is
4567              possible that DEF_REGULAR is not set now but will be set
4568              later (it is never cleared).  In case of a weak definition,
4569              DEF_REGULAR may be cleared later by a strong definition in
4570              a shared library.  We account for that possibility below by
4571              storing information in the dyn_relocs field of the hash
4572              table entry.  A similar situation occurs when creating
4573              shared libraries and symbol visibility changes render the
4574              symbol local.
4575
4576              If on the other hand, we are creating an executable, we
4577              may need to keep relocations for symbols satisfied by a
4578              dynamic library if we manage to avoid copy relocs for the
4579              symbol.  */
4580         dodyn:
4581           if ((info->shared
4582                && (MUST_BE_DYN_RELOC (r_type)
4583                    || (h != NULL
4584                        && (! info->symbolic
4585                            || h->root.type == bfd_link_hash_defweak
4586                            || !h->def_regular))))
4587               || (ELIMINATE_COPY_RELOCS
4588                   && !info->shared
4589                   && h != NULL
4590                   && (h->root.type == bfd_link_hash_defweak
4591                       || !h->def_regular)))
4592             {
4593               struct ppc_dyn_relocs *p;
4594               struct ppc_dyn_relocs **head;
4595
4596               /* We must copy these reloc types into the output file.
4597                  Create a reloc section in dynobj and make room for
4598                  this reloc.  */
4599               if (sreloc == NULL)
4600                 {
4601                   const char *name;
4602                   bfd *dynobj;
4603
4604                   name = (bfd_elf_string_from_elf_section
4605                           (abfd,
4606                            elf_elfheader (abfd)->e_shstrndx,
4607                            elf_section_data (sec)->rel_hdr.sh_name));
4608                   if (name == NULL)
4609                     return FALSE;
4610
4611                   if (strncmp (name, ".rela", 5) != 0
4612                       || strcmp (bfd_get_section_name (abfd, sec),
4613                                  name + 5) != 0)
4614                     {
4615                       (*_bfd_error_handler)
4616                         (_("%B: bad relocation section name `%s\'"),
4617                          abfd, name);
4618                       bfd_set_error (bfd_error_bad_value);
4619                     }
4620
4621                   dynobj = htab->elf.dynobj;
4622                   sreloc = bfd_get_section_by_name (dynobj, name);
4623                   if (sreloc == NULL)
4624                     {
4625                       flagword flags;
4626
4627                       sreloc = bfd_make_section (dynobj, name);
4628                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
4629                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4630                       if ((sec->flags & SEC_ALLOC) != 0)
4631                         flags |= SEC_ALLOC | SEC_LOAD;
4632                       if (sreloc == NULL
4633                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
4634                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
4635                         return FALSE;
4636                     }
4637                   elf_section_data (sec)->sreloc = sreloc;
4638                 }
4639
4640               /* If this is a global symbol, we count the number of
4641                  relocations we need for this symbol.  */
4642               if (h != NULL)
4643                 {
4644                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
4645                 }
4646               else
4647                 {
4648                   /* Track dynamic relocs needed for local syms too.
4649                      We really need local syms available to do this
4650                      easily.  Oh well.  */
4651
4652                   asection *s;
4653                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4654                                                  sec, r_symndx);
4655                   if (s == NULL)
4656                     return FALSE;
4657
4658                   head = ((struct ppc_dyn_relocs **)
4659                           &elf_section_data (s)->local_dynrel);
4660                 }
4661
4662               p = *head;
4663               if (p == NULL || p->sec != sec)
4664                 {
4665                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4666                   if (p == NULL)
4667                     return FALSE;
4668                   p->next = *head;
4669                   *head = p;
4670                   p->sec = sec;
4671                   p->count = 0;
4672                   p->pc_count = 0;
4673                 }
4674
4675               p->count += 1;
4676               if (!MUST_BE_DYN_RELOC (r_type))
4677                 p->pc_count += 1;
4678             }
4679           break;
4680
4681         default:
4682           break;
4683         }
4684     }
4685
4686   return TRUE;
4687 }
4688
4689 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
4690    of the code entry point, and its section.  */
4691
4692 static bfd_vma
4693 opd_entry_value (asection *opd_sec,
4694                  bfd_vma offset,
4695                  asection **code_sec,
4696                  bfd_vma *code_off)
4697 {
4698   bfd *opd_bfd = opd_sec->owner;
4699   Elf_Internal_Rela *lo, *hi, *look;
4700
4701   /* Go find the opd reloc at the sym address.  */
4702   lo = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
4703   BFD_ASSERT (lo != NULL);
4704   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
4705
4706   while (lo < hi)
4707     {
4708       look = lo + (hi - lo) / 2;
4709       if (look->r_offset < offset)
4710         lo = look + 1;
4711       else if (look->r_offset > offset)
4712         hi = look;
4713       else
4714         {
4715           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (opd_bfd)->symtab_hdr;
4716           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
4717               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
4718             {
4719               unsigned long symndx = ELF64_R_SYM (look->r_info);
4720               bfd_vma val;
4721               asection *sec;
4722
4723               if (symndx < symtab_hdr->sh_info)
4724                 {
4725                   Elf_Internal_Sym *sym;
4726
4727                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
4728                   if (sym == NULL)
4729                     {
4730                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
4731                                                   symtab_hdr->sh_info,
4732                                                   0, NULL, NULL, NULL);
4733                       if (sym == NULL)
4734                         return (bfd_vma) -1;
4735                       symtab_hdr->contents = (bfd_byte *) sym;
4736                     }
4737
4738                   sym += symndx;
4739                   val = sym->st_value;
4740                   sec = NULL;
4741                   if ((sym->st_shndx != SHN_UNDEF
4742                        && sym->st_shndx < SHN_LORESERVE)
4743                       || sym->st_shndx > SHN_HIRESERVE)
4744                     sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
4745                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
4746                 }
4747               else
4748                 {
4749                   struct elf_link_hash_entry **sym_hashes;
4750                   struct elf_link_hash_entry *rh;
4751
4752                   sym_hashes = elf_sym_hashes (opd_bfd);
4753                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
4754                   while (rh->root.type == bfd_link_hash_indirect
4755                          || rh->root.type == bfd_link_hash_warning)
4756                     rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
4757                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
4758                               || rh->root.type == bfd_link_hash_defweak);
4759                   val = rh->root.u.def.value;
4760                   sec = rh->root.u.def.section;
4761                 }
4762               val += look->r_addend;
4763               if (code_off != NULL)
4764                 *code_off = val;
4765               if (code_sec != NULL)
4766                 *code_sec = sec;
4767               if (sec != NULL && sec->output_section != NULL)
4768                 val += sec->output_section->vma + sec->output_offset;
4769               return val;
4770             }
4771           break;
4772         }
4773     }
4774   return (bfd_vma) -1;
4775 }
4776
4777 /* Return the section that should be marked against GC for a given
4778    relocation.  */
4779
4780 static asection *
4781 ppc64_elf_gc_mark_hook (asection *sec,
4782                         struct bfd_link_info *info,
4783                         Elf_Internal_Rela *rel,
4784                         struct elf_link_hash_entry *h,
4785                         Elf_Internal_Sym *sym)
4786 {
4787   asection *rsec;
4788
4789   /* First mark all our entry sym sections.  */
4790   if (info->gc_sym_list != NULL)
4791     {
4792       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4793       struct bfd_sym_chain *sym = info->gc_sym_list;
4794
4795       info->gc_sym_list = NULL;
4796       do
4797         {
4798           struct ppc_link_hash_entry *eh;
4799
4800           eh = (struct ppc_link_hash_entry *)
4801             elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
4802           if (eh == NULL)
4803             continue;
4804           if (eh->elf.root.type != bfd_link_hash_defined
4805               && eh->elf.root.type != bfd_link_hash_defweak)
4806             continue;
4807
4808           if (eh->is_func_descriptor)
4809             rsec = eh->oh->elf.root.u.def.section;
4810           else if (get_opd_info (eh->elf.root.u.def.section) != NULL
4811                    && opd_entry_value (eh->elf.root.u.def.section,
4812                                        eh->elf.root.u.def.value,
4813                                        &rsec, NULL) != (bfd_vma) -1)
4814             ;
4815           else
4816             continue;
4817
4818           if (!rsec->gc_mark)
4819             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
4820
4821           rsec = eh->elf.root.u.def.section;
4822           if (!rsec->gc_mark)
4823             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
4824
4825           sym = sym->next;
4826         }
4827       while (sym != NULL);
4828     }
4829
4830   /* Syms return NULL if we're marking .opd, so we avoid marking all
4831      function sections, as all functions are referenced in .opd.  */
4832   rsec = NULL;
4833   if (get_opd_info (sec) != NULL)
4834     return rsec;
4835
4836   if (h != NULL)
4837     {
4838       enum elf_ppc64_reloc_type r_type;
4839       struct ppc_link_hash_entry *eh;
4840
4841       r_type = ELF64_R_TYPE (rel->r_info);
4842       switch (r_type)
4843         {
4844         case R_PPC64_GNU_VTINHERIT:
4845         case R_PPC64_GNU_VTENTRY:
4846           break;
4847
4848         default:
4849           switch (h->root.type)
4850             {
4851             case bfd_link_hash_defined:
4852             case bfd_link_hash_defweak:
4853               eh = (struct ppc_link_hash_entry *) h;
4854               if (eh->oh != NULL && eh->oh->is_func_descriptor)
4855                 eh = eh->oh;
4856
4857               /* Function descriptor syms cause the associated
4858                  function code sym section to be marked.  */
4859               if (eh->is_func_descriptor)
4860                 {
4861                   /* They also mark their opd section.  */
4862                   if (!eh->elf.root.u.def.section->gc_mark)
4863                     _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
4864                                       ppc64_elf_gc_mark_hook);
4865
4866                   rsec = eh->oh->elf.root.u.def.section;
4867                 }
4868               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
4869                        && opd_entry_value (eh->elf.root.u.def.section,
4870                                            eh->elf.root.u.def.value,
4871                                            &rsec, NULL) != (bfd_vma) -1)
4872                 {
4873                   if (!eh->elf.root.u.def.section->gc_mark)
4874                     _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
4875                                       ppc64_elf_gc_mark_hook);
4876                 }
4877               else
4878                 rsec = h->root.u.def.section;
4879               break;
4880
4881             case bfd_link_hash_common:
4882               rsec = h->root.u.c.p->section;
4883               break;
4884
4885             default:
4886               break;
4887             }
4888         }
4889     }
4890   else
4891     {
4892       asection **opd_sym_section;
4893
4894       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4895       opd_sym_section = get_opd_info (rsec);
4896       if (opd_sym_section != NULL)
4897         {
4898           if (!rsec->gc_mark)
4899             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
4900
4901           rsec = opd_sym_section[sym->st_value / 8];
4902         }
4903     }
4904
4905   return rsec;
4906 }
4907
4908 /* Update the .got, .plt. and dynamic reloc reference counts for the
4909    section being removed.  */
4910
4911 static bfd_boolean
4912 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
4913                          asection *sec, const Elf_Internal_Rela *relocs)
4914 {
4915   struct ppc_link_hash_table *htab;
4916   Elf_Internal_Shdr *symtab_hdr;
4917   struct elf_link_hash_entry **sym_hashes;
4918   struct got_entry **local_got_ents;
4919   const Elf_Internal_Rela *rel, *relend;
4920
4921   if ((sec->flags & SEC_ALLOC) == 0)
4922     return TRUE;
4923
4924   elf_section_data (sec)->local_dynrel = NULL;
4925
4926   htab = ppc_hash_table (info);
4927   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4928   sym_hashes = elf_sym_hashes (abfd);
4929   local_got_ents = elf_local_got_ents (abfd);
4930
4931   relend = relocs + sec->reloc_count;
4932   for (rel = relocs; rel < relend; rel++)
4933     {
4934       unsigned long r_symndx;
4935       enum elf_ppc64_reloc_type r_type;
4936       struct elf_link_hash_entry *h = NULL;
4937       char tls_type = 0;
4938
4939       r_symndx = ELF64_R_SYM (rel->r_info);
4940       r_type = ELF64_R_TYPE (rel->r_info);
4941       if (r_symndx >= symtab_hdr->sh_info)
4942         {
4943           struct ppc_link_hash_entry *eh;
4944           struct ppc_dyn_relocs **pp;
4945           struct ppc_dyn_relocs *p;
4946
4947           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4948           eh = (struct ppc_link_hash_entry *) h;
4949
4950           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
4951             if (p->sec == sec)
4952               {
4953                 /* Everything must go for SEC.  */
4954                 *pp = p->next;
4955                 break;
4956               }
4957         }
4958
4959       switch (r_type)
4960         {
4961         case R_PPC64_GOT_TLSLD16:
4962         case R_PPC64_GOT_TLSLD16_LO:
4963         case R_PPC64_GOT_TLSLD16_HI:
4964         case R_PPC64_GOT_TLSLD16_HA:
4965           ppc64_tlsld_got (abfd)->refcount -= 1;
4966           tls_type = TLS_TLS | TLS_LD;
4967           goto dogot;
4968
4969         case R_PPC64_GOT_TLSGD16:
4970         case R_PPC64_GOT_TLSGD16_LO:
4971         case R_PPC64_GOT_TLSGD16_HI:
4972         case R_PPC64_GOT_TLSGD16_HA:
4973           tls_type = TLS_TLS | TLS_GD;
4974           goto dogot;
4975
4976         case R_PPC64_GOT_TPREL16_DS:
4977         case R_PPC64_GOT_TPREL16_LO_DS:
4978         case R_PPC64_GOT_TPREL16_HI:
4979         case R_PPC64_GOT_TPREL16_HA:
4980           tls_type = TLS_TLS | TLS_TPREL;
4981           goto dogot;
4982
4983         case R_PPC64_GOT_DTPREL16_DS:
4984         case R_PPC64_GOT_DTPREL16_LO_DS:
4985         case R_PPC64_GOT_DTPREL16_HI:
4986         case R_PPC64_GOT_DTPREL16_HA:
4987           tls_type = TLS_TLS | TLS_DTPREL;
4988           goto dogot;
4989
4990         case R_PPC64_GOT16:
4991         case R_PPC64_GOT16_DS:
4992         case R_PPC64_GOT16_HA:
4993         case R_PPC64_GOT16_HI:
4994         case R_PPC64_GOT16_LO:
4995         case R_PPC64_GOT16_LO_DS:
4996         dogot:
4997           {
4998             struct got_entry *ent;
4999
5000             if (h != NULL)
5001               ent = h->got.glist;
5002             else
5003               ent = local_got_ents[r_symndx];
5004
5005             for (; ent != NULL; ent = ent->next)
5006               if (ent->addend == rel->r_addend
5007                   && ent->owner == abfd
5008                   && ent->tls_type == tls_type)
5009                 break;
5010             if (ent == NULL)
5011               abort ();
5012             if (ent->got.refcount > 0)
5013               ent->got.refcount -= 1;
5014           }
5015           break;
5016
5017         case R_PPC64_PLT16_HA:
5018         case R_PPC64_PLT16_HI:
5019         case R_PPC64_PLT16_LO:
5020         case R_PPC64_PLT32:
5021         case R_PPC64_PLT64:
5022         case R_PPC64_REL14:
5023         case R_PPC64_REL14_BRNTAKEN:
5024         case R_PPC64_REL14_BRTAKEN:
5025         case R_PPC64_REL24:
5026           if (h != NULL)
5027             {
5028               struct plt_entry *ent;
5029
5030               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5031                 if (ent->addend == rel->r_addend)
5032                   break;
5033               if (ent == NULL)
5034                 abort ();
5035               if (ent->plt.refcount > 0)
5036                 ent->plt.refcount -= 1;
5037             }
5038           break;
5039
5040         default:
5041           break;
5042         }
5043     }
5044   return TRUE;
5045 }
5046
5047 /* The maximum size of .sfpr.  */
5048 #define SFPR_MAX (218*4)
5049
5050 struct sfpr_def_parms
5051 {
5052   const char name[12];
5053   unsigned char lo, hi;
5054   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5055   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5056 };
5057
5058 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5059
5060 static unsigned int
5061 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5062 {
5063   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5064   unsigned int i;
5065   size_t len = strlen (parm->name);
5066   bfd_boolean writing = FALSE;
5067   char sym[16];
5068
5069   memcpy (sym, parm->name, len);
5070   sym[len + 2] = 0;
5071
5072   for (i = parm->lo; i <= parm->hi; i++)
5073     {
5074       struct elf_link_hash_entry *h;
5075
5076       sym[len + 0] = i / 10 + '0';
5077       sym[len + 1] = i % 10 + '0';
5078       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5079       if (h != NULL
5080           && !h->def_regular)
5081         {
5082           h->root.type = bfd_link_hash_defined;
5083           h->root.u.def.section = htab->sfpr;
5084           h->root.u.def.value = htab->sfpr->size;
5085           h->type = STT_FUNC;
5086           h->def_regular = 1;
5087           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5088           writing = TRUE;
5089           if (htab->sfpr->contents == NULL)
5090             {
5091               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5092               if (htab->sfpr->contents == NULL)
5093                 return FALSE;
5094             }
5095         }
5096       if (writing)
5097         {
5098           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5099           if (i != parm->hi)
5100             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5101           else
5102             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5103           htab->sfpr->size = p - htab->sfpr->contents;
5104         }
5105     }
5106
5107   return TRUE;
5108 }
5109
5110 static bfd_byte *
5111 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5112 {
5113   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5114   return p + 4;
5115 }
5116
5117 static bfd_byte *
5118 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5119 {
5120   p = savegpr0 (abfd, p, r);
5121   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5122   p = p + 4;
5123   bfd_put_32 (abfd, BLR, p);
5124   return p + 4;
5125 }
5126
5127 static bfd_byte *
5128 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5129 {
5130   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5131   return p + 4;
5132 }
5133
5134 static bfd_byte *
5135 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5136 {
5137   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5138   p = p + 4;
5139   p = restgpr0 (abfd, p, r);
5140   bfd_put_32 (abfd, MTLR_R0, p);
5141   p = p + 4;
5142   if (r == 29)
5143     {
5144       p = restgpr0 (abfd, p, 30);
5145       p = restgpr0 (abfd, p, 31);
5146     }
5147   bfd_put_32 (abfd, BLR, p);
5148   return p + 4;
5149 }
5150
5151 static bfd_byte *
5152 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5153 {
5154   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5155   return p + 4;
5156 }
5157
5158 static bfd_byte *
5159 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5160 {
5161   p = savegpr1 (abfd, p, r);
5162   bfd_put_32 (abfd, BLR, p);
5163   return p + 4;
5164 }
5165
5166 static bfd_byte *
5167 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5168 {
5169   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5170   return p + 4;
5171 }
5172
5173 static bfd_byte *
5174 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5175 {
5176   p = restgpr1 (abfd, p, r);
5177   bfd_put_32 (abfd, BLR, p);
5178   return p + 4;
5179 }
5180
5181 static bfd_byte *
5182 savefpr (bfd *abfd, bfd_byte *p, int r)
5183 {
5184   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5185   return p + 4;
5186 }
5187
5188 static bfd_byte *
5189 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5190 {
5191   p = savefpr (abfd, p, r);
5192   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5193   p = p + 4;
5194   bfd_put_32 (abfd, BLR, p);
5195   return p + 4;
5196 }
5197
5198 static bfd_byte *
5199 restfpr (bfd *abfd, bfd_byte *p, int r)
5200 {
5201   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5202   return p + 4;
5203 }
5204
5205 static bfd_byte *
5206 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5207 {
5208   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5209   p = p + 4;
5210   p = restfpr (abfd, p, r);
5211   bfd_put_32 (abfd, MTLR_R0, p);
5212   p = p + 4;
5213   if (r == 29)
5214     {
5215       p = restfpr (abfd, p, 30);
5216       p = restfpr (abfd, p, 31);
5217     }
5218   bfd_put_32 (abfd, BLR, p);
5219   return p + 4;
5220 }
5221
5222 static bfd_byte *
5223 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5224 {
5225   p = savefpr (abfd, p, r);
5226   bfd_put_32 (abfd, BLR, p);
5227   return p + 4;
5228 }
5229
5230 static bfd_byte *
5231 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5232 {
5233   p = restfpr (abfd, p, r);
5234   bfd_put_32 (abfd, BLR, p);
5235   return p + 4;
5236 }
5237
5238 static bfd_byte *
5239 savevr (bfd *abfd, bfd_byte *p, int r)
5240 {
5241   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5242   p = p + 4;
5243   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5244   return p + 4;
5245 }
5246
5247 static bfd_byte *
5248 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5249 {
5250   p = savevr (abfd, p, r);
5251   bfd_put_32 (abfd, BLR, p);
5252   return p + 4;
5253 }
5254
5255 static bfd_byte *
5256 restvr (bfd *abfd, bfd_byte *p, int r)
5257 {
5258   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5259   p = p + 4;
5260   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5261   return p + 4;
5262 }
5263
5264 static bfd_byte *
5265 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5266 {
5267   p = restvr (abfd, p, r);
5268   bfd_put_32 (abfd, BLR, p);
5269   return p + 4;
5270 }
5271
5272 /* Called via elf_link_hash_traverse to transfer dynamic linking
5273    information on function code symbol entries to their corresponding
5274    function descriptor symbol entries.  */
5275
5276 static bfd_boolean
5277 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5278 {
5279   struct bfd_link_info *info;
5280   struct ppc_link_hash_table *htab;
5281   struct plt_entry *ent;
5282   struct ppc_link_hash_entry *fh;
5283   struct ppc_link_hash_entry *fdh;
5284   bfd_boolean force_local;
5285
5286   fh = (struct ppc_link_hash_entry *) h;
5287   if (fh->elf.root.type == bfd_link_hash_indirect)
5288     return TRUE;
5289
5290   if (fh->elf.root.type == bfd_link_hash_warning)
5291     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5292
5293   info = inf;
5294   htab = ppc_hash_table (info);
5295
5296   /* Resolve undefined references to dot-symbols as the value
5297      in the function descriptor, if we have one in a regular object.
5298      This is to satisfy cases like ".quad .foo".  Calls to functions
5299      in dynamic objects are handled elsewhere.  */
5300   if (fh->elf.root.type == bfd_link_hash_undefweak
5301       && fh->was_undefined
5302       && (fh->oh->elf.root.type == bfd_link_hash_defined
5303           || fh->oh->elf.root.type == bfd_link_hash_defweak)
5304       && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5305       && opd_entry_value (fh->oh->elf.root.u.def.section,
5306                           fh->oh->elf.root.u.def.value,
5307                           &fh->elf.root.u.def.section,
5308                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
5309     {
5310       fh->elf.root.type = fh->oh->elf.root.type;
5311       fh->elf.forced_local = 1;
5312     }
5313
5314   /* If this is a function code symbol, transfer dynamic linking
5315      information to the function descriptor symbol.  */
5316   if (!fh->is_func)
5317     return TRUE;
5318
5319   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
5320     if (ent->plt.refcount > 0)
5321       break;
5322   if (ent == NULL
5323       || fh->elf.root.root.string[0] != '.'
5324       || fh->elf.root.root.string[1] == '\0')
5325     return TRUE;
5326
5327   /* Find the corresponding function descriptor symbol.  Create it
5328      as undefined if necessary.  */
5329
5330   fdh = get_fdh (fh, htab);
5331   if (fdh != NULL)
5332     while (fdh->elf.root.type == bfd_link_hash_indirect
5333            || fdh->elf.root.type == bfd_link_hash_warning)
5334       fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5335
5336   if (fdh == NULL
5337       && info->shared
5338       && (fh->elf.root.type == bfd_link_hash_undefined
5339           || fh->elf.root.type == bfd_link_hash_undefweak))
5340     {
5341       bfd *abfd;
5342       asymbol *newsym;
5343       struct bfd_link_hash_entry *bh;
5344
5345       abfd = fh->elf.root.u.undef.abfd;
5346       newsym = bfd_make_empty_symbol (abfd);
5347       newsym->name = fh->elf.root.root.string + 1;
5348       newsym->section = bfd_und_section_ptr;
5349       newsym->value = 0;
5350       newsym->flags = BSF_OBJECT;
5351       if (fh->elf.root.type == bfd_link_hash_undefweak)
5352         newsym->flags |= BSF_WEAK;
5353
5354       bh = &fdh->elf.root;
5355       if ( !(_bfd_generic_link_add_one_symbol
5356              (info, abfd, newsym->name, newsym->flags,
5357               newsym->section, newsym->value, NULL, FALSE, FALSE, &bh)))
5358         {
5359           return FALSE;
5360         }
5361       fdh = (struct ppc_link_hash_entry *) bh;
5362       fdh->elf.non_elf = 0;
5363       fdh->elf.size = 24;
5364       fdh->elf.type = STT_OBJECT;
5365     }
5366
5367   if (fdh != NULL
5368       && !fdh->elf.forced_local
5369       && (info->shared
5370           || fdh->elf.def_dynamic
5371           || fdh->elf.ref_dynamic
5372           || (fdh->elf.root.type == bfd_link_hash_undefweak
5373               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5374     {
5375       if (fdh->elf.dynindx == -1)
5376         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5377           return FALSE;
5378       fdh->elf.ref_regular |= fh->elf.ref_regular;
5379       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5380       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5381       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
5382       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
5383         {
5384           struct plt_entry **ep = &fdh->elf.plt.plist;
5385           while (*ep != NULL)
5386             ep = &(*ep)->next;
5387           *ep = fh->elf.plt.plist;
5388           fh->elf.plt.plist = NULL;
5389           fdh->elf.needs_plt = 1;
5390         }
5391       fdh->is_func_descriptor = 1;
5392       fdh->oh = fh;
5393       fh->oh = fdh;
5394     }
5395
5396   /* Now that the info is on the function descriptor, clear the
5397      function code sym info.  Any function code syms for which we
5398      don't have a definition in a regular file, we force local.
5399      This prevents a shared library from exporting syms that have
5400      been imported from another library.  Function code syms that
5401      are really in the library we must leave global to prevent the
5402      linker dragging in a definition from a static library.  */
5403   force_local
5404     = (info->shared
5405        && (!fh->elf.def_regular
5406            || fdh == NULL
5407            || !fdh->elf.def_regular
5408            || fdh->elf.forced_local));
5409   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5410
5411   return TRUE;
5412 }
5413
5414 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
5415    this hook to a) provide some gcc support functions, and b) transfer
5416    dynamic linking information gathered so far on function code symbol
5417    entries, to their corresponding function descriptor symbol entries.  */
5418
5419 static bfd_boolean
5420 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5421                             struct bfd_link_info *info)
5422 {
5423   struct ppc_link_hash_table *htab;
5424   unsigned int i;
5425   const struct sfpr_def_parms funcs[] =
5426     {
5427       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5428       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5429       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5430       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5431       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5432       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5433       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5434       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5435       { "._savef", 14, 31, savefpr, savefpr1_tail },
5436       { "._restf", 14, 31, restfpr, restfpr1_tail },
5437       { "_savevr_", 20, 31, savevr, savevr_tail },
5438       { "_restvr_", 20, 31, restvr, restvr_tail }
5439     };
5440
5441   htab = ppc_hash_table (info);
5442   if (htab->sfpr == NULL)
5443     /* We don't have any relocs.  */
5444     return TRUE;
5445
5446   /* Provide any missing _save* and _rest* functions.  */
5447   htab->sfpr->size = 0;
5448   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5449     if (!sfpr_define (info, &funcs[i]))
5450       return FALSE;
5451
5452   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5453
5454   if (htab->sfpr->size == 0)
5455     _bfd_strip_section_from_output (info, htab->sfpr);
5456
5457   return TRUE;
5458 }
5459
5460 /* Adjust a symbol defined by a dynamic object and referenced by a
5461    regular object.  The current definition is in some section of the
5462    dynamic object, but we're not including those sections.  We have to
5463    change the definition to something the rest of the link can
5464    understand.  */
5465
5466 static bfd_boolean
5467 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5468                                  struct elf_link_hash_entry *h)
5469 {
5470   struct ppc_link_hash_table *htab;
5471   asection *s;
5472   unsigned int power_of_two;
5473
5474   htab = ppc_hash_table (info);
5475
5476   /* Deal with function syms.  */
5477   if (h->type == STT_FUNC
5478       || h->needs_plt)
5479     {
5480       /* Clear procedure linkage table information for any symbol that
5481          won't need a .plt entry.  */
5482       struct plt_entry *ent;
5483       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5484         if (ent->plt.refcount > 0)
5485           break;
5486       if (ent == NULL
5487           || SYMBOL_CALLS_LOCAL (info, h)
5488           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5489               && h->root.type == bfd_link_hash_undefweak))
5490         {
5491           h->plt.plist = NULL;
5492           h->needs_plt = 0;
5493         }
5494     }
5495   else
5496     h->plt.plist = NULL;
5497
5498   /* If this is a weak symbol, and there is a real definition, the
5499      processor independent code will have arranged for us to see the
5500      real definition first, and we can just use the same value.  */
5501   if (h->weakdef != NULL)
5502     {
5503       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
5504                   || h->weakdef->root.type == bfd_link_hash_defweak);
5505       h->root.u.def.section = h->weakdef->root.u.def.section;
5506       h->root.u.def.value = h->weakdef->root.u.def.value;
5507       if (ELIMINATE_COPY_RELOCS)
5508         h->non_got_ref = h->weakdef->non_got_ref;
5509       return TRUE;
5510     }
5511
5512   /* If we are creating a shared library, we must presume that the
5513      only references to the symbol are via the global offset table.
5514      For such cases we need not do anything here; the relocations will
5515      be handled correctly by relocate_section.  */
5516   if (info->shared)
5517     return TRUE;
5518
5519   /* If there are no references to this symbol that do not use the
5520      GOT, we don't need to generate a copy reloc.  */
5521   if (!h->non_got_ref)
5522     return TRUE;
5523
5524   if (ELIMINATE_COPY_RELOCS)
5525     {
5526       struct ppc_link_hash_entry * eh;
5527       struct ppc_dyn_relocs *p;
5528
5529       eh = (struct ppc_link_hash_entry *) h;
5530       for (p = eh->dyn_relocs; p != NULL; p = p->next)
5531         {
5532           s = p->sec->output_section;
5533           if (s != NULL && (s->flags & SEC_READONLY) != 0)
5534             break;
5535         }
5536
5537       /* If we didn't find any dynamic relocs in read-only sections, then
5538          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
5539       if (p == NULL)
5540         {
5541           h->non_got_ref = 0;
5542           return TRUE;
5543         }
5544     }
5545
5546   if (h->plt.plist != NULL)
5547     {
5548       /* We should never get here, but unfortunately there are versions
5549          of gcc out there that improperly (for this ABI) put initialized
5550          function pointers, vtable refs and suchlike in read-only
5551          sections.  Allow them to proceed, but warn that this might
5552          break at runtime.  */
5553       (*_bfd_error_handler)
5554         (_("copy reloc against `%s' requires lazy plt linking; "
5555            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
5556          h->root.root.string);
5557     }
5558
5559   /* This is a reference to a symbol defined by a dynamic object which
5560      is not a function.  */
5561
5562   /* We must allocate the symbol in our .dynbss section, which will
5563      become part of the .bss section of the executable.  There will be
5564      an entry for this symbol in the .dynsym section.  The dynamic
5565      object will contain position independent code, so all references
5566      from the dynamic object to this symbol will go through the global
5567      offset table.  The dynamic linker will use the .dynsym entry to
5568      determine the address it must put in the global offset table, so
5569      both the dynamic object and the regular object will refer to the
5570      same memory location for the variable.  */
5571
5572   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
5573      to copy the initial value out of the dynamic object and into the
5574      runtime process image.  We need to remember the offset into the
5575      .rela.bss section we are going to use.  */
5576   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5577     {
5578       htab->relbss->size += sizeof (Elf64_External_Rela);
5579       h->needs_copy = 1;
5580     }
5581
5582   /* We need to figure out the alignment required for this symbol.  I
5583      have no idea how ELF linkers handle this.  */
5584   power_of_two = bfd_log2 (h->size);
5585   if (power_of_two > 4)
5586     power_of_two = 4;
5587
5588   /* Apply the required alignment.  */
5589   s = htab->dynbss;
5590   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5591   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
5592     {
5593       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
5594         return FALSE;
5595     }
5596
5597   /* Define the symbol as being at this point in the section.  */
5598   h->root.u.def.section = s;
5599   h->root.u.def.value = s->size;
5600
5601   /* Increment the section size to make room for the symbol.  */
5602   s->size += h->size;
5603
5604   return TRUE;
5605 }
5606
5607 /* If given a function descriptor symbol, hide both the function code
5608    sym and the descriptor.  */
5609 static void
5610 ppc64_elf_hide_symbol (struct bfd_link_info *info,
5611                        struct elf_link_hash_entry *h,
5612                        bfd_boolean force_local)
5613 {
5614   struct ppc_link_hash_entry *eh;
5615   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
5616
5617   eh = (struct ppc_link_hash_entry *) h;
5618   if (eh->is_func_descriptor)
5619     {
5620       struct ppc_link_hash_entry *fh = eh->oh;
5621
5622       if (fh == NULL)
5623         {
5624           const char *p, *q;
5625           struct ppc_link_hash_table *htab;
5626           char save;
5627
5628           /* We aren't supposed to use alloca in BFD because on
5629              systems which do not have alloca the version in libiberty
5630              calls xmalloc, which might cause the program to crash
5631              when it runs out of memory.  This function doesn't have a
5632              return status, so there's no way to gracefully return an
5633              error.  So cheat.  We know that string[-1] can be safely
5634              accessed;  It's either a string in an ELF string table,
5635              or allocated in an objalloc structure.  */
5636
5637           p = eh->elf.root.root.string - 1;
5638           save = *p;
5639           *(char *) p = '.';
5640           htab = ppc_hash_table (info);
5641           fh = (struct ppc_link_hash_entry *)
5642             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5643           *(char *) p = save;
5644
5645           /* Unfortunately, if it so happens that the string we were
5646              looking for was allocated immediately before this string,
5647              then we overwrote the string terminator.  That's the only
5648              reason the lookup should fail.  */
5649           if (fh == NULL)
5650             {
5651               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
5652               while (q >= eh->elf.root.root.string && *q == *p)
5653                 --q, --p;
5654               if (q < eh->elf.root.root.string && *p == '.')
5655                 fh = (struct ppc_link_hash_entry *)
5656                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5657             }
5658           if (fh != NULL)
5659             {
5660               eh->oh = fh;
5661               fh->oh = eh;
5662             }
5663         }
5664       if (fh != NULL)
5665         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5666     }
5667 }
5668
5669 static bfd_boolean
5670 get_sym_h (struct elf_link_hash_entry **hp,
5671            Elf_Internal_Sym **symp,
5672            asection **symsecp,
5673            char **tls_maskp,
5674            Elf_Internal_Sym **locsymsp,
5675            unsigned long r_symndx,
5676            bfd *ibfd)
5677 {
5678   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5679
5680   if (r_symndx >= symtab_hdr->sh_info)
5681     {
5682       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
5683       struct elf_link_hash_entry *h;
5684
5685       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5686       while (h->root.type == bfd_link_hash_indirect
5687              || h->root.type == bfd_link_hash_warning)
5688         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5689
5690       if (hp != NULL)
5691         *hp = h;
5692
5693       if (symp != NULL)
5694         *symp = NULL;
5695
5696       if (symsecp != NULL)
5697         {
5698           asection *symsec = NULL;
5699           if (h->root.type == bfd_link_hash_defined
5700               || h->root.type == bfd_link_hash_defweak)
5701             symsec = h->root.u.def.section;
5702           *symsecp = symsec;
5703         }
5704
5705       if (tls_maskp != NULL)
5706         {
5707           struct ppc_link_hash_entry *eh;
5708
5709           eh = (struct ppc_link_hash_entry *) h;
5710           *tls_maskp = &eh->tls_mask;
5711         }
5712     }
5713   else
5714     {
5715       Elf_Internal_Sym *sym;
5716       Elf_Internal_Sym *locsyms = *locsymsp;
5717
5718       if (locsyms == NULL)
5719         {
5720           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
5721           if (locsyms == NULL)
5722             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
5723                                             symtab_hdr->sh_info,
5724                                             0, NULL, NULL, NULL);
5725           if (locsyms == NULL)
5726             return FALSE;
5727           *locsymsp = locsyms;
5728         }
5729       sym = locsyms + r_symndx;
5730
5731       if (hp != NULL)
5732         *hp = NULL;
5733
5734       if (symp != NULL)
5735         *symp = sym;
5736
5737       if (symsecp != NULL)
5738         {
5739           asection *symsec = NULL;
5740           if ((sym->st_shndx != SHN_UNDEF
5741                && sym->st_shndx < SHN_LORESERVE)
5742               || sym->st_shndx > SHN_HIRESERVE)
5743             symsec = bfd_section_from_elf_index (ibfd, sym->st_shndx);
5744           *symsecp = symsec;
5745         }
5746
5747       if (tls_maskp != NULL)
5748         {
5749           struct got_entry **lgot_ents;
5750           char *tls_mask;
5751
5752           tls_mask = NULL;
5753           lgot_ents = elf_local_got_ents (ibfd);
5754           if (lgot_ents != NULL)
5755             {
5756               char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
5757               tls_mask = &lgot_masks[r_symndx];
5758             }
5759           *tls_maskp = tls_mask;
5760         }
5761     }
5762   return TRUE;
5763 }
5764
5765 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
5766    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
5767    type suitable for optimization, and 1 otherwise.  */
5768
5769 static int
5770 get_tls_mask (char **tls_maskp, unsigned long *toc_symndx,
5771               Elf_Internal_Sym **locsymsp,
5772               const Elf_Internal_Rela *rel, bfd *ibfd)
5773 {
5774   unsigned long r_symndx;
5775   int next_r;
5776   struct elf_link_hash_entry *h;
5777   Elf_Internal_Sym *sym;
5778   asection *sec;
5779   bfd_vma off;
5780
5781   r_symndx = ELF64_R_SYM (rel->r_info);
5782   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
5783     return 0;
5784
5785   if ((*tls_maskp != NULL && **tls_maskp != 0)
5786       || sec == NULL
5787       || ppc64_elf_section_data (sec)->t_symndx == NULL)
5788     return 1;
5789
5790   /* Look inside a TOC section too.  */
5791   if (h != NULL)
5792     {
5793       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5794       off = h->root.u.def.value;
5795     }
5796   else
5797     off = sym->st_value;
5798   off += rel->r_addend;
5799   BFD_ASSERT (off % 8 == 0);
5800   r_symndx = ppc64_elf_section_data (sec)->t_symndx[off / 8];
5801   next_r = ppc64_elf_section_data (sec)->t_symndx[off / 8 + 1];
5802   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
5803     return 0;
5804   if (toc_symndx != NULL)
5805     *toc_symndx = r_symndx;
5806   if ((h == NULL
5807        || ((h->root.type == bfd_link_hash_defined
5808             || h->root.type == bfd_link_hash_defweak)
5809            && !h->def_dynamic))
5810       && (next_r == -1 || next_r == -2))
5811     return 1 - next_r;
5812   return 1;
5813 }
5814
5815 /* Adjust all global syms defined in opd sections.  In gcc generated
5816    code for the old ABI, these will already have been done.  */
5817
5818 static bfd_boolean
5819 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
5820 {
5821   struct ppc_link_hash_entry *eh;
5822   asection *sym_sec;
5823   long *opd_adjust;
5824
5825   if (h->root.type == bfd_link_hash_indirect)
5826     return TRUE;
5827
5828   if (h->root.type == bfd_link_hash_warning)
5829     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5830
5831   if (h->root.type != bfd_link_hash_defined
5832       && h->root.type != bfd_link_hash_defweak)
5833     return TRUE;
5834
5835   eh = (struct ppc_link_hash_entry *) h;
5836   if (eh->adjust_done)
5837     return TRUE;
5838
5839   sym_sec = eh->elf.root.u.def.section;
5840   opd_adjust = get_opd_info (sym_sec);
5841   if (opd_adjust != NULL)
5842     {
5843       long adjust = opd_adjust[eh->elf.root.u.def.value / 8];
5844       if (adjust == -1)
5845         {
5846           /* This entry has been deleted.  */
5847           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
5848           if (dsec == NULL)
5849             {
5850               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
5851                 if (elf_discarded_section (dsec))
5852                   {
5853                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
5854                     break;
5855                   }
5856             }
5857           eh->elf.root.u.def.value = 0;
5858           eh->elf.root.u.def.section = dsec;
5859         }
5860       else
5861         eh->elf.root.u.def.value += adjust;
5862       eh->adjust_done = 1;
5863     }
5864   return TRUE;
5865 }
5866
5867 /* Remove unused Official Procedure Descriptor entries.  Currently we
5868    only remove those associated with functions in discarded link-once
5869    sections, or weakly defined functions that have been overridden.  It
5870    would be possible to remove many more entries for statically linked
5871    applications.  */
5872
5873 bfd_boolean
5874 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
5875                     bfd_boolean non_overlapping)
5876 {
5877   bfd *ibfd;
5878   bfd_boolean some_edited = FALSE;
5879   asection *need_pad = NULL;
5880
5881   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5882     {
5883       asection *sec;
5884       Elf_Internal_Rela *relstart, *rel, *relend;
5885       Elf_Internal_Shdr *symtab_hdr;
5886       Elf_Internal_Sym *local_syms;
5887       struct elf_link_hash_entry **sym_hashes;
5888       bfd_vma offset;
5889       bfd_size_type amt;
5890       long *opd_adjust;
5891       bfd_boolean need_edit, add_aux_fields;
5892       bfd_size_type cnt_16b = 0;
5893
5894       sec = bfd_get_section_by_name (ibfd, ".opd");
5895       if (sec == NULL)
5896         continue;
5897
5898       amt = sec->size * sizeof (long) / 8;
5899       opd_adjust = get_opd_info (sec);
5900       if (opd_adjust == NULL)
5901         {
5902           /* Must be a ld -r link.  ie. check_relocs hasn't been
5903              called.  */
5904           opd_adjust = bfd_zalloc (obfd, amt);
5905           ppc64_elf_section_data (sec)->opd.adjust = opd_adjust;
5906         }
5907       memset (opd_adjust, 0, amt);
5908
5909       if (sec->output_section == bfd_abs_section_ptr)
5910         continue;
5911
5912       /* Look through the section relocs.  */
5913       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
5914         continue;
5915
5916       local_syms = NULL;
5917       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5918       sym_hashes = elf_sym_hashes (ibfd);
5919
5920       /* Read the relocations.  */
5921       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
5922                                             info->keep_memory);
5923       if (relstart == NULL)
5924         return FALSE;
5925
5926       /* First run through the relocs to check they are sane, and to
5927          determine whether we need to edit this opd section.  */
5928       need_edit = FALSE;
5929       need_pad = sec;
5930       offset = 0;
5931       relend = relstart + sec->reloc_count;
5932       for (rel = relstart; rel < relend; )
5933         {
5934           enum elf_ppc64_reloc_type r_type;
5935           unsigned long r_symndx;
5936           asection *sym_sec;
5937           struct elf_link_hash_entry *h;
5938           Elf_Internal_Sym *sym;
5939
5940           /* .opd contains a regular array of 16 or 24 byte entries.  We're
5941              only interested in the reloc pointing to a function entry
5942              point.  */
5943           if (rel->r_offset != offset
5944               || rel + 1 >= relend
5945               || (rel + 1)->r_offset != offset + 8)
5946             {
5947               /* If someone messes with .opd alignment then after a
5948                  "ld -r" we might have padding in the middle of .opd.
5949                  Also, there's nothing to prevent someone putting
5950                  something silly in .opd with the assembler.  No .opd
5951                  optimization for them!  */
5952             broken_opd:
5953               (*_bfd_error_handler)
5954                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
5955               need_edit = FALSE;
5956               break;
5957             }
5958
5959           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
5960               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
5961             {
5962               (*_bfd_error_handler)
5963                 (_("%B: unexpected reloc type %u in .opd section"),
5964                  ibfd, r_type);
5965               need_edit = FALSE;
5966               break;
5967             }
5968
5969           r_symndx = ELF64_R_SYM (rel->r_info);
5970           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
5971                           r_symndx, ibfd))
5972             goto error_ret;
5973
5974           if (sym_sec == NULL || sym_sec->owner == NULL)
5975             {
5976               const char *sym_name;
5977               if (h != NULL)
5978                 sym_name = h->root.root.string;
5979               else
5980                 sym_name = bfd_elf_local_sym_name (ibfd, sym);
5981
5982               (*_bfd_error_handler)
5983                 (_("%B: undefined sym `%s' in .opd section"),
5984                  ibfd, sym_name);
5985               need_edit = FALSE;
5986               break;
5987             }
5988
5989           /* opd entries are always for functions defined in the
5990              current input bfd.  If the symbol isn't defined in the
5991              input bfd, then we won't be using the function in this
5992              bfd;  It must be defined in a linkonce section in another
5993              bfd, or is weak.  It's also possible that we are
5994              discarding the function due to a linker script /DISCARD/,
5995              which we test for via the output_section.  */
5996           if (sym_sec->owner != ibfd
5997               || sym_sec->output_section == bfd_abs_section_ptr)
5998             need_edit = TRUE;
5999
6000           rel += 2;
6001           if (rel == relend
6002               || (rel + 1 == relend && rel->r_offset == offset + 16))
6003             {
6004               if (sec->size == offset + 24)
6005                 {
6006                   need_pad = NULL;
6007                   break;
6008                 }
6009               if (rel == relend && sec->size == offset + 16)
6010                 {
6011                   cnt_16b++;
6012                   break;
6013                 }
6014               goto broken_opd;
6015             }
6016
6017           if (rel->r_offset == offset + 24)
6018             offset += 24;
6019           else if (rel->r_offset != offset + 16)
6020             goto broken_opd;
6021           else if (rel + 1 < relend
6022                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6023                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6024             {
6025               offset += 16;
6026               cnt_16b++;
6027             }
6028           else if (rel + 2 < relend
6029                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6030                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6031             {
6032               offset += 24;
6033               rel += 1;
6034             }
6035           else
6036             goto broken_opd;
6037         }
6038
6039       add_aux_fields = non_overlapping && cnt_16b > 0;
6040
6041       if (need_edit || add_aux_fields)
6042         {
6043           Elf_Internal_Rela *write_rel;
6044           bfd_byte *rptr, *wptr;
6045           bfd_byte *new_contents = NULL;
6046           bfd_boolean skip;
6047           long opd_ent_size;
6048
6049           /* This seems a waste of time as input .opd sections are all
6050              zeros as generated by gcc, but I suppose there's no reason
6051              this will always be so.  We might start putting something in
6052              the third word of .opd entries.  */
6053           if ((sec->flags & SEC_IN_MEMORY) == 0)
6054             {
6055               bfd_byte *loc;
6056               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6057                 {
6058                   if (loc != NULL)
6059                     free (loc);
6060                 error_ret:
6061                   if (local_syms != NULL
6062                       && symtab_hdr->contents != (unsigned char *) local_syms)
6063                     free (local_syms);
6064                   if (elf_section_data (sec)->relocs != relstart)
6065                     free (relstart);
6066                   return FALSE;
6067                 }
6068               sec->contents = loc;
6069               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6070             }
6071
6072           elf_section_data (sec)->relocs = relstart;
6073
6074           wptr = sec->contents;
6075           rptr = sec->contents;
6076           new_contents = sec->contents;
6077
6078           if (add_aux_fields)
6079             {
6080               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6081               if (new_contents == NULL)
6082                 return FALSE;
6083               need_pad = FALSE;
6084               wptr = new_contents;
6085             }
6086
6087           write_rel = relstart;
6088           skip = FALSE;
6089           offset = 0;
6090           opd_ent_size = 0;
6091           for (rel = relstart; rel < relend; rel++)
6092             {
6093               unsigned long r_symndx;
6094               asection *sym_sec;
6095               struct elf_link_hash_entry *h;
6096               Elf_Internal_Sym *sym;
6097
6098               r_symndx = ELF64_R_SYM (rel->r_info);
6099               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6100                               r_symndx, ibfd))
6101                 goto error_ret;
6102
6103               if (rel->r_offset == offset)
6104                 {
6105                   struct ppc_link_hash_entry *fdh = NULL;
6106
6107                   /* See if the .opd entry is full 24 byte or
6108                      16 byte (with fd_aux entry overlapped with next
6109                      fd_func).  */
6110                   opd_ent_size = 24;
6111                   if ((rel + 2 == relend && sec->size == offset + 16)
6112                       || (rel + 3 < relend
6113                           && rel[2].r_offset == offset + 16
6114                           && rel[3].r_offset == offset + 24
6115                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6116                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6117                     opd_ent_size = 16;
6118
6119                   if (h != NULL
6120                       && h->root.root.string[0] == '.')
6121                     fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6122                                    ppc_hash_table (info));
6123
6124                   skip = (sym_sec->owner != ibfd
6125                           || sym_sec->output_section == bfd_abs_section_ptr);
6126                   if (skip)
6127                     {
6128                       if (fdh != NULL && sym_sec->owner == ibfd)
6129                         {
6130                           /* Arrange for the function descriptor sym
6131                              to be dropped.  */
6132                           fdh->elf.root.u.def.value = 0;
6133                           fdh->elf.root.u.def.section = sym_sec;
6134                         }
6135                       opd_adjust[rel->r_offset / 8] = -1;
6136                     }
6137                   else
6138                     {
6139                       /* We'll be keeping this opd entry.  */
6140
6141                       if (fdh != NULL)
6142                         {
6143                           /* Redefine the function descriptor symbol to
6144                              this location in the opd section.  It is
6145                              necessary to update the value here rather
6146                              than using an array of adjustments as we do
6147                              for local symbols, because various places
6148                              in the generic ELF code use the value
6149                              stored in u.def.value.  */
6150                           fdh->elf.root.u.def.value = wptr - new_contents;
6151                           fdh->adjust_done = 1;
6152                         }
6153
6154                       /* Local syms are a bit tricky.  We could
6155                          tweak them as they can be cached, but
6156                          we'd need to look through the local syms
6157                          for the function descriptor sym which we
6158                          don't have at the moment.  So keep an
6159                          array of adjustments.  */
6160                       opd_adjust[rel->r_offset / 8]
6161                         = (wptr - new_contents) - (rptr - sec->contents);
6162
6163                       if (wptr != rptr)
6164                         memcpy (wptr, rptr, opd_ent_size);
6165                       wptr += opd_ent_size;
6166                       if (add_aux_fields && opd_ent_size == 16)
6167                         {
6168                           memset (wptr, '\0', 8);
6169                           wptr += 8;
6170                         }
6171                     }
6172                   rptr += opd_ent_size;
6173                   offset += opd_ent_size;
6174                 }
6175
6176               if (skip)
6177                 {
6178                   BFD_ASSERT (MUST_BE_DYN_RELOC (ELF64_R_TYPE (rel->r_info)));
6179                   if (info->shared)
6180                     {
6181                       /* We won't be needing dynamic relocs here.  */
6182                       struct ppc_dyn_relocs **pp;
6183                       struct ppc_dyn_relocs *p;
6184
6185                       if (h != NULL)
6186                         pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6187                       else if (sym_sec != NULL)
6188                         pp = ((struct ppc_dyn_relocs **)
6189                               &elf_section_data (sym_sec)->local_dynrel);
6190                       else
6191                         pp = ((struct ppc_dyn_relocs **)
6192                               &elf_section_data (sec)->local_dynrel);
6193                       while ((p = *pp) != NULL)
6194                         {
6195                           if (p->sec == sec)
6196                             {
6197                               p->count -= 1;
6198                               if (p->count == 0)
6199                                 *pp = p->next;
6200                               break;
6201                             }
6202                           pp = &p->next;
6203                         }
6204                     }
6205                 }
6206               else
6207                 {
6208                   /* We need to adjust any reloc offsets to point to the
6209                      new opd entries.  While we're at it, we may as well
6210                      remove redundant relocs.  */
6211                   rel->r_offset += opd_adjust[(offset - opd_ent_size) / 8];
6212                   if (write_rel != rel)
6213                     memcpy (write_rel, rel, sizeof (*rel));
6214                   ++write_rel;
6215                 }
6216             }
6217
6218           sec->size = wptr - new_contents;
6219           sec->reloc_count = write_rel - relstart;
6220           if (add_aux_fields)
6221             {
6222               free (sec->contents);
6223               sec->contents = new_contents;
6224             }
6225
6226           /* Fudge the size too, as this is used later in
6227              elf_bfd_final_link if we are emitting relocs.  */
6228           elf_section_data (sec)->rel_hdr.sh_size
6229             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6230           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
6231           some_edited = TRUE;
6232         }
6233       else if (elf_section_data (sec)->relocs != relstart)
6234         free (relstart);
6235
6236       if (local_syms != NULL
6237           && symtab_hdr->contents != (unsigned char *) local_syms)
6238         {
6239           if (!info->keep_memory)
6240             free (local_syms);
6241           else
6242             symtab_hdr->contents = (unsigned char *) local_syms;
6243         }
6244     }
6245
6246   if (some_edited)
6247     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6248
6249   /* If we are doing a final link and the last .opd entry is just 16 byte
6250      long, add a 8 byte padding after it.  */
6251   if (need_pad != NULL && !info->relocatable)
6252     {
6253       bfd_byte *p;
6254
6255       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6256         {
6257           BFD_ASSERT (need_pad->size > 0);
6258
6259           p = bfd_malloc (need_pad->size + 8);
6260           if (p == NULL)
6261             return FALSE;
6262
6263           if (! bfd_get_section_contents (need_pad->owner, need_pad,
6264                                           p, 0, need_pad->size))
6265             return FALSE;
6266
6267           need_pad->contents = p;
6268           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6269         }
6270       else
6271         {
6272           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6273           if (p == NULL)
6274             return FALSE;
6275
6276           need_pad->contents = p;
6277         }
6278
6279       memset (need_pad->contents + need_pad->size, 0, 8);
6280       need_pad->size += 8;
6281     }
6282
6283   return TRUE;
6284 }
6285
6286 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
6287
6288 asection *
6289 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
6290 {
6291   struct ppc_link_hash_table *htab;
6292
6293   htab = ppc_hash_table (info);
6294   if (htab->tls_get_addr != NULL)
6295     {
6296       struct ppc_link_hash_entry *h = htab->tls_get_addr;
6297
6298       while (h->elf.root.type == bfd_link_hash_indirect
6299              || h->elf.root.type == bfd_link_hash_warning)
6300         h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6301
6302       htab->tls_get_addr = h;
6303
6304       if (htab->tls_get_addr_fd == NULL
6305           && h->oh != NULL
6306           && h->oh->is_func_descriptor)
6307         htab->tls_get_addr_fd = h->oh;
6308     }
6309
6310   if (htab->tls_get_addr_fd != NULL)
6311     {
6312       struct ppc_link_hash_entry *h = htab->tls_get_addr_fd;
6313
6314       while (h->elf.root.type == bfd_link_hash_indirect
6315              || h->elf.root.type == bfd_link_hash_warning)
6316         h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6317
6318       htab->tls_get_addr_fd = h;
6319     }
6320
6321   return _bfd_elf_tls_setup (obfd, info);
6322 }
6323
6324 /* Run through all the TLS relocs looking for optimization
6325    opportunities.  The linker has been hacked (see ppc64elf.em) to do
6326    a preliminary section layout so that we know the TLS segment
6327    offsets.  We can't optimize earlier because some optimizations need
6328    to know the tp offset, and we need to optimize before allocating
6329    dynamic relocations.  */
6330
6331 bfd_boolean
6332 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6333 {
6334   bfd *ibfd;
6335   asection *sec;
6336   struct ppc_link_hash_table *htab;
6337
6338   if (info->relocatable || info->shared)
6339     return TRUE;
6340
6341   htab = ppc_hash_table (info);
6342   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6343     {
6344       Elf_Internal_Sym *locsyms = NULL;
6345
6346       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6347         if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
6348           {
6349             Elf_Internal_Rela *relstart, *rel, *relend;
6350             int expecting_tls_get_addr;
6351
6352             /* Read the relocations.  */
6353             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6354                                                   info->keep_memory);
6355             if (relstart == NULL)
6356               return FALSE;
6357
6358             expecting_tls_get_addr = 0;
6359             relend = relstart + sec->reloc_count;
6360             for (rel = relstart; rel < relend; rel++)
6361               {
6362                 enum elf_ppc64_reloc_type r_type;
6363                 unsigned long r_symndx;
6364                 struct elf_link_hash_entry *h;
6365                 Elf_Internal_Sym *sym;
6366                 asection *sym_sec;
6367                 char *tls_mask;
6368                 char tls_set, tls_clear, tls_type = 0;
6369                 bfd_vma value;
6370                 bfd_boolean ok_tprel, is_local;
6371
6372                 r_symndx = ELF64_R_SYM (rel->r_info);
6373                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
6374                                 r_symndx, ibfd))
6375                   {
6376                   err_free_rel:
6377                     if (elf_section_data (sec)->relocs != relstart)
6378                       free (relstart);
6379                     if (locsyms != NULL
6380                         && (elf_tdata (ibfd)->symtab_hdr.contents
6381                             != (unsigned char *) locsyms))
6382                       free (locsyms);
6383                     return FALSE;
6384                   }
6385
6386                 if (h != NULL)
6387                   {
6388                     if (h->root.type != bfd_link_hash_defined
6389                         && h->root.type != bfd_link_hash_defweak)
6390                       continue;
6391                     value = h->root.u.def.value;
6392                   }
6393                 else
6394                   /* Symbols referenced by TLS relocs must be of type
6395                      STT_TLS.  So no need for .opd local sym adjust.  */
6396                   value = sym->st_value;
6397
6398                 ok_tprel = FALSE;
6399                 is_local = FALSE;
6400                 if (h == NULL
6401                     || !h->def_dynamic)
6402                   {
6403                     is_local = TRUE;
6404                     value += sym_sec->output_offset;
6405                     value += sym_sec->output_section->vma;
6406                     value -= htab->elf.tls_sec->vma;
6407                     ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
6408                                 < (bfd_vma) 1 << 32);
6409                   }
6410
6411                 r_type = ELF64_R_TYPE (rel->r_info);
6412                 switch (r_type)
6413                   {
6414                   case R_PPC64_GOT_TLSLD16:
6415                   case R_PPC64_GOT_TLSLD16_LO:
6416                   case R_PPC64_GOT_TLSLD16_HI:
6417                   case R_PPC64_GOT_TLSLD16_HA:
6418                     /* These relocs should never be against a symbol
6419                        defined in a shared lib.  Leave them alone if
6420                        that turns out to be the case.  */
6421                     ppc64_tlsld_got (ibfd)->refcount -= 1;
6422                     if (!is_local)
6423                       continue;
6424
6425                     /* LD -> LE */
6426                     tls_set = 0;
6427                     tls_clear = TLS_LD;
6428                     tls_type = TLS_TLS | TLS_LD;
6429                     expecting_tls_get_addr = 1;
6430                     break;
6431
6432                   case R_PPC64_GOT_TLSGD16:
6433                   case R_PPC64_GOT_TLSGD16_LO:
6434                   case R_PPC64_GOT_TLSGD16_HI:
6435                   case R_PPC64_GOT_TLSGD16_HA:
6436                     if (ok_tprel)
6437                       /* GD -> LE */
6438                       tls_set = 0;
6439                     else
6440                       /* GD -> IE */
6441                       tls_set = TLS_TLS | TLS_TPRELGD;
6442                     tls_clear = TLS_GD;
6443                     tls_type = TLS_TLS | TLS_GD;
6444                     expecting_tls_get_addr = 1;
6445                     break;
6446
6447                   case R_PPC64_GOT_TPREL16_DS:
6448                   case R_PPC64_GOT_TPREL16_LO_DS:
6449                   case R_PPC64_GOT_TPREL16_HI:
6450                   case R_PPC64_GOT_TPREL16_HA:
6451                     expecting_tls_get_addr = 0;
6452                     if (ok_tprel)
6453                       {
6454                         /* IE -> LE */
6455                         tls_set = 0;
6456                         tls_clear = TLS_TPREL;
6457                         tls_type = TLS_TLS | TLS_TPREL;
6458                         break;
6459                       }
6460                     else
6461                       continue;
6462
6463                   case R_PPC64_REL14:
6464                   case R_PPC64_REL14_BRTAKEN:
6465                   case R_PPC64_REL14_BRNTAKEN:
6466                   case R_PPC64_REL24:
6467                     if (h != NULL
6468                         && (h == &htab->tls_get_addr->elf
6469                             || h == &htab->tls_get_addr_fd->elf))
6470                       {
6471                         if (!expecting_tls_get_addr
6472                             && rel != relstart
6473                             && ((ELF64_R_TYPE (rel[-1].r_info)
6474                                  == R_PPC64_TOC16)
6475                                 || (ELF64_R_TYPE (rel[-1].r_info)
6476                                     == R_PPC64_TOC16_LO)))
6477                           {
6478                             /* Check for toc tls entries.  */
6479                             char *toc_tls;
6480                             int retval;
6481
6482                             retval = get_tls_mask (&toc_tls, NULL, &locsyms,
6483                                                    rel - 1, ibfd);
6484                             if (retval == 0)
6485                               goto err_free_rel;
6486                             if (toc_tls != NULL)
6487                               expecting_tls_get_addr = retval > 1;
6488                           }
6489
6490                         if (expecting_tls_get_addr)
6491                           {
6492                             struct plt_entry *ent;
6493                             for (ent = h->plt.plist; ent; ent = ent->next)
6494                               if (ent->addend == 0)
6495                                 {
6496                                   if (ent->plt.refcount > 0)
6497                                     ent->plt.refcount -= 1;
6498                                   break;
6499                                 }
6500                           }
6501                       }
6502                     expecting_tls_get_addr = 0;
6503                     continue;
6504
6505                   case R_PPC64_TPREL64:
6506                     expecting_tls_get_addr = 0;
6507                     if (ok_tprel)
6508                       {
6509                         /* IE -> LE */
6510                         tls_set = TLS_EXPLICIT;
6511                         tls_clear = TLS_TPREL;
6512                         break;
6513                       }
6514                     else
6515                       continue;
6516
6517                   case R_PPC64_DTPMOD64:
6518                     expecting_tls_get_addr = 0;
6519                     if (rel + 1 < relend
6520                         && (rel[1].r_info
6521                             == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
6522                         && rel[1].r_offset == rel->r_offset + 8)
6523                       {
6524                         if (ok_tprel)
6525                           /* GD -> LE */
6526                           tls_set = TLS_EXPLICIT | TLS_GD;
6527                         else
6528                           /* GD -> IE */
6529                           tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
6530                         tls_clear = TLS_GD;
6531                       }
6532                     else
6533                       {
6534                         if (!is_local)
6535                           continue;
6536
6537                         /* LD -> LE */
6538                         tls_set = TLS_EXPLICIT;
6539                         tls_clear = TLS_LD;
6540                       }
6541                     break;
6542
6543                   default:
6544                     expecting_tls_get_addr = 0;
6545                     continue;
6546                   }
6547
6548                 if ((tls_set & TLS_EXPLICIT) == 0)
6549                   {
6550                     struct got_entry *ent;
6551
6552                     /* Adjust got entry for this reloc.  */
6553                     if (h != NULL)
6554                       ent = h->got.glist;
6555                     else
6556                       ent = elf_local_got_ents (ibfd)[r_symndx];
6557
6558                     for (; ent != NULL; ent = ent->next)
6559                       if (ent->addend == rel->r_addend
6560                           && ent->owner == ibfd
6561                           && ent->tls_type == tls_type)
6562                         break;
6563                     if (ent == NULL)
6564                       abort ();
6565
6566                     if (tls_set == 0)
6567                       {
6568                         /* We managed to get rid of a got entry.  */
6569                         if (ent->got.refcount > 0)
6570                           ent->got.refcount -= 1;
6571                       }
6572                   }
6573                 else if (h != NULL)
6574                   {
6575                     struct ppc_link_hash_entry * eh;
6576                     struct ppc_dyn_relocs **pp;
6577                     struct ppc_dyn_relocs *p;
6578
6579                     /* Adjust dynamic relocs.  */
6580                     eh = (struct ppc_link_hash_entry *) h;
6581                     for (pp = &eh->dyn_relocs;
6582                          (p = *pp) != NULL;
6583                          pp = &p->next)
6584                       if (p->sec == sec)
6585                         {
6586                           /* If we got rid of a DTPMOD/DTPREL reloc
6587                              pair then we'll lose one or two dyn
6588                              relocs.  */
6589                           if (tls_set == (TLS_EXPLICIT | TLS_GD))
6590                             p->count -= 1;
6591                           p->count -= 1;
6592                           if (p->count == 0)
6593                             *pp = p->next;
6594                           break;
6595                         }
6596                   }
6597
6598                 *tls_mask |= tls_set;
6599                 *tls_mask &= ~tls_clear;
6600               }
6601
6602             if (elf_section_data (sec)->relocs != relstart)
6603               free (relstart);
6604           }
6605
6606       if (locsyms != NULL
6607           && (elf_tdata (ibfd)->symtab_hdr.contents
6608               != (unsigned char *) locsyms))
6609         {
6610           if (!info->keep_memory)
6611             free (locsyms);
6612           else
6613             elf_tdata (ibfd)->symtab_hdr.contents = (unsigned char *) locsyms;
6614         }
6615     }
6616   return TRUE;
6617 }
6618
6619 /* Allocate space in .plt, .got and associated reloc sections for
6620    dynamic relocs.  */
6621
6622 static bfd_boolean
6623 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6624 {
6625   struct bfd_link_info *info;
6626   struct ppc_link_hash_table *htab;
6627   asection *s;
6628   struct ppc_link_hash_entry *eh;
6629   struct ppc_dyn_relocs *p;
6630   struct got_entry *gent;
6631
6632   if (h->root.type == bfd_link_hash_indirect)
6633     return TRUE;
6634
6635   if (h->root.type == bfd_link_hash_warning)
6636     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6637
6638   info = (struct bfd_link_info *) inf;
6639   htab = ppc_hash_table (info);
6640
6641   if (htab->elf.dynamic_sections_created
6642       && h->dynindx != -1
6643       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
6644     {
6645       struct plt_entry *pent;
6646       bfd_boolean doneone = FALSE;
6647       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
6648         if (pent->plt.refcount > 0)
6649           {
6650             /* If this is the first .plt entry, make room for the special
6651                first entry.  */
6652             s = htab->plt;
6653             if (s->size == 0)
6654               s->size += PLT_INITIAL_ENTRY_SIZE;
6655
6656             pent->plt.offset = s->size;
6657
6658             /* Make room for this entry.  */
6659             s->size += PLT_ENTRY_SIZE;
6660
6661             /* Make room for the .glink code.  */
6662             s = htab->glink;
6663             if (s->size == 0)
6664               s->size += GLINK_CALL_STUB_SIZE;
6665             /* We need bigger stubs past index 32767.  */
6666             if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
6667               s->size += 4;
6668             s->size += 2*4;
6669
6670             /* We also need to make an entry in the .rela.plt section.  */
6671             s = htab->relplt;
6672             s->size += sizeof (Elf64_External_Rela);
6673             doneone = TRUE;
6674           }
6675         else
6676           pent->plt.offset = (bfd_vma) -1;
6677       if (!doneone)
6678         {
6679           h->plt.plist = NULL;
6680           h->needs_plt = 0;
6681         }
6682     }
6683   else
6684     {
6685       h->plt.plist = NULL;
6686       h->needs_plt = 0;
6687     }
6688
6689   eh = (struct ppc_link_hash_entry *) h;
6690   /* Run through the TLS GD got entries first if we're changing them
6691      to TPREL.  */
6692   if ((eh->tls_mask & TLS_TPRELGD) != 0)
6693     for (gent = h->got.glist; gent != NULL; gent = gent->next)
6694       if (gent->got.refcount > 0
6695           && (gent->tls_type & TLS_GD) != 0)
6696         {
6697           /* This was a GD entry that has been converted to TPREL.  If
6698              there happens to be a TPREL entry we can use that one.  */
6699           struct got_entry *ent;
6700           for (ent = h->got.glist; ent != NULL; ent = ent->next)
6701             if (ent->got.refcount > 0
6702                 && (ent->tls_type & TLS_TPREL) != 0
6703                 && ent->addend == gent->addend
6704                 && ent->owner == gent->owner)
6705               {
6706                 gent->got.refcount = 0;
6707                 break;
6708               }
6709
6710           /* If not, then we'll be using our own TPREL entry.  */
6711           if (gent->got.refcount != 0)
6712             gent->tls_type = TLS_TLS | TLS_TPREL;
6713         }
6714
6715   for (gent = h->got.glist; gent != NULL; gent = gent->next)
6716     if (gent->got.refcount > 0)
6717       {
6718         bfd_boolean dyn;
6719
6720         /* Make sure this symbol is output as a dynamic symbol.
6721            Undefined weak syms won't yet be marked as dynamic,
6722            nor will all TLS symbols.  */
6723         if (h->dynindx == -1
6724             && !h->forced_local)
6725           {
6726             if (! bfd_elf_link_record_dynamic_symbol (info, h))
6727               return FALSE;
6728           }
6729
6730         if ((gent->tls_type & TLS_LD) != 0
6731             && !h->def_dynamic)
6732           {
6733             gent->got.offset = ppc64_tlsld_got (gent->owner)->offset;
6734             continue;
6735           }
6736
6737         s = ppc64_elf_tdata (gent->owner)->got;
6738         gent->got.offset = s->size;
6739         s->size
6740           += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
6741         dyn = htab->elf.dynamic_sections_created;
6742         if ((info->shared
6743              || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
6744             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6745                 || h->root.type != bfd_link_hash_undefweak))
6746           ppc64_elf_tdata (gent->owner)->relgot->size
6747             += (gent->tls_type & eh->tls_mask & TLS_GD
6748                 ? 2 * sizeof (Elf64_External_Rela)
6749                 : sizeof (Elf64_External_Rela));
6750       }
6751     else
6752       gent->got.offset = (bfd_vma) -1;
6753
6754   if (eh->dyn_relocs == NULL)
6755     return TRUE;
6756
6757   /* In the shared -Bsymbolic case, discard space allocated for
6758      dynamic pc-relative relocs against symbols which turn out to be
6759      defined in regular objects.  For the normal shared case, discard
6760      space for relocs that have become local due to symbol visibility
6761      changes.  */
6762
6763   if (info->shared)
6764     {
6765       /* Relocs that use pc_count are those that appear on a call insn,
6766          or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
6767          generated via assembly.  We want calls to protected symbols to
6768          resolve directly to the function rather than going via the plt.
6769          If people want function pointer comparisons to work as expected
6770          then they should avoid writing weird assembly.  */
6771       if (SYMBOL_CALLS_LOCAL (info, h))
6772         {
6773           struct ppc_dyn_relocs **pp;
6774
6775           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
6776             {
6777               p->count -= p->pc_count;
6778               p->pc_count = 0;
6779               if (p->count == 0)
6780                 *pp = p->next;
6781               else
6782                 pp = &p->next;
6783             }
6784         }
6785
6786       /* Also discard relocs on undefined weak syms with non-default
6787          visibility.  */
6788       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6789           && h->root.type == bfd_link_hash_undefweak)
6790         eh->dyn_relocs = NULL;
6791     }
6792   else if (ELIMINATE_COPY_RELOCS)
6793     {
6794       /* For the non-shared case, discard space for relocs against
6795          symbols which turn out to need copy relocs or are not
6796          dynamic.  */
6797
6798       if (!h->non_got_ref
6799           && h->def_dynamic
6800           && !h->def_regular)
6801         {
6802           /* Make sure this symbol is output as a dynamic symbol.
6803              Undefined weak syms won't yet be marked as dynamic.  */
6804           if (h->dynindx == -1
6805               && !h->forced_local)
6806             {
6807               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6808                 return FALSE;
6809             }
6810
6811           /* If that succeeded, we know we'll be keeping all the
6812              relocs.  */
6813           if (h->dynindx != -1)
6814             goto keep;
6815         }
6816
6817       eh->dyn_relocs = NULL;
6818
6819     keep: ;
6820     }
6821
6822   /* Finally, allocate space.  */
6823   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6824     {
6825       asection *sreloc = elf_section_data (p->sec)->sreloc;
6826       sreloc->size += p->count * sizeof (Elf64_External_Rela);
6827     }
6828
6829   return TRUE;
6830 }
6831
6832 /* Find any dynamic relocs that apply to read-only sections.  */
6833
6834 static bfd_boolean
6835 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6836 {
6837   struct ppc_link_hash_entry *eh;
6838   struct ppc_dyn_relocs *p;
6839
6840   if (h->root.type == bfd_link_hash_warning)
6841     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6842
6843   eh = (struct ppc_link_hash_entry *) h;
6844   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6845     {
6846       asection *s = p->sec->output_section;
6847
6848       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6849         {
6850           struct bfd_link_info *info = inf;
6851
6852           info->flags |= DF_TEXTREL;
6853
6854           /* Not an error, just cut short the traversal.  */
6855           return FALSE;
6856         }
6857     }
6858   return TRUE;
6859 }
6860
6861 /* Set the sizes of the dynamic sections.  */
6862
6863 static bfd_boolean
6864 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
6865                                  struct bfd_link_info *info)
6866 {
6867   struct ppc_link_hash_table *htab;
6868   bfd *dynobj;
6869   asection *s;
6870   bfd_boolean relocs;
6871   bfd *ibfd;
6872
6873   htab = ppc_hash_table (info);
6874   dynobj = htab->elf.dynobj;
6875   if (dynobj == NULL)
6876     abort ();
6877
6878   if (htab->elf.dynamic_sections_created)
6879     {
6880       /* Set the contents of the .interp section to the interpreter.  */
6881       if (info->executable)
6882         {
6883           s = bfd_get_section_by_name (dynobj, ".interp");
6884           if (s == NULL)
6885             abort ();
6886           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6887           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6888         }
6889     }
6890
6891   /* Set up .got offsets for local syms, and space for local dynamic
6892      relocs.  */
6893   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6894     {
6895       struct got_entry **lgot_ents;
6896       struct got_entry **end_lgot_ents;
6897       char *lgot_masks;
6898       bfd_size_type locsymcount;
6899       Elf_Internal_Shdr *symtab_hdr;
6900       asection *srel;
6901
6902       if (!is_ppc64_elf_target (ibfd->xvec))
6903         continue;
6904
6905       if (ppc64_tlsld_got (ibfd)->refcount > 0)
6906         {
6907           s = ppc64_elf_tdata (ibfd)->got;
6908           ppc64_tlsld_got (ibfd)->offset = s->size;
6909           s->size += 16;
6910           if (info->shared)
6911             {
6912               srel = ppc64_elf_tdata (ibfd)->relgot;
6913               srel->size += sizeof (Elf64_External_Rela);
6914             }
6915         }
6916       else
6917         ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
6918
6919       for (s = ibfd->sections; s != NULL; s = s->next)
6920         {
6921           struct ppc_dyn_relocs *p;
6922
6923           for (p = *((struct ppc_dyn_relocs **)
6924                      &elf_section_data (s)->local_dynrel);
6925                p != NULL;
6926                p = p->next)
6927             {
6928               if (!bfd_is_abs_section (p->sec)
6929                   && bfd_is_abs_section (p->sec->output_section))
6930                 {
6931                   /* Input section has been discarded, either because
6932                      it is a copy of a linkonce section or due to
6933                      linker script /DISCARD/, so we'll be discarding
6934                      the relocs too.  */
6935                 }
6936               else if (p->count != 0)
6937                 {
6938                   srel = elf_section_data (p->sec)->sreloc;
6939                   srel->size += p->count * sizeof (Elf64_External_Rela);
6940                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
6941                     info->flags |= DF_TEXTREL;
6942                 }
6943             }
6944         }
6945
6946       lgot_ents = elf_local_got_ents (ibfd);
6947       if (!lgot_ents)
6948         continue;
6949
6950       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6951       locsymcount = symtab_hdr->sh_info;
6952       end_lgot_ents = lgot_ents + locsymcount;
6953       lgot_masks = (char *) end_lgot_ents;
6954       s = ppc64_elf_tdata (ibfd)->got;
6955       srel = ppc64_elf_tdata (ibfd)->relgot;
6956       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
6957         {
6958           struct got_entry *ent;
6959
6960           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
6961             if (ent->got.refcount > 0)
6962               {
6963                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
6964                   {
6965                     if (ppc64_tlsld_got (ibfd)->offset == (bfd_vma) -1)
6966                       {
6967                         ppc64_tlsld_got (ibfd)->offset = s->size;
6968                         s->size += 16;
6969                         if (info->shared)
6970                           srel->size += sizeof (Elf64_External_Rela);
6971                       }
6972                     ent->got.offset = ppc64_tlsld_got (ibfd)->offset;
6973                   }
6974                 else
6975                   {
6976                     ent->got.offset = s->size;
6977                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
6978                       {
6979                         s->size += 16;
6980                         if (info->shared)
6981                           srel->size += 2 * sizeof (Elf64_External_Rela);
6982                       }
6983                     else
6984                       {
6985                         s->size += 8;
6986                         if (info->shared)
6987                           srel->size += sizeof (Elf64_External_Rela);
6988                       }
6989                   }
6990               }
6991             else
6992               ent->got.offset = (bfd_vma) -1;
6993         }
6994     }
6995
6996   /* Allocate global sym .plt and .got entries, and space for global
6997      sym dynamic relocs.  */
6998   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
6999
7000   /* We now have determined the sizes of the various dynamic sections.
7001      Allocate memory for them.  */
7002   relocs = FALSE;
7003   for (s = dynobj->sections; s != NULL; s = s->next)
7004     {
7005       if ((s->flags & SEC_LINKER_CREATED) == 0)
7006         continue;
7007
7008       if (s == htab->brlt || s == htab->relbrlt)
7009         /* These haven't been allocated yet;  don't strip.  */
7010         continue;
7011       else if (s == htab->got
7012                || s == htab->plt
7013                || s == htab->glink)
7014         {
7015           /* Strip this section if we don't need it; see the
7016              comment below.  */
7017         }
7018       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
7019         {
7020           if (s->size == 0)
7021             {
7022               /* If we don't need this section, strip it from the
7023                  output file.  This is mostly to handle .rela.bss and
7024                  .rela.plt.  We must create both sections in
7025                  create_dynamic_sections, because they must be created
7026                  before the linker maps input sections to output
7027                  sections.  The linker does that before
7028                  adjust_dynamic_symbol is called, and it is that
7029                  function which decides whether anything needs to go
7030                  into these sections.  */
7031             }
7032           else
7033             {
7034               if (s != htab->relplt)
7035                 relocs = TRUE;
7036
7037               /* We use the reloc_count field as a counter if we need
7038                  to copy relocs into the output file.  */
7039               s->reloc_count = 0;
7040             }
7041         }
7042       else
7043         {
7044           /* It's not one of our sections, so don't allocate space.  */
7045           continue;
7046         }
7047
7048       if (s->size == 0)
7049         {
7050           _bfd_strip_section_from_output (info, s);
7051           continue;
7052         }
7053
7054       /* .plt is in the bss section.  We don't initialise it.  */
7055       if (s == htab->plt)
7056         continue;
7057
7058       /* Allocate memory for the section contents.  We use bfd_zalloc
7059          here in case unused entries are not reclaimed before the
7060          section's contents are written out.  This should not happen,
7061          but this way if it does we get a R_PPC64_NONE reloc in .rela
7062          sections instead of garbage.
7063          We also rely on the section contents being zero when writing
7064          the GOT.  */
7065       s->contents = bfd_zalloc (dynobj, s->size);
7066       if (s->contents == NULL)
7067         return FALSE;
7068     }
7069
7070   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7071     {
7072       if (!is_ppc64_elf_target (ibfd->xvec))
7073         continue;
7074
7075       s = ppc64_elf_tdata (ibfd)->got;
7076       if (s != NULL && s != htab->got)
7077         {
7078           if (s->size == 0)
7079             _bfd_strip_section_from_output (info, s);
7080           else
7081             {
7082               s->contents = bfd_zalloc (ibfd, s->size);
7083               if (s->contents == NULL)
7084                 return FALSE;
7085             }
7086         }
7087       s = ppc64_elf_tdata (ibfd)->relgot;
7088       if (s != NULL)
7089         {
7090           if (s->size == 0)
7091             _bfd_strip_section_from_output (info, s);
7092           else
7093             {
7094               s->contents = bfd_zalloc (ibfd, s->size);
7095               if (s->contents == NULL)
7096                 return FALSE;
7097               relocs = TRUE;
7098               s->reloc_count = 0;
7099             }
7100         }
7101     }
7102
7103   if (htab->elf.dynamic_sections_created)
7104     {
7105       /* Add some entries to the .dynamic section.  We fill in the
7106          values later, in ppc64_elf_finish_dynamic_sections, but we
7107          must add the entries now so that we get the correct size for
7108          the .dynamic section.  The DT_DEBUG entry is filled in by the
7109          dynamic linker and used by the debugger.  */
7110 #define add_dynamic_entry(TAG, VAL) \
7111   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
7112
7113       if (info->executable)
7114         {
7115           if (!add_dynamic_entry (DT_DEBUG, 0))
7116             return FALSE;
7117         }
7118
7119       if (htab->plt != NULL && htab->plt->size != 0)
7120         {
7121           if (!add_dynamic_entry (DT_PLTGOT, 0)
7122               || !add_dynamic_entry (DT_PLTRELSZ, 0)
7123               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
7124               || !add_dynamic_entry (DT_JMPREL, 0)
7125               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
7126             return FALSE;
7127         }
7128
7129       if (NO_OPD_RELOCS)
7130         {
7131           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
7132               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
7133             return FALSE;
7134         }
7135
7136       if (relocs)
7137         {
7138           if (!add_dynamic_entry (DT_RELA, 0)
7139               || !add_dynamic_entry (DT_RELASZ, 0)
7140               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
7141             return FALSE;
7142
7143           /* If any dynamic relocs apply to a read-only section,
7144              then we need a DT_TEXTREL entry.  */
7145           if ((info->flags & DF_TEXTREL) == 0)
7146             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
7147
7148           if ((info->flags & DF_TEXTREL) != 0)
7149             {
7150               if (!add_dynamic_entry (DT_TEXTREL, 0))
7151                 return FALSE;
7152             }
7153         }
7154     }
7155 #undef add_dynamic_entry
7156
7157   return TRUE;
7158 }
7159
7160 /* Determine the type of stub needed, if any, for a call.  */
7161
7162 static inline enum ppc_stub_type
7163 ppc_type_of_stub (asection *input_sec,
7164                   const Elf_Internal_Rela *rel,
7165                   struct ppc_link_hash_entry **hash,
7166                   bfd_vma destination)
7167 {
7168   struct ppc_link_hash_entry *h = *hash;
7169   bfd_vma location;
7170   bfd_vma branch_offset;
7171   bfd_vma max_branch_offset;
7172   enum elf_ppc64_reloc_type r_type;
7173
7174   if (h != NULL)
7175     {
7176       if (h->oh != NULL
7177           && h->oh->is_func_descriptor)
7178         h = h->oh;
7179
7180       if (h->elf.dynindx != -1)
7181         {
7182           struct plt_entry *ent;
7183
7184           for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
7185             if (ent->addend == rel->r_addend
7186                 && ent->plt.offset != (bfd_vma) -1)
7187               {
7188                 *hash = h;
7189                 return ppc_stub_plt_call;
7190               }
7191         }
7192
7193       if (!(h->elf.root.type == bfd_link_hash_defined
7194             || h->elf.root.type == bfd_link_hash_defweak)
7195           || h->elf.root.u.def.section->output_section == NULL)
7196         return ppc_stub_none;
7197     }
7198
7199   /* Determine where the call point is.  */
7200   location = (input_sec->output_offset
7201               + input_sec->output_section->vma
7202               + rel->r_offset);
7203
7204   branch_offset = destination - location;
7205   r_type = ELF64_R_TYPE (rel->r_info);
7206
7207   /* Determine if a long branch stub is needed.  */
7208   max_branch_offset = 1 << 25;
7209   if (r_type != R_PPC64_REL24)
7210     max_branch_offset = 1 << 15;
7211
7212   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
7213     /* We need a stub.  Figure out whether a long_branch or plt_branch
7214        is needed later.  */
7215     return ppc_stub_long_branch;
7216
7217   return ppc_stub_none;
7218 }
7219
7220 /* Build a .plt call stub.  */
7221
7222 static inline bfd_byte *
7223 build_plt_stub (bfd *obfd, bfd_byte *p, int offset)
7224 {
7225 #define PPC_LO(v) ((v) & 0xffff)
7226 #define PPC_HI(v) (((v) >> 16) & 0xffff)
7227 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
7228
7229   bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
7230   bfd_put_32 (obfd, STD_R2_40R1, p),                    p += 4;
7231   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
7232   if (PPC_HA (offset + 8) != PPC_HA (offset))
7233     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
7234   offset += 8;
7235   bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p),   p += 4;
7236   if (PPC_HA (offset + 8) != PPC_HA (offset))
7237     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
7238   offset += 8;
7239   bfd_put_32 (obfd, MTCTR_R11, p),                      p += 4;
7240   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
7241   bfd_put_32 (obfd, BCTR, p),                           p += 4;
7242   return p;
7243 }
7244
7245 static bfd_boolean
7246 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
7247 {
7248   struct ppc_stub_hash_entry *stub_entry;
7249   struct ppc_branch_hash_entry *br_entry;
7250   struct bfd_link_info *info;
7251   struct ppc_link_hash_table *htab;
7252   bfd_byte *loc;
7253   bfd_byte *p;
7254   unsigned int indx;
7255   struct plt_entry *ent;
7256   bfd_vma dest, off;
7257   int size;
7258
7259   /* Massage our args to the form they really have.  */
7260   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
7261   info = in_arg;
7262
7263   htab = ppc_hash_table (info);
7264
7265   /* Make a note of the offset within the stubs for this entry.  */
7266   stub_entry->stub_offset = stub_entry->stub_sec->size;
7267   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
7268
7269   htab->stub_count[stub_entry->stub_type - 1] += 1;
7270   switch (stub_entry->stub_type)
7271     {
7272     case ppc_stub_long_branch:
7273     case ppc_stub_long_branch_r2off:
7274       /* Branches are relative.  This is where we are going to.  */
7275       off = dest = (stub_entry->target_value
7276                     + stub_entry->target_section->output_offset
7277                     + stub_entry->target_section->output_section->vma);
7278
7279       /* And this is where we are coming from.  */
7280       off -= (stub_entry->stub_offset
7281               + stub_entry->stub_sec->output_offset
7282               + stub_entry->stub_sec->output_section->vma);
7283
7284       if (stub_entry->stub_type != ppc_stub_long_branch_r2off)
7285         size = 4;
7286       else
7287         {
7288           bfd_vma r2off;
7289
7290           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
7291                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
7292           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
7293           loc += 4;
7294           bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
7295           loc += 4;
7296           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
7297           loc += 4;
7298           off -= 12;
7299           size = 16;
7300         }
7301       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
7302
7303       BFD_ASSERT (off + (1 << 25) < (bfd_vma) (1 << 26));
7304
7305       if (info->emitrelocations)
7306         {
7307           Elf_Internal_Rela *relocs, *r;
7308           struct bfd_elf_section_data *elfsec_data;
7309
7310           elfsec_data = elf_section_data (stub_entry->stub_sec);
7311           relocs = elfsec_data->relocs;
7312           if (relocs == NULL)
7313             {
7314               bfd_size_type relsize;
7315               relsize = stub_entry->stub_sec->reloc_count * sizeof (*relocs);
7316               relocs = bfd_alloc (htab->stub_bfd, relsize);
7317               if (relocs == NULL)
7318                 return FALSE;
7319               elfsec_data->relocs = relocs;
7320               elfsec_data->rel_hdr.sh_size = relsize;
7321               elfsec_data->rel_hdr.sh_entsize = 24;
7322               stub_entry->stub_sec->reloc_count = 0;
7323             }
7324           r = relocs + stub_entry->stub_sec->reloc_count;
7325           stub_entry->stub_sec->reloc_count += 1;
7326           r->r_offset = loc - stub_entry->stub_sec->contents;
7327           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
7328           r->r_addend = dest;
7329           if (stub_entry->h != NULL)
7330             {
7331               struct elf_link_hash_entry **hashes;
7332               unsigned long symndx;
7333               struct ppc_link_hash_entry *h;
7334
7335               hashes = elf_sym_hashes (htab->stub_bfd);
7336               if (hashes == NULL)
7337                 {
7338                   bfd_size_type hsize;
7339
7340                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
7341                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
7342                   if (hashes == NULL)
7343                     return FALSE;
7344                   elf_sym_hashes (htab->stub_bfd) = hashes;
7345                   htab->stub_globals = 1;
7346                 }
7347               symndx = htab->stub_globals++;
7348               h = stub_entry->h;
7349               hashes[symndx] = &h->elf;
7350               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
7351               if (h->oh != NULL && h->oh->is_func)
7352                 h = h->oh;
7353               if (h->elf.root.u.def.section != stub_entry->target_section)
7354                 /* H is an opd symbol.  The addend must be zero.  */
7355                 r->r_addend = 0;
7356               else
7357                 {
7358                   off = (h->elf.root.u.def.value
7359                          + h->elf.root.u.def.section->output_offset
7360                          + h->elf.root.u.def.section->output_section->vma);
7361                   r->r_addend -= off;
7362                 }
7363             }
7364         }
7365       break;
7366
7367     case ppc_stub_plt_branch:
7368     case ppc_stub_plt_branch_r2off:
7369       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
7370                                          stub_entry->root.string + 9,
7371                                          FALSE, FALSE);
7372       if (br_entry == NULL)
7373         {
7374           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
7375                                  stub_entry->root.string + 9);
7376           htab->stub_error = TRUE;
7377           return FALSE;
7378         }
7379
7380       off = (stub_entry->target_value
7381              + stub_entry->target_section->output_offset
7382              + stub_entry->target_section->output_section->vma);
7383
7384       bfd_put_64 (htab->brlt->owner, off,
7385                   htab->brlt->contents + br_entry->offset);
7386
7387       if (htab->relbrlt != NULL)
7388         {
7389           /* Create a reloc for the branch lookup table entry.  */
7390           Elf_Internal_Rela rela;
7391           bfd_byte *rl;
7392
7393           rela.r_offset = (br_entry->offset
7394                            + htab->brlt->output_offset
7395                            + htab->brlt->output_section->vma);
7396           rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
7397           rela.r_addend = off;
7398
7399           rl = htab->relbrlt->contents;
7400           rl += htab->relbrlt->reloc_count++ * sizeof (Elf64_External_Rela);
7401           bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
7402         }
7403
7404       off = (br_entry->offset
7405              + htab->brlt->output_offset
7406              + htab->brlt->output_section->vma
7407              - elf_gp (htab->brlt->output_section->owner)
7408              - htab->stub_group[stub_entry->id_sec->id].toc_off);
7409
7410       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
7411         {
7412           (*_bfd_error_handler)
7413             (_("linkage table error against `%s'"),
7414              stub_entry->root.string);
7415           bfd_set_error (bfd_error_bad_value);
7416           htab->stub_error = TRUE;
7417           return FALSE;
7418         }
7419
7420       indx = off;
7421       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
7422         {
7423           bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
7424           loc += 4;
7425           bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
7426           size = 16;
7427         }
7428       else
7429         {
7430           bfd_vma r2off;
7431
7432           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
7433                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
7434           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
7435           loc += 4;
7436           bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
7437           loc += 4;
7438           bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
7439           loc += 4;
7440           bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
7441           loc += 4;
7442           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
7443           size = 28;
7444         }
7445       loc += 4;
7446       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
7447       loc += 4;
7448       bfd_put_32 (htab->stub_bfd, BCTR, loc);
7449       break;
7450
7451     case ppc_stub_plt_call:
7452       /* Do the best we can for shared libraries built without
7453          exporting ".foo" for each "foo".  This can happen when symbol
7454          versioning scripts strip all bar a subset of symbols.  */
7455       if (stub_entry->h->oh != NULL
7456           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
7457           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
7458         {
7459           /* Point the symbol at the stub.  There may be multiple stubs,
7460              we don't really care;  The main thing is to make this sym
7461              defined somewhere.  Maybe defining the symbol in the stub
7462              section is a silly idea.  If we didn't do this, htab->top_id
7463              could disappear.  */
7464           stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
7465           stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
7466           stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
7467         }
7468
7469       /* Now build the stub.  */
7470       off = (bfd_vma) -1;
7471       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
7472         if (ent->addend == stub_entry->addend)
7473           {
7474             off = ent->plt.offset;
7475             break;
7476           }
7477       if (off >= (bfd_vma) -2)
7478         abort ();
7479
7480       off &= ~ (bfd_vma) 1;
7481       off += (htab->plt->output_offset
7482               + htab->plt->output_section->vma
7483               - elf_gp (htab->plt->output_section->owner)
7484               - htab->stub_group[stub_entry->id_sec->id].toc_off);
7485
7486       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
7487         {
7488           (*_bfd_error_handler)
7489             (_("linkage table error against `%s'"),
7490              stub_entry->h->elf.root.root.string);
7491           bfd_set_error (bfd_error_bad_value);
7492           htab->stub_error = TRUE;
7493           return FALSE;
7494         }
7495
7496       p = build_plt_stub (htab->stub_bfd, loc, off);
7497       size = p - loc;
7498       break;
7499
7500     default:
7501       BFD_FAIL ();
7502       return FALSE;
7503     }
7504
7505   stub_entry->stub_sec->size += size;
7506
7507   if (htab->emit_stub_syms)
7508     {
7509       struct elf_link_hash_entry *h;
7510       size_t len1, len2;
7511       char *name;
7512       const char *const stub_str[] = { "long_branch",
7513                                        "long_branch_r2off",
7514                                        "plt_branch",
7515                                        "plt_branch_r2off",
7516                                        "plt_call" };
7517
7518       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
7519       len2 = strlen (stub_entry->root.string);
7520       name = bfd_malloc (len1 + len2 + 2);
7521       if (name == NULL)
7522         return FALSE;
7523       memcpy (name, stub_entry->root.string, 9);
7524       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
7525       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
7526       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
7527       if (h == NULL)
7528         return FALSE;
7529       if (h->root.type == bfd_link_hash_new)
7530         {
7531           h->root.type = bfd_link_hash_defined;
7532           h->root.u.def.section = stub_entry->stub_sec;
7533           h->root.u.def.value = stub_entry->stub_offset;
7534           h->ref_regular = 1;
7535           h->def_regular = 1;
7536           h->ref_regular_nonweak = 1;
7537           h->forced_local = 1;
7538           h->non_elf = 0;
7539         }
7540     }
7541
7542   return TRUE;
7543 }
7544
7545 /* As above, but don't actually build the stub.  Just bump offset so
7546    we know stub section sizes, and select plt_branch stubs where
7547    long_branch stubs won't do.  */
7548
7549 static bfd_boolean
7550 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
7551 {
7552   struct ppc_stub_hash_entry *stub_entry;
7553   struct bfd_link_info *info;
7554   struct ppc_link_hash_table *htab;
7555   bfd_vma off;
7556   int size;
7557
7558   /* Massage our args to the form they really have.  */
7559   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
7560   info = in_arg;
7561
7562   htab = ppc_hash_table (info);
7563
7564   if (stub_entry->stub_type == ppc_stub_plt_call)
7565     {
7566       struct plt_entry *ent;
7567       off = (bfd_vma) -1;
7568       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
7569         if (ent->addend == stub_entry->addend)
7570           {
7571             off = ent->plt.offset & ~(bfd_vma) 1;
7572             break;
7573           }
7574       if (off >= (bfd_vma) -2)
7575         abort ();
7576       off += (htab->plt->output_offset
7577               + htab->plt->output_section->vma
7578               - elf_gp (htab->plt->output_section->owner)
7579               - htab->stub_group[stub_entry->id_sec->id].toc_off);
7580
7581       size = PLT_CALL_STUB_SIZE;
7582       if (PPC_HA (off + 16) != PPC_HA (off))
7583         size += 4;
7584     }
7585   else
7586     {
7587       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
7588          variants.  */
7589       off = (stub_entry->target_value
7590              + stub_entry->target_section->output_offset
7591              + stub_entry->target_section->output_section->vma);
7592       off -= (stub_entry->stub_sec->size
7593               + stub_entry->stub_sec->output_offset
7594               + stub_entry->stub_sec->output_section->vma);
7595
7596       /* Reset the stub type from the plt variant in case we now
7597          can reach with a shorter stub.  */
7598       if (stub_entry->stub_type >= ppc_stub_plt_branch)
7599         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
7600
7601       size = 4;
7602       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
7603         {
7604           off -= 12;
7605           size = 16;
7606         }
7607
7608       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
7609       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
7610         {
7611           struct ppc_branch_hash_entry *br_entry;
7612
7613           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
7614                                              stub_entry->root.string + 9,
7615                                              TRUE, FALSE);
7616           if (br_entry == NULL)
7617             {
7618               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
7619                                      stub_entry->root.string + 9);
7620               htab->stub_error = TRUE;
7621               return FALSE;
7622             }
7623
7624           if (br_entry->iter != htab->stub_iteration)
7625             {
7626               br_entry->iter = htab->stub_iteration;
7627               br_entry->offset = htab->brlt->size;
7628               htab->brlt->size += 8;
7629
7630               if (htab->relbrlt != NULL)
7631                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
7632             }
7633
7634           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
7635           size = 16;
7636           if (stub_entry->stub_type != ppc_stub_plt_branch)
7637             size = 28;
7638         }
7639
7640       if (info->emitrelocations
7641           && (stub_entry->stub_type == ppc_stub_long_branch
7642               || stub_entry->stub_type == ppc_stub_long_branch_r2off))
7643         stub_entry->stub_sec->reloc_count += 1;
7644     }
7645
7646   stub_entry->stub_sec->size += size;
7647   return TRUE;
7648 }
7649
7650 /* Set up various things so that we can make a list of input sections
7651    for each output section included in the link.  Returns -1 on error,
7652    0 when no stubs will be needed, and 1 on success.  */
7653
7654 int
7655 ppc64_elf_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
7656 {
7657   bfd *input_bfd;
7658   int top_id, top_index, id;
7659   asection *section;
7660   asection **input_list;
7661   bfd_size_type amt;
7662   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7663
7664   if (htab->brlt == NULL)
7665     return 0;
7666
7667   /* Find the top input section id.  */
7668   for (input_bfd = info->input_bfds, top_id = 3;
7669        input_bfd != NULL;
7670        input_bfd = input_bfd->link_next)
7671     {
7672       for (section = input_bfd->sections;
7673            section != NULL;
7674            section = section->next)
7675         {
7676           if (top_id < section->id)
7677             top_id = section->id;
7678         }
7679     }
7680
7681   htab->top_id = top_id;
7682   amt = sizeof (struct map_stub) * (top_id + 1);
7683   htab->stub_group = bfd_zmalloc (amt);
7684   if (htab->stub_group == NULL)
7685     return -1;
7686
7687   /* Set toc_off for com, und, abs and ind sections.  */
7688   for (id = 0; id < 3; id++)
7689     htab->stub_group[id].toc_off = TOC_BASE_OFF;
7690
7691   elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
7692
7693   /* We can't use output_bfd->section_count here to find the top output
7694      section index as some sections may have been removed, and
7695      _bfd_strip_section_from_output doesn't renumber the indices.  */
7696   for (section = output_bfd->sections, top_index = 0;
7697        section != NULL;
7698        section = section->next)
7699     {
7700       if (top_index < section->index)
7701         top_index = section->index;
7702     }
7703
7704   htab->top_index = top_index;
7705   amt = sizeof (asection *) * (top_index + 1);
7706   input_list = bfd_zmalloc (amt);
7707   htab->input_list = input_list;
7708   if (input_list == NULL)
7709     return -1;
7710
7711   return 1;
7712 }
7713
7714 /* The linker repeatedly calls this function for each TOC input section
7715    and linker generated GOT section.  Group input bfds such that the toc
7716    within a group is less than 64k in size.  Will break with cute linker
7717    scripts that play games with dot in the output toc section.  */
7718
7719 void
7720 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
7721 {
7722   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7723   bfd_vma addr = isec->output_offset + isec->output_section->vma;
7724   bfd_vma off = addr - htab->toc_curr;
7725
7726   if (off + isec->size > 0x10000)
7727     htab->toc_curr = addr;
7728
7729   elf_gp (isec->owner) = (htab->toc_curr
7730                           - elf_gp (isec->output_section->owner)
7731                           + TOC_BASE_OFF);
7732 }
7733
7734 /* Called after the last call to the above function.  */
7735
7736 void
7737 ppc64_elf_reinit_toc (bfd *output_bfd ATTRIBUTE_UNUSED,
7738                       struct bfd_link_info *info)
7739 {
7740   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7741
7742   /* toc_curr tracks the TOC offset used for code sections below in
7743      ppc64_elf_next_input_section.  Start off at 0x8000.  */
7744   htab->toc_curr = TOC_BASE_OFF;
7745 }
7746
7747 /* No toc references were found in ISEC.  If the code in ISEC makes no
7748    calls, then there's no need to use toc adjusting stubs when branching
7749    into ISEC.  Actually, indirect calls from ISEC are OK as they will
7750    load r2.  */
7751
7752 static int
7753 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
7754 {
7755   bfd_byte *contents;
7756   bfd_size_type i;
7757   int ret;
7758   int branch_ok;
7759
7760   /* We know none of our code bearing sections will need toc stubs.  */
7761   if ((isec->flags & SEC_LINKER_CREATED) != 0)
7762     return 0;
7763
7764   if (isec->size == 0)
7765     return 0;
7766
7767   /* Hack for linux kernel.  .fixup contains branches, but only back to
7768      the function that hit an exception.  */
7769   branch_ok = strcmp (isec->name, ".fixup") == 0;
7770
7771   contents = elf_section_data (isec)->this_hdr.contents;
7772   if (contents == NULL)
7773     {
7774       if (!bfd_malloc_and_get_section (isec->owner, isec, &contents))
7775         {
7776           if (contents != NULL)
7777             free (contents);
7778           return -1;
7779         }
7780       if (info->keep_memory)
7781         elf_section_data (isec)->this_hdr.contents = contents;
7782     }
7783
7784   /* Code scan, because we don't necessarily have relocs on calls to
7785      static functions.  */
7786   ret = 0;
7787   for (i = 0; i < isec->size; i += 4)
7788     {
7789       unsigned long insn = bfd_get_32 (isec->owner, contents + i);
7790       /* Is this a branch?  */
7791       if ((insn & (0x3f << 26)) == (18 << 26)
7792           /* If branch and link, it's a function call.  */
7793           && ((insn & 1) != 0
7794               /* Sibling calls use a plain branch.  I don't know a way
7795                  of deciding whether a branch is really a sibling call.  */
7796               || !branch_ok))
7797         {
7798           ret = 1;
7799           break;
7800         }
7801     }
7802
7803   if (elf_section_data (isec)->this_hdr.contents != contents)
7804     free (contents);
7805   return ret;
7806 }
7807
7808 /* The linker repeatedly calls this function for each input section,
7809    in the order that input sections are linked into output sections.
7810    Build lists of input sections to determine groupings between which
7811    we may insert linker stubs.  */
7812
7813 bfd_boolean
7814 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
7815 {
7816   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7817   int ret;
7818
7819   if ((isec->output_section->flags & SEC_CODE) != 0
7820       && isec->output_section->index <= htab->top_index)
7821     {
7822       asection **list = htab->input_list + isec->output_section->index;
7823       /* Steal the link_sec pointer for our list.  */
7824 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
7825       /* This happens to make the list in reverse order,
7826          which is what we want.  */
7827       PREV_SEC (isec) = *list;
7828       *list = isec;
7829     }
7830
7831   /* If a code section has a function that uses the TOC then we need
7832      to use the right TOC (obviously).  Also, make sure that .opd gets
7833      the correct TOC value for R_PPC64_TOC relocs that don't have or
7834      can't find their function symbol (shouldn't ever happen now).  */
7835   if (isec->has_gp_reloc || (isec->flags & SEC_CODE) == 0)
7836     {
7837       if (elf_gp (isec->owner) != 0)
7838         htab->toc_curr = elf_gp (isec->owner);
7839     }
7840   else if ((ret = toc_adjusting_stub_needed (info, isec)) < 0)
7841     return FALSE;
7842   else
7843     isec->has_gp_reloc = ret;
7844
7845   /* Functions that don't use the TOC can belong in any TOC group.
7846      Use the last TOC base.  This happens to make _init and _fini
7847      pasting work.  */
7848   htab->stub_group[isec->id].toc_off = htab->toc_curr;
7849   return TRUE;
7850 }
7851
7852 /* See whether we can group stub sections together.  Grouping stub
7853    sections may result in fewer stubs.  More importantly, we need to
7854    put all .init* and .fini* stubs at the beginning of the .init or
7855    .fini output sections respectively, because glibc splits the
7856    _init and _fini functions into multiple parts.  Putting a stub in
7857    the middle of a function is not a good idea.  */
7858
7859 static void
7860 group_sections (struct ppc_link_hash_table *htab,
7861                 bfd_size_type stub_group_size,
7862                 bfd_boolean stubs_always_before_branch)
7863 {
7864   asection **list = htab->input_list + htab->top_index;
7865   do
7866     {
7867       asection *tail = *list;
7868       while (tail != NULL)
7869         {
7870           asection *curr;
7871           asection *prev;
7872           bfd_size_type total;
7873           bfd_boolean big_sec;
7874           bfd_vma curr_toc;
7875
7876           curr = tail;
7877           total = tail->size;
7878           big_sec = total >= stub_group_size;
7879           curr_toc = htab->stub_group[tail->id].toc_off;
7880
7881           while ((prev = PREV_SEC (curr)) != NULL
7882                  && ((total += curr->output_offset - prev->output_offset)
7883                      < stub_group_size)
7884                  && htab->stub_group[prev->id].toc_off == curr_toc)
7885             curr = prev;
7886
7887           /* OK, the size from the start of CURR to the end is less
7888              than stub_group_size and thus can be handled by one stub
7889              section.  (or the tail section is itself larger than
7890              stub_group_size, in which case we may be toast.)  We
7891              should really be keeping track of the total size of stubs
7892              added here, as stubs contribute to the final output
7893              section size.  That's a little tricky, and this way will
7894              only break if stubs added make the total size more than
7895              2^25, ie. for the default stub_group_size, if stubs total
7896              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
7897           do
7898             {
7899               prev = PREV_SEC (tail);
7900               /* Set up this stub group.  */
7901               htab->stub_group[tail->id].link_sec = curr;
7902             }
7903           while (tail != curr && (tail = prev) != NULL);
7904
7905           /* But wait, there's more!  Input sections up to stub_group_size
7906              bytes before the stub section can be handled by it too.
7907              Don't do this if we have a really large section after the
7908              stubs, as adding more stubs increases the chance that
7909              branches may not reach into the stub section.  */
7910           if (!stubs_always_before_branch && !big_sec)
7911             {
7912               total = 0;
7913               while (prev != NULL
7914                      && ((total += tail->output_offset - prev->output_offset)
7915                          < stub_group_size)
7916                      && htab->stub_group[prev->id].toc_off == curr_toc)
7917                 {
7918                   tail = prev;
7919                   prev = PREV_SEC (tail);
7920                   htab->stub_group[tail->id].link_sec = curr;
7921                 }
7922             }
7923           tail = prev;
7924         }
7925     }
7926   while (list-- != htab->input_list);
7927   free (htab->input_list);
7928 #undef PREV_SEC
7929 }
7930
7931 /* Determine and set the size of the stub section for a final link.
7932
7933    The basic idea here is to examine all the relocations looking for
7934    PC-relative calls to a target that is unreachable with a "bl"
7935    instruction.  */
7936
7937 bfd_boolean
7938 ppc64_elf_size_stubs (bfd *output_bfd,
7939                       struct bfd_link_info *info,
7940                       bfd_signed_vma group_size,
7941                       asection *(*add_stub_section) (const char *, asection *),
7942                       void (*layout_sections_again) (void))
7943 {
7944   bfd_size_type stub_group_size;
7945   bfd_boolean stubs_always_before_branch;
7946   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7947
7948   /* Stash our params away.  */
7949   htab->add_stub_section = add_stub_section;
7950   htab->layout_sections_again = layout_sections_again;
7951   stubs_always_before_branch = group_size < 0;
7952   if (group_size < 0)
7953     stub_group_size = -group_size;
7954   else
7955     stub_group_size = group_size;
7956   if (stub_group_size == 1)
7957     {
7958       /* Default values.  */
7959       if (stubs_always_before_branch)
7960         {
7961           stub_group_size = 0x1e00000;
7962           if (htab->has_14bit_branch)
7963             stub_group_size = 0x7800;
7964         }
7965       else
7966         {
7967           stub_group_size = 0x1c00000;
7968           if (htab->has_14bit_branch)
7969             stub_group_size = 0x7000;
7970         }
7971     }
7972
7973   group_sections (htab, stub_group_size, stubs_always_before_branch);
7974
7975   while (1)
7976     {
7977       bfd *input_bfd;
7978       unsigned int bfd_indx;
7979       asection *stub_sec;
7980       bfd_boolean stub_changed;
7981
7982       htab->stub_iteration += 1;
7983       stub_changed = FALSE;
7984
7985       for (input_bfd = info->input_bfds, bfd_indx = 0;
7986            input_bfd != NULL;
7987            input_bfd = input_bfd->link_next, bfd_indx++)
7988         {
7989           Elf_Internal_Shdr *symtab_hdr;
7990           asection *section;
7991           Elf_Internal_Sym *local_syms = NULL;
7992
7993           /* We'll need the symbol table in a second.  */
7994           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
7995           if (symtab_hdr->sh_info == 0)
7996             continue;
7997
7998           /* Walk over each section attached to the input bfd.  */
7999           for (section = input_bfd->sections;
8000                section != NULL;
8001                section = section->next)
8002             {
8003               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
8004
8005               /* If there aren't any relocs, then there's nothing more
8006                  to do.  */
8007               if ((section->flags & SEC_RELOC) == 0
8008                   || section->reloc_count == 0)
8009                 continue;
8010
8011               /* If this section is a link-once section that will be
8012                  discarded, then don't create any stubs.  */
8013               if (section->output_section == NULL
8014                   || section->output_section->owner != output_bfd)
8015                 continue;
8016
8017               /* Get the relocs.  */
8018               internal_relocs
8019                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
8020                                              info->keep_memory);
8021               if (internal_relocs == NULL)
8022                 goto error_ret_free_local;
8023
8024               /* Now examine each relocation.  */
8025               irela = internal_relocs;
8026               irelaend = irela + section->reloc_count;
8027               for (; irela < irelaend; irela++)
8028                 {
8029                   enum elf_ppc64_reloc_type r_type;
8030                   unsigned int r_indx;
8031                   enum ppc_stub_type stub_type;
8032                   struct ppc_stub_hash_entry *stub_entry;
8033                   asection *sym_sec, *code_sec;
8034                   bfd_vma sym_value;
8035                   bfd_vma destination;
8036                   bfd_boolean ok_dest;
8037                   struct ppc_link_hash_entry *hash;
8038                   struct ppc_link_hash_entry *fdh;
8039                   struct elf_link_hash_entry *h;
8040                   Elf_Internal_Sym *sym;
8041                   char *stub_name;
8042                   const asection *id_sec;
8043                   long *opd_adjust;
8044
8045                   r_type = ELF64_R_TYPE (irela->r_info);
8046                   r_indx = ELF64_R_SYM (irela->r_info);
8047
8048                   if (r_type >= R_PPC64_max)
8049                     {
8050                       bfd_set_error (bfd_error_bad_value);
8051                       goto error_ret_free_internal;
8052                     }
8053
8054                   /* Only look for stubs on branch instructions.  */
8055                   if (r_type != R_PPC64_REL24
8056                       && r_type != R_PPC64_REL14
8057                       && r_type != R_PPC64_REL14_BRTAKEN
8058                       && r_type != R_PPC64_REL14_BRNTAKEN)
8059                     continue;
8060
8061                   /* Now determine the call target, its name, value,
8062                      section.  */
8063                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8064                                   r_indx, input_bfd))
8065                     goto error_ret_free_internal;
8066                   hash = (struct ppc_link_hash_entry *) h;
8067
8068                   ok_dest = FALSE;
8069                   fdh = NULL;
8070                   if (hash == NULL)
8071                     {
8072                       sym_value = sym->st_value;
8073                       ok_dest = TRUE;
8074                     }
8075                   else
8076                     {
8077                       sym_value = 0;
8078                       /* Recognise an old ABI func code entry sym, and
8079                          use the func descriptor sym instead.  */
8080                       if (hash->elf.root.type == bfd_link_hash_undefweak
8081                           && hash->elf.root.root.string[0] == '.'
8082                           && (fdh = get_fdh (hash, htab)) != NULL)
8083                         {
8084                           if (fdh->elf.root.type == bfd_link_hash_defined
8085                               || fdh->elf.root.type == bfd_link_hash_defweak)
8086                             {
8087                               sym_sec = fdh->elf.root.u.def.section;
8088                               sym_value = fdh->elf.root.u.def.value;
8089                               if (sym_sec->output_section != NULL)
8090                                 ok_dest = TRUE;
8091                             }
8092                           else
8093                             fdh = NULL;
8094                         }
8095                       else if (hash->elf.root.type == bfd_link_hash_defined
8096                                || hash->elf.root.type == bfd_link_hash_defweak)
8097                         {
8098                           sym_value = hash->elf.root.u.def.value;
8099                           if (sym_sec->output_section != NULL)
8100                             ok_dest = TRUE;
8101                         }
8102                       else if (hash->elf.root.type == bfd_link_hash_undefweak)
8103                         ;
8104                       else if (hash->elf.root.type == bfd_link_hash_undefined)
8105                         ;
8106                       else
8107                         {
8108                           bfd_set_error (bfd_error_bad_value);
8109                           goto error_ret_free_internal;
8110                         }
8111                     }
8112
8113                   destination = 0;
8114                   if (ok_dest)
8115                     {
8116                       sym_value += irela->r_addend;
8117                       destination = (sym_value
8118                                      + sym_sec->output_offset
8119                                      + sym_sec->output_section->vma);
8120                     }
8121
8122                   code_sec = sym_sec;
8123                   opd_adjust = get_opd_info (sym_sec);
8124                   if (opd_adjust != NULL)
8125                     {
8126                       bfd_vma dest;
8127
8128                       if (hash == NULL)
8129                         {
8130                           long adjust = opd_adjust[sym_value / 8];
8131                           if (adjust == -1)
8132                             continue;
8133                           sym_value += adjust;
8134                         }
8135                       dest = opd_entry_value (sym_sec, sym_value,
8136                                               &code_sec, &sym_value);
8137                       if (dest != (bfd_vma) -1)
8138                         {
8139                           destination = dest;
8140                           if (fdh != NULL)
8141                             {
8142                               /* Fixup old ABI sym to point at code
8143                                  entry.  */
8144                               hash->elf.root.type = bfd_link_hash_defweak;
8145                               hash->elf.root.u.def.section = code_sec;
8146                               hash->elf.root.u.def.value = sym_value;
8147                             }
8148                         }
8149                     }
8150
8151                   /* Determine what (if any) linker stub is needed.  */
8152                   stub_type = ppc_type_of_stub (section, irela, &hash,
8153                                                 destination);
8154
8155                   if (stub_type != ppc_stub_plt_call)
8156                     {
8157                       /* Check whether we need a TOC adjusting stub.
8158                          Since the linker pastes together pieces from
8159                          different object files when creating the
8160                          _init and _fini functions, it may be that a
8161                          call to what looks like a local sym is in
8162                          fact a call needing a TOC adjustment.  */
8163                       if (code_sec != NULL
8164                           && code_sec->output_section != NULL
8165                           && (htab->stub_group[code_sec->id].toc_off
8166                               != htab->stub_group[section->id].toc_off)
8167                           && code_sec->has_gp_reloc
8168                           && section->has_gp_reloc)
8169                         stub_type = ppc_stub_long_branch_r2off;
8170                     }
8171
8172                   if (stub_type == ppc_stub_none)
8173                     continue;
8174
8175                   /* __tls_get_addr calls might be eliminated.  */
8176                   if (stub_type != ppc_stub_plt_call
8177                       && hash != NULL
8178                       && (hash == htab->tls_get_addr
8179                           || hash == htab->tls_get_addr_fd)
8180                       && section->has_tls_reloc
8181                       && irela != internal_relocs)
8182                     {
8183                       /* Get tls info.  */
8184                       char *tls_mask;
8185
8186                       if (!get_tls_mask (&tls_mask, NULL, &local_syms,
8187                                          irela - 1, input_bfd))
8188                         goto error_ret_free_internal;
8189                       if (*tls_mask != 0)
8190                         continue;
8191                     }
8192
8193                   /* Support for grouping stub sections.  */
8194                   id_sec = htab->stub_group[section->id].link_sec;
8195
8196                   /* Get the name of this stub.  */
8197                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
8198                   if (!stub_name)
8199                     goto error_ret_free_internal;
8200
8201                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
8202                                                      stub_name, FALSE, FALSE);
8203                   if (stub_entry != NULL)
8204                     {
8205                       /* The proper stub has already been created.  */
8206                       free (stub_name);
8207                       continue;
8208                     }
8209
8210                   stub_entry = ppc_add_stub (stub_name, section, htab);
8211                   if (stub_entry == NULL)
8212                     {
8213                       free (stub_name);
8214                     error_ret_free_internal:
8215                       if (elf_section_data (section)->relocs == NULL)
8216                         free (internal_relocs);
8217                     error_ret_free_local:
8218                       if (local_syms != NULL
8219                           && (symtab_hdr->contents
8220                               != (unsigned char *) local_syms))
8221                         free (local_syms);
8222                       return FALSE;
8223                     }
8224
8225                   stub_entry->stub_type = stub_type;
8226                   stub_entry->target_value = sym_value;
8227                   stub_entry->target_section = code_sec;
8228                   stub_entry->h = hash;
8229                   stub_entry->addend = irela->r_addend;
8230
8231                   if (stub_entry->h != NULL)
8232                     htab->stub_globals += 1;
8233
8234                   stub_changed = TRUE;
8235                 }
8236
8237               /* We're done with the internal relocs, free them.  */
8238               if (elf_section_data (section)->relocs != internal_relocs)
8239                 free (internal_relocs);
8240             }
8241
8242           if (local_syms != NULL
8243               && symtab_hdr->contents != (unsigned char *) local_syms)
8244             {
8245               if (!info->keep_memory)
8246                 free (local_syms);
8247               else
8248                 symtab_hdr->contents = (unsigned char *) local_syms;
8249             }
8250         }
8251
8252       if (!stub_changed)
8253         break;
8254
8255       /* OK, we've added some stubs.  Find out the new size of the
8256          stub sections.  */
8257       for (stub_sec = htab->stub_bfd->sections;
8258            stub_sec != NULL;
8259            stub_sec = stub_sec->next)
8260         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
8261           {
8262             stub_sec->size = 0;
8263             stub_sec->reloc_count = 0;
8264           }
8265
8266       htab->brlt->size = 0;
8267       if (htab->relbrlt != NULL)
8268         htab->relbrlt->size = 0;
8269
8270       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
8271
8272       /* Ask the linker to do its stuff.  */
8273       (*htab->layout_sections_again) ();
8274     }
8275
8276   /* It would be nice to strip .branch_lt from the output if the
8277      section is empty, but it's too late.  If we strip sections here,
8278      the dynamic symbol table is corrupted since the section symbol
8279      for the stripped section isn't written.  */
8280
8281   return TRUE;
8282 }
8283
8284 /* Called after we have determined section placement.  If sections
8285    move, we'll be called again.  Provide a value for TOCstart.  */
8286
8287 bfd_vma
8288 ppc64_elf_toc (bfd *obfd)
8289 {
8290   asection *s;
8291   bfd_vma TOCstart;
8292
8293   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
8294      order.  The TOC starts where the first of these sections starts.  */
8295   s = bfd_get_section_by_name (obfd, ".got");
8296   if (s == NULL)
8297     s = bfd_get_section_by_name (obfd, ".toc");
8298   if (s == NULL)
8299     s = bfd_get_section_by_name (obfd, ".tocbss");
8300   if (s == NULL)
8301     s = bfd_get_section_by_name (obfd, ".plt");
8302   if (s == NULL)
8303     {
8304       /* This may happen for
8305          o  references to TOC base (SYM@toc / TOC[tc0]) without a
8306          .toc directive
8307          o  bad linker script
8308          o --gc-sections and empty TOC sections
8309
8310          FIXME: Warn user?  */
8311
8312       /* Look for a likely section.  We probably won't even be
8313          using TOCstart.  */
8314       for (s = obfd->sections; s != NULL; s = s->next)
8315         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
8316             == (SEC_ALLOC | SEC_SMALL_DATA))
8317           break;
8318       if (s == NULL)
8319         for (s = obfd->sections; s != NULL; s = s->next)
8320           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
8321               == (SEC_ALLOC | SEC_SMALL_DATA))
8322             break;
8323       if (s == NULL)
8324         for (s = obfd->sections; s != NULL; s = s->next)
8325           if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
8326             break;
8327       if (s == NULL)
8328         for (s = obfd->sections; s != NULL; s = s->next)
8329           if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
8330             break;
8331     }
8332
8333   TOCstart = 0;
8334   if (s != NULL)
8335     TOCstart = s->output_section->vma + s->output_offset;
8336
8337   return TOCstart;
8338 }
8339
8340 /* Build all the stubs associated with the current output file.
8341    The stubs are kept in a hash table attached to the main linker
8342    hash table.  This function is called via gldelf64ppc_finish.  */
8343
8344 bfd_boolean
8345 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
8346                        struct bfd_link_info *info,
8347                        char **stats)
8348 {
8349   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8350   asection *stub_sec;
8351   bfd_byte *p;
8352   int stub_sec_count = 0;
8353
8354   htab->emit_stub_syms = emit_stub_syms;
8355
8356   /* Allocate memory to hold the linker stubs.  */
8357   for (stub_sec = htab->stub_bfd->sections;
8358        stub_sec != NULL;
8359        stub_sec = stub_sec->next)
8360     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
8361         && stub_sec->size != 0)
8362       {
8363         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
8364         if (stub_sec->contents == NULL)
8365           return FALSE;
8366         /* We want to check that built size is the same as calculated
8367            size.  rawsize is a convenient location to use.  */
8368         stub_sec->rawsize = stub_sec->size;
8369         stub_sec->size = 0;
8370       }
8371
8372   if (htab->plt != NULL)
8373     {
8374       unsigned int indx;
8375       bfd_vma plt0;
8376
8377       /* Build the .glink plt call stub.  */
8378       plt0 = (htab->plt->output_section->vma
8379               + htab->plt->output_offset
8380               - (htab->glink->output_section->vma
8381                  + htab->glink->output_offset
8382                  + GLINK_CALL_STUB_SIZE));
8383       if (plt0 + 0x80008000 > 0xffffffff)
8384         {
8385           (*_bfd_error_handler) (_(".glink and .plt too far apart"));
8386           bfd_set_error (bfd_error_bad_value);
8387           return FALSE;
8388         }
8389
8390       if (htab->emit_stub_syms)
8391         {
8392           struct elf_link_hash_entry *h;
8393           h = elf_link_hash_lookup (&htab->elf, "__glink", TRUE, FALSE, FALSE);
8394           if (h == NULL)
8395             return FALSE;
8396           if (h->root.type == bfd_link_hash_new)
8397             {
8398               h->root.type = bfd_link_hash_defined;
8399               h->root.u.def.section = htab->glink;
8400               h->root.u.def.value = 0;
8401               h->ref_regular = 1;
8402               h->def_regular = 1;
8403               h->ref_regular_nonweak = 1;
8404               h->forced_local = 1;
8405               h->non_elf = 0;
8406             }
8407         }
8408       p = htab->glink->contents;
8409       bfd_put_32 (htab->glink->owner, MFCTR_R12, p);
8410       p += 4;
8411       bfd_put_32 (htab->glink->owner, SLDI_R11_R0_3, p);
8412       p += 4;
8413       bfd_put_32 (htab->glink->owner, ADDIC_R2_R0_32K, p);
8414       p += 4;
8415       bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
8416       p += 4;
8417       bfd_put_32 (htab->glink->owner, SRADI_R2_R2_63, p);
8418       p += 4;
8419       bfd_put_32 (htab->glink->owner, SLDI_R11_R0_2, p);
8420       p += 4;
8421       bfd_put_32 (htab->glink->owner, AND_R2_R2_R11, p);
8422       p += 4;
8423       bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
8424       p += 4;
8425       bfd_put_32 (htab->glink->owner, ADD_R12_R12_R2, p);
8426       p += 4;
8427       bfd_put_32 (htab->glink->owner, ADDIS_R12_R12 | PPC_HA (plt0), p);
8428       p += 4;
8429       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | PPC_LO (plt0), p);
8430       p += 4;
8431       bfd_put_32 (htab->glink->owner, ADDI_R12_R12 | PPC_LO (plt0), p);
8432       p += 4;
8433       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
8434       p += 4;
8435       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
8436       p += 4;
8437       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
8438       p += 4;
8439       bfd_put_32 (htab->glink->owner, BCTR, p);
8440       p += 4;
8441
8442       /* Build the .glink lazy link call stubs.  */
8443       indx = 0;
8444       while (p < htab->glink->contents + htab->glink->size)
8445         {
8446           if (indx < 0x8000)
8447             {
8448               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
8449               p += 4;
8450             }
8451           else
8452             {
8453               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
8454               p += 4;
8455               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
8456               p += 4;
8457             }
8458           bfd_put_32 (htab->glink->owner,
8459                       B_DOT | ((htab->glink->contents - p) & 0x3fffffc), p);
8460           indx++;
8461           p += 4;
8462         }
8463       htab->glink->rawsize = p - htab->glink->contents;
8464     }
8465
8466   if (htab->brlt->size != 0)
8467     {
8468       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
8469                                          htab->brlt->size);
8470       if (htab->brlt->contents == NULL)
8471         return FALSE;
8472     }
8473   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
8474     {
8475       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
8476                                             htab->relbrlt->size);
8477       if (htab->relbrlt->contents == NULL)
8478         return FALSE;
8479     }
8480
8481   /* Build the stubs as directed by the stub hash table.  */
8482   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
8483
8484   for (stub_sec = htab->stub_bfd->sections;
8485        stub_sec != NULL;
8486        stub_sec = stub_sec->next)
8487     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
8488       {
8489         stub_sec_count += 1;
8490         if (stub_sec->rawsize != stub_sec->size)
8491           break;
8492       }
8493
8494   if (stub_sec != NULL
8495       || htab->glink->rawsize != htab->glink->size)
8496     {
8497       htab->stub_error = TRUE;
8498       (*_bfd_error_handler) (_("stubs don't match calculated size"));
8499     }
8500
8501   if (htab->stub_error)
8502     return FALSE;
8503
8504   if (stats != NULL)
8505     {
8506       *stats = bfd_malloc (500);
8507       if (*stats == NULL)
8508         return FALSE;
8509
8510       sprintf (*stats, _("linker stubs in %u group%s\n"
8511                          "  branch       %lu\n"
8512                          "  toc adjust   %lu\n"
8513                          "  long branch  %lu\n"
8514                          "  long toc adj %lu\n"
8515                          "  plt call     %lu"),
8516                stub_sec_count,
8517                stub_sec_count == 1 ? "" : "s",
8518                htab->stub_count[ppc_stub_long_branch - 1],
8519                htab->stub_count[ppc_stub_long_branch_r2off - 1],
8520                htab->stub_count[ppc_stub_plt_branch - 1],
8521                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
8522                htab->stub_count[ppc_stub_plt_call - 1]);
8523     }
8524   return TRUE;
8525 }
8526
8527 /* This function undoes the changes made by add_symbol_adjust.  */
8528
8529 static bfd_boolean
8530 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
8531 {
8532   struct ppc_link_hash_entry *eh;
8533
8534   if (h->root.type == bfd_link_hash_indirect)
8535     return TRUE;
8536
8537   if (h->root.type == bfd_link_hash_warning)
8538     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8539
8540   eh = (struct ppc_link_hash_entry *) h;
8541   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
8542     return TRUE;
8543
8544   eh->elf.root.type = bfd_link_hash_undefined;
8545   return TRUE;
8546 }
8547
8548 void
8549 ppc64_elf_restore_symbols (struct bfd_link_info *info)
8550 {
8551   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8552   elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
8553 }
8554
8555 /* The RELOCATE_SECTION function is called by the ELF backend linker
8556    to handle the relocations for a section.
8557
8558    The relocs are always passed as Rela structures; if the section
8559    actually uses Rel structures, the r_addend field will always be
8560    zero.
8561
8562    This function is responsible for adjust the section contents as
8563    necessary, and (if using Rela relocs and generating a
8564    relocatable output file) adjusting the reloc addend as
8565    necessary.
8566
8567    This function does not have to worry about setting the reloc
8568    address or the reloc symbol index.
8569
8570    LOCAL_SYMS is a pointer to the swapped in local symbols.
8571
8572    LOCAL_SECTIONS is an array giving the section in the input file
8573    corresponding to the st_shndx field of each local symbol.
8574
8575    The global hash table entry for the global symbols can be found
8576    via elf_sym_hashes (input_bfd).
8577
8578    When generating relocatable output, this function must handle
8579    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
8580    going to be the section symbol corresponding to the output
8581    section, which means that the addend must be adjusted
8582    accordingly.  */
8583
8584 static bfd_boolean
8585 ppc64_elf_relocate_section (bfd *output_bfd,
8586                             struct bfd_link_info *info,
8587                             bfd *input_bfd,
8588                             asection *input_section,
8589                             bfd_byte *contents,
8590                             Elf_Internal_Rela *relocs,
8591                             Elf_Internal_Sym *local_syms,
8592                             asection **local_sections)
8593 {
8594   struct ppc_link_hash_table *htab;
8595   Elf_Internal_Shdr *symtab_hdr;
8596   struct elf_link_hash_entry **sym_hashes;
8597   Elf_Internal_Rela *rel;
8598   Elf_Internal_Rela *relend;
8599   Elf_Internal_Rela outrel;
8600   bfd_byte *loc;
8601   struct got_entry **local_got_ents;
8602   bfd_vma TOCstart;
8603   bfd_boolean ret = TRUE;
8604   bfd_boolean is_opd;
8605   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
8606   bfd_boolean is_power4 = FALSE;
8607
8608   if (info->relocatable)
8609     return TRUE;
8610
8611   /* Initialize howto table if needed.  */
8612   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8613     ppc_howto_init ();
8614
8615   htab = ppc_hash_table (info);
8616
8617   /* Don't relocate stub sections.  */
8618   if (input_section->owner == htab->stub_bfd)
8619     return TRUE;
8620
8621   local_got_ents = elf_local_got_ents (input_bfd);
8622   TOCstart = elf_gp (output_bfd);
8623   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
8624   sym_hashes = elf_sym_hashes (input_bfd);
8625   is_opd = ppc64_elf_section_data (input_section)->opd.adjust != NULL;
8626
8627   rel = relocs;
8628   relend = relocs + input_section->reloc_count;
8629   for (; rel < relend; rel++)
8630     {
8631       enum elf_ppc64_reloc_type r_type;
8632       bfd_vma addend;
8633       bfd_reloc_status_type r;
8634       Elf_Internal_Sym *sym;
8635       asection *sec;
8636       struct elf_link_hash_entry *h_elf;
8637       struct ppc_link_hash_entry *h;
8638       struct ppc_link_hash_entry *fdh;
8639       const char *sym_name;
8640       unsigned long r_symndx, toc_symndx;
8641       char tls_mask, tls_gd, tls_type;
8642       char sym_type;
8643       bfd_vma relocation;
8644       bfd_boolean unresolved_reloc;
8645       bfd_boolean warned;
8646       unsigned long insn, mask;
8647       struct ppc_stub_hash_entry *stub_entry;
8648       bfd_vma max_br_offset;
8649       bfd_vma from;
8650
8651       r_type = ELF64_R_TYPE (rel->r_info);
8652       r_symndx = ELF64_R_SYM (rel->r_info);
8653
8654       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
8655          symbol of the previous ADDR64 reloc.  The symbol gives us the
8656          proper TOC base to use.  */
8657       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
8658           && rel != relocs
8659           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
8660           && is_opd)
8661         r_symndx = ELF64_R_SYM (rel[-1].r_info);
8662
8663       sym = NULL;
8664       sec = NULL;
8665       h_elf = NULL;
8666       sym_name = NULL;
8667       unresolved_reloc = FALSE;
8668       warned = FALSE;
8669
8670       if (r_symndx < symtab_hdr->sh_info)
8671         {
8672           /* It's a local symbol.  */
8673           long *opd_adjust;
8674
8675           sym = local_syms + r_symndx;
8676           sec = local_sections[r_symndx];
8677           sym_name = bfd_elf_local_sym_name (input_bfd, sym);
8678           sym_type = ELF64_ST_TYPE (sym->st_info);
8679           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8680           opd_adjust = get_opd_info (sec);
8681           if (opd_adjust != NULL)
8682             {
8683               long adjust = opd_adjust[(sym->st_value + rel->r_addend) / 8];
8684               if (adjust == -1)
8685                 relocation = 0;
8686               else
8687                 relocation += adjust;
8688             }
8689         }
8690       else
8691         {
8692           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
8693                                    r_symndx, symtab_hdr, sym_hashes,
8694                                    h_elf, sec, relocation,
8695                                    unresolved_reloc, warned);
8696           sym_name = h_elf->root.root.string;
8697           sym_type = h_elf->type;
8698         }
8699       h = (struct ppc_link_hash_entry *) h_elf;
8700
8701       /* TLS optimizations.  Replace instruction sequences and relocs
8702          based on information we collected in tls_optimize.  We edit
8703          RELOCS so that --emit-relocs will output something sensible
8704          for the final instruction stream.  */
8705       tls_mask = 0;
8706       tls_gd = 0;
8707       toc_symndx = 0;
8708       if (IS_PPC64_TLS_RELOC (r_type))
8709         {
8710           if (h != NULL)
8711             tls_mask = h->tls_mask;
8712           else if (local_got_ents != NULL)
8713             {
8714               char *lgot_masks;
8715               lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
8716               tls_mask = lgot_masks[r_symndx];
8717             }
8718           if (tls_mask == 0 && r_type == R_PPC64_TLS)
8719             {
8720               /* Check for toc tls entries.  */
8721               char *toc_tls;
8722
8723               if (!get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
8724                                  rel, input_bfd))
8725                 return FALSE;
8726
8727               if (toc_tls)
8728                 tls_mask = *toc_tls;
8729             }
8730         }
8731
8732       /* Check that tls relocs are used with tls syms, and non-tls
8733          relocs are used with non-tls syms.  */
8734       if (r_symndx != 0
8735           && r_type != R_PPC64_NONE
8736           && (h == NULL
8737               || h->elf.root.type == bfd_link_hash_defined
8738               || h->elf.root.type == bfd_link_hash_defweak)
8739           && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
8740         {
8741           if (r_type == R_PPC64_TLS && tls_mask != 0)
8742             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
8743             ;
8744           else
8745             (*_bfd_error_handler)
8746               (sym_type == STT_TLS
8747                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
8748                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
8749                input_bfd,
8750                input_section,
8751                (long) rel->r_offset,
8752                ppc64_elf_howto_table[r_type]->name,
8753                sym_name);
8754         }
8755
8756       /* Ensure reloc mapping code below stays sane.  */
8757       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
8758           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
8759           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
8760           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
8761           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
8762           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
8763           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
8764           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
8765           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
8766           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
8767         abort ();
8768
8769       switch (r_type)
8770         {
8771         default:
8772           break;
8773
8774         case R_PPC64_TOC16:
8775         case R_PPC64_TOC16_LO:
8776         case R_PPC64_TOC16_DS:
8777         case R_PPC64_TOC16_LO_DS:
8778           {
8779             /* Check for toc tls entries.  */
8780             char *toc_tls;
8781             int retval;
8782
8783             retval = get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
8784                                    rel, input_bfd);
8785             if (retval == 0)
8786               return FALSE;
8787
8788             if (toc_tls)
8789               {
8790                 tls_mask = *toc_tls;
8791                 if (r_type == R_PPC64_TOC16_DS
8792                     || r_type == R_PPC64_TOC16_LO_DS)
8793                   {
8794                     if (tls_mask != 0
8795                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
8796                       goto toctprel;
8797                   }
8798                 else
8799                   {
8800                     /* If we found a GD reloc pair, then we might be
8801                        doing a GD->IE transition.  */
8802                     if (retval == 2)
8803                       {
8804                         tls_gd = TLS_TPRELGD;
8805                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
8806                           goto tls_get_addr_check;
8807                       }
8808                     else if (retval == 3)
8809                       {
8810                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
8811                           goto tls_get_addr_check;
8812                       }
8813                   }
8814               }
8815           }
8816           break;
8817
8818         case R_PPC64_GOT_TPREL16_DS:
8819         case R_PPC64_GOT_TPREL16_LO_DS:
8820           if (tls_mask != 0
8821               && (tls_mask & TLS_TPREL) == 0)
8822             {
8823             toctprel:
8824               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
8825               insn &= 31 << 21;
8826               insn |= 0x3c0d0000;       /* addis 0,13,0 */
8827               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
8828               r_type = R_PPC64_TPREL16_HA;
8829               if (toc_symndx != 0)
8830                 {
8831                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
8832                   /* We changed the symbol.  Start over in order to
8833                      get h, sym, sec etc. right.  */
8834                   rel--;
8835                   continue;
8836                 }
8837               else
8838                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
8839             }
8840           break;
8841
8842         case R_PPC64_TLS:
8843           if (tls_mask != 0
8844               && (tls_mask & TLS_TPREL) == 0)
8845             {
8846               bfd_vma rtra;
8847               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
8848               if ((insn & ((0x3f << 26) | (31 << 11)))
8849                   == ((31 << 26) | (13 << 11)))
8850                 rtra = insn & ((1 << 26) - (1 << 16));
8851               else if ((insn & ((0x3f << 26) | (31 << 16)))
8852                        == ((31 << 26) | (13 << 16)))
8853                 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
8854               else
8855                 abort ();
8856               if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
8857                 /* add -> addi.  */
8858                 insn = 14 << 26;
8859               else if ((insn & (31 << 1)) == 23 << 1
8860                        && ((insn & (31 << 6)) < 14 << 6
8861                            || ((insn & (31 << 6)) >= 16 << 6
8862                                && (insn & (31 << 6)) < 24 << 6)))
8863                 /* load and store indexed -> dform.  */
8864                 insn = (32 | ((insn >> 6) & 31)) << 26;
8865               else if ((insn & (31 << 1)) == 21 << 1
8866                        && (insn & (0x1a << 6)) == 0)
8867                 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
8868                 insn = (((58 | ((insn >> 6) & 4)) << 26)
8869                         | ((insn >> 6) & 1));
8870               else if ((insn & (31 << 1)) == 21 << 1
8871                        && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
8872                 /* lwax -> lwa.  */
8873                 insn = (58 << 26) | 2;
8874               else
8875                 abort ();
8876               insn |= rtra;
8877               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
8878               /* Was PPC64_TLS which sits on insn boundary, now
8879                  PPC64_TPREL16_LO which is at insn+2.  */
8880               rel->r_offset += 2;
8881               r_type = R_PPC64_TPREL16_LO;
8882               if (toc_symndx != 0)
8883                 {
8884                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
8885                   /* We changed the symbol.  Start over in order to
8886                      get h, sym, sec etc. right.  */
8887                   rel--;
8888                   continue;
8889                 }
8890               else
8891                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
8892             }
8893           break;
8894
8895         case R_PPC64_GOT_TLSGD16_HI:
8896         case R_PPC64_GOT_TLSGD16_HA:
8897           tls_gd = TLS_TPRELGD;
8898           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
8899             goto tls_gdld_hi;
8900           break;
8901
8902         case R_PPC64_GOT_TLSLD16_HI:
8903         case R_PPC64_GOT_TLSLD16_HA:
8904           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
8905             {
8906             tls_gdld_hi:
8907               if ((tls_mask & tls_gd) != 0)
8908                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
8909                           + R_PPC64_GOT_TPREL16_DS);
8910               else
8911                 {
8912                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
8913                   rel->r_offset -= 2;
8914                   r_type = R_PPC64_NONE;
8915                 }
8916               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
8917             }
8918           break;
8919
8920         case R_PPC64_GOT_TLSGD16:
8921         case R_PPC64_GOT_TLSGD16_LO:
8922           tls_gd = TLS_TPRELGD;
8923           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
8924             goto tls_get_addr_check;
8925           break;
8926
8927         case R_PPC64_GOT_TLSLD16:
8928         case R_PPC64_GOT_TLSLD16_LO:
8929           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
8930             {
8931             tls_get_addr_check:
8932               if (rel + 1 < relend)
8933                 {
8934                   enum elf_ppc64_reloc_type r_type2;
8935                   unsigned long r_symndx2;
8936                   struct elf_link_hash_entry *h2;
8937                   bfd_vma insn1, insn2, insn3;
8938                   bfd_vma offset;
8939
8940                   /* The next instruction should be a call to
8941                      __tls_get_addr.  Peek at the reloc to be sure.  */
8942                   r_type2 = ELF64_R_TYPE (rel[1].r_info);
8943                   r_symndx2 = ELF64_R_SYM (rel[1].r_info);
8944                   if (r_symndx2 < symtab_hdr->sh_info
8945                       || (r_type2 != R_PPC64_REL14
8946                           && r_type2 != R_PPC64_REL14_BRTAKEN
8947                           && r_type2 != R_PPC64_REL14_BRNTAKEN
8948                           && r_type2 != R_PPC64_REL24))
8949                     break;
8950
8951                   h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
8952                   while (h2->root.type == bfd_link_hash_indirect
8953                          || h2->root.type == bfd_link_hash_warning)
8954                     h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
8955                   if (h2 == NULL || (h2 != &htab->tls_get_addr->elf
8956                                      && h2 != &htab->tls_get_addr_fd->elf))
8957                     break;
8958
8959                   /* OK, it checks out.  Replace the call.  */
8960                   offset = rel[1].r_offset;
8961                   insn1 = bfd_get_32 (output_bfd,
8962                                       contents + rel->r_offset - 2);
8963                   insn3 = bfd_get_32 (output_bfd,
8964                                       contents + offset + 4);
8965                   if ((tls_mask & tls_gd) != 0)
8966                     {
8967                       /* IE */
8968                       insn1 &= (1 << 26) - (1 << 2);
8969                       insn1 |= 58 << 26;        /* ld */
8970                       insn2 = 0x7c636a14;       /* add 3,3,13 */
8971                       rel[1].r_info = ELF64_R_INFO (r_symndx2, R_PPC64_NONE);
8972                       if ((tls_mask & TLS_EXPLICIT) == 0)
8973                         r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
8974                                   + R_PPC64_GOT_TPREL16_DS);
8975                       else
8976                         r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
8977                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
8978                     }
8979                   else
8980                     {
8981                       /* LE */
8982                       insn1 = 0x3c6d0000;       /* addis 3,13,0 */
8983                       insn2 = 0x38630000;       /* addi 3,3,0 */
8984                       if (tls_gd == 0)
8985                         {
8986                           /* Was an LD reloc.  */
8987                           r_symndx = 0;
8988                           rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
8989                           rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
8990                         }
8991                       else if (toc_symndx != 0)
8992                         r_symndx = toc_symndx;
8993                       r_type = R_PPC64_TPREL16_HA;
8994                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
8995                       rel[1].r_info = ELF64_R_INFO (r_symndx,
8996                                                     R_PPC64_TPREL16_LO);
8997                       rel[1].r_offset += 2;
8998                     }
8999                   if (insn3 == NOP
9000                       || insn3 == CROR_151515 || insn3 == CROR_313131)
9001                     {
9002                       insn3 = insn2;
9003                       insn2 = NOP;
9004                       rel[1].r_offset += 4;
9005                     }
9006                   bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
9007                   bfd_put_32 (output_bfd, insn2, contents + offset);
9008                   bfd_put_32 (output_bfd, insn3, contents + offset + 4);
9009                   if (tls_gd == 0 || toc_symndx != 0)
9010                     {
9011                       /* We changed the symbol.  Start over in order
9012                          to get h, sym, sec etc. right.  */
9013                       rel--;
9014                       continue;
9015                     }
9016                 }
9017             }
9018           break;
9019
9020         case R_PPC64_DTPMOD64:
9021           if (rel + 1 < relend
9022               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
9023               && rel[1].r_offset == rel->r_offset + 8)
9024             {
9025               if ((tls_mask & TLS_GD) == 0)
9026                 {
9027                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
9028                   if ((tls_mask & TLS_TPRELGD) != 0)
9029                     r_type = R_PPC64_TPREL64;
9030                   else
9031                     {
9032                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
9033                       r_type = R_PPC64_NONE;
9034                     }
9035                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9036                 }
9037             }
9038           else
9039             {
9040               if ((tls_mask & TLS_LD) == 0)
9041                 {
9042                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
9043                   r_type = R_PPC64_NONE;
9044                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9045                 }
9046             }
9047           break;
9048
9049         case R_PPC64_TPREL64:
9050           if ((tls_mask & TLS_TPREL) == 0)
9051             {
9052               r_type = R_PPC64_NONE;
9053               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9054             }
9055           break;
9056         }
9057
9058       /* Handle other relocations that tweak non-addend part of insn.  */
9059       insn = 0;
9060       max_br_offset = 1 << 25;
9061       addend = rel->r_addend;
9062       switch (r_type)
9063         {
9064         default:
9065           break;
9066
9067           /* Branch taken prediction relocations.  */
9068         case R_PPC64_ADDR14_BRTAKEN:
9069         case R_PPC64_REL14_BRTAKEN:
9070           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
9071           /* Fall thru.  */
9072
9073           /* Branch not taken prediction relocations.  */
9074         case R_PPC64_ADDR14_BRNTAKEN:
9075         case R_PPC64_REL14_BRNTAKEN:
9076           insn |= bfd_get_32 (output_bfd,
9077                               contents + rel->r_offset) & ~(0x01 << 21);
9078           /* Fall thru.  */
9079
9080         case R_PPC64_REL14:
9081           max_br_offset = 1 << 15;
9082           /* Fall thru.  */
9083
9084         case R_PPC64_REL24:
9085           /* Calls to functions with a different TOC, such as calls to
9086              shared objects, need to alter the TOC pointer.  This is
9087              done using a linkage stub.  A REL24 branching to these
9088              linkage stubs needs to be followed by a nop, as the nop
9089              will be replaced with an instruction to restore the TOC
9090              base pointer.  */
9091           stub_entry = NULL;
9092           fdh = h;
9093           if (((h != NULL
9094                 && (((fdh = h->oh) != NULL
9095                      && fdh->elf.plt.plist != NULL)
9096                     || (fdh = h)->elf.plt.plist != NULL))
9097                || (sec != NULL
9098                    && sec->output_section != NULL
9099                    && sec->id <= htab->top_id
9100                    && (htab->stub_group[sec->id].toc_off
9101                        != htab->stub_group[input_section->id].toc_off)))
9102               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
9103                                                    rel, htab)) != NULL
9104               && (stub_entry->stub_type == ppc_stub_plt_call
9105                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
9106                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
9107             {
9108               bfd_boolean can_plt_call = FALSE;
9109
9110               if (rel->r_offset + 8 <= input_section->size)
9111                 {
9112                   unsigned long nop;
9113                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
9114                   if (nop == NOP
9115                       || nop == CROR_151515 || nop == CROR_313131)
9116                     {
9117                       bfd_put_32 (input_bfd, LD_R2_40R1,
9118                                   contents + rel->r_offset + 4);
9119                       can_plt_call = TRUE;
9120                     }
9121                 }
9122
9123               if (!can_plt_call)
9124                 {
9125                   if (stub_entry->stub_type == ppc_stub_plt_call)
9126                     {
9127                       /* If this is a plain branch rather than a branch
9128                          and link, don't require a nop.  */
9129                       unsigned long br;
9130                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
9131                       if ((br & 1) == 0)
9132                         can_plt_call = TRUE;
9133                     }
9134                   else if (h != NULL
9135                            && strcmp (h->elf.root.root.string,
9136                                       ".__libc_start_main") == 0)
9137                     {
9138                       /* Allow crt1 branch to go via a toc adjusting stub.  */
9139                       can_plt_call = TRUE;
9140                     }
9141                   else
9142                     {
9143                       if (strcmp (input_section->output_section->name,
9144                                   ".init") == 0
9145                           || strcmp (input_section->output_section->name,
9146                                      ".fini") == 0)
9147                         (*_bfd_error_handler)
9148                           (_("%B(%A+0x%lx): automatic multiple TOCs "
9149                              "not supported using your crt files; "
9150                              "recompile with -mminimal-toc or upgrade gcc"),
9151                            input_bfd,
9152                            input_section,
9153                            (long) rel->r_offset);
9154                       else
9155                         (*_bfd_error_handler)
9156                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
9157                              "does not allow automatic multiple TOCs; "
9158                              "recompile with -mminimal-toc or "
9159                              "-fno-optimize-sibling-calls, "
9160                              "or make `%s' extern"),
9161                            input_bfd,
9162                            input_section,
9163                            (long) rel->r_offset,
9164                            sym_name,
9165                            sym_name);
9166                       bfd_set_error (bfd_error_bad_value);
9167                       ret = FALSE;
9168                     }
9169                 }
9170
9171               if (can_plt_call
9172                   && stub_entry->stub_type == ppc_stub_plt_call)
9173                 unresolved_reloc = FALSE;
9174             }
9175
9176           if (stub_entry == NULL
9177               && get_opd_info (sec) != NULL)
9178             {
9179               /* The branch destination is the value of the opd entry. */
9180               bfd_vma off = (relocation - sec->output_section->vma
9181                              - sec->output_offset + rel->r_addend);
9182               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
9183               if (dest != (bfd_vma) -1)
9184                 {
9185                   relocation = dest;
9186                   addend = 0;
9187                 }
9188             }
9189
9190           /* If the branch is out of reach we ought to have a long
9191              branch stub.  */
9192           from = (rel->r_offset
9193                   + input_section->output_offset
9194                   + input_section->output_section->vma);
9195
9196           if (stub_entry == NULL
9197               && (relocation + rel->r_addend - from + max_br_offset
9198                   >= 2 * max_br_offset)
9199               && r_type != R_PPC64_ADDR14_BRTAKEN
9200               && r_type != R_PPC64_ADDR14_BRNTAKEN)
9201             stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
9202                                              htab);
9203
9204           if (stub_entry != NULL)
9205             {
9206               /* Munge up the value and addend so that we call the stub
9207                  rather than the procedure directly.  */
9208               relocation = (stub_entry->stub_offset
9209                             + stub_entry->stub_sec->output_offset
9210                             + stub_entry->stub_sec->output_section->vma);
9211               addend = 0;
9212             }
9213
9214           if (insn != 0)
9215             {
9216               if (is_power4)
9217                 {
9218                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
9219                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
9220                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
9221                   if ((insn & (0x14 << 21)) == (0x04 << 21))
9222                     insn |= 0x02 << 21;
9223                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
9224                     insn |= 0x08 << 21;
9225                   else
9226                     break;
9227                 }
9228               else
9229                 {
9230                   /* Invert 'y' bit if not the default.  */
9231                   if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
9232                     insn ^= 0x01 << 21;
9233                 }
9234
9235               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9236             }
9237
9238           /* NOP out calls to undefined weak functions.
9239              We can thus call a weak function without first
9240              checking whether the function is defined.  */
9241           else if (h != NULL
9242                    && h->elf.root.type == bfd_link_hash_undefweak
9243                    && r_type == R_PPC64_REL24
9244                    && relocation == 0
9245                    && rel->r_addend == 0)
9246             {
9247               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
9248               continue;
9249             }
9250           break;
9251         }
9252
9253       /* Set `addend'.  */
9254       tls_type = 0;
9255       switch (r_type)
9256         {
9257         default:
9258           (*_bfd_error_handler)
9259             (_("%B: unknown relocation type %d for symbol %s"),
9260              input_bfd, (int) r_type, sym_name);
9261
9262           bfd_set_error (bfd_error_bad_value);
9263           ret = FALSE;
9264           continue;
9265
9266         case R_PPC64_NONE:
9267         case R_PPC64_TLS:
9268         case R_PPC64_GNU_VTINHERIT:
9269         case R_PPC64_GNU_VTENTRY:
9270           continue;
9271
9272           /* GOT16 relocations.  Like an ADDR16 using the symbol's
9273              address in the GOT as relocation value instead of the
9274              symbol's value itself.  Also, create a GOT entry for the
9275              symbol and put the symbol value there.  */
9276         case R_PPC64_GOT_TLSGD16:
9277         case R_PPC64_GOT_TLSGD16_LO:
9278         case R_PPC64_GOT_TLSGD16_HI:
9279         case R_PPC64_GOT_TLSGD16_HA:
9280           tls_type = TLS_TLS | TLS_GD;
9281           goto dogot;
9282
9283         case R_PPC64_GOT_TLSLD16:
9284         case R_PPC64_GOT_TLSLD16_LO:
9285         case R_PPC64_GOT_TLSLD16_HI:
9286         case R_PPC64_GOT_TLSLD16_HA:
9287           tls_type = TLS_TLS | TLS_LD;
9288           goto dogot;
9289
9290         case R_PPC64_GOT_TPREL16_DS:
9291         case R_PPC64_GOT_TPREL16_LO_DS:
9292         case R_PPC64_GOT_TPREL16_HI:
9293         case R_PPC64_GOT_TPREL16_HA:
9294           tls_type = TLS_TLS | TLS_TPREL;
9295           goto dogot;
9296
9297         case R_PPC64_GOT_DTPREL16_DS:
9298         case R_PPC64_GOT_DTPREL16_LO_DS:
9299         case R_PPC64_GOT_DTPREL16_HI:
9300         case R_PPC64_GOT_DTPREL16_HA:
9301           tls_type = TLS_TLS | TLS_DTPREL;
9302           goto dogot;
9303
9304         case R_PPC64_GOT16:
9305         case R_PPC64_GOT16_LO:
9306         case R_PPC64_GOT16_HI:
9307         case R_PPC64_GOT16_HA:
9308         case R_PPC64_GOT16_DS:
9309         case R_PPC64_GOT16_LO_DS:
9310         dogot:
9311           {
9312             /* Relocation is to the entry for this symbol in the global
9313                offset table.  */
9314             asection *got;
9315             bfd_vma *offp;
9316             bfd_vma off;
9317             unsigned long indx = 0;
9318
9319             if (tls_type == (TLS_TLS | TLS_LD)
9320                 && (h == NULL
9321                     || !h->elf.def_dynamic))
9322               offp = &ppc64_tlsld_got (input_bfd)->offset;
9323             else
9324               {
9325                 struct got_entry *ent;
9326
9327                 if (h != NULL)
9328                   {
9329                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
9330                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
9331                                                           &h->elf)
9332                         || (info->shared
9333                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
9334                       /* This is actually a static link, or it is a
9335                          -Bsymbolic link and the symbol is defined
9336                          locally, or the symbol was forced to be local
9337                          because of a version file.  */
9338                       ;
9339                     else
9340                       {
9341                         indx = h->elf.dynindx;
9342                         unresolved_reloc = FALSE;
9343                       }
9344                     ent = h->elf.got.glist;
9345                   }
9346                 else
9347                   {
9348                     if (local_got_ents == NULL)
9349                       abort ();
9350                     ent = local_got_ents[r_symndx];
9351                   }
9352
9353                 for (; ent != NULL; ent = ent->next)
9354                   if (ent->addend == rel->r_addend
9355                       && ent->owner == input_bfd
9356                       && ent->tls_type == tls_type)
9357                     break;
9358                 if (ent == NULL)
9359                   abort ();
9360                 offp = &ent->got.offset;
9361               }
9362
9363             got = ppc64_elf_tdata (input_bfd)->got;
9364             if (got == NULL)
9365               abort ();
9366
9367             /* The offset must always be a multiple of 8.  We use the
9368                least significant bit to record whether we have already
9369                processed this entry.  */
9370             off = *offp;
9371             if ((off & 1) != 0)
9372               off &= ~1;
9373             else
9374               {
9375                 /* Generate relocs for the dynamic linker, except in
9376                    the case of TLSLD where we'll use one entry per
9377                    module.  */
9378                 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
9379
9380                 *offp = off | 1;
9381                 if ((info->shared || indx != 0)
9382                     && (h == NULL
9383                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
9384                         || h->elf.root.type != bfd_link_hash_undefweak))
9385                   {
9386                     outrel.r_offset = (got->output_section->vma
9387                                        + got->output_offset
9388                                        + off);
9389                     outrel.r_addend = rel->r_addend;
9390                     if (tls_type & (TLS_LD | TLS_GD))
9391                       {
9392                         outrel.r_addend = 0;
9393                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
9394                         if (tls_type == (TLS_TLS | TLS_GD))
9395                           {
9396                             loc = relgot->contents;
9397                             loc += (relgot->reloc_count++
9398                                     * sizeof (Elf64_External_Rela));
9399                             bfd_elf64_swap_reloca_out (output_bfd,
9400                                                        &outrel, loc);
9401                             outrel.r_offset += 8;
9402                             outrel.r_addend = rel->r_addend;
9403                             outrel.r_info
9404                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
9405                           }
9406                       }
9407                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
9408                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
9409                     else if (tls_type == (TLS_TLS | TLS_TPREL))
9410                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
9411                     else if (indx == 0)
9412                       {
9413                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
9414
9415                         /* Write the .got section contents for the sake
9416                            of prelink.  */
9417                         loc = got->contents + off;
9418                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
9419                                     loc);
9420                       }
9421                     else
9422                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
9423
9424                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
9425                       {
9426                         outrel.r_addend += relocation;
9427                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
9428                           outrel.r_addend -= htab->elf.tls_sec->vma;
9429                       }
9430                     loc = relgot->contents;
9431                     loc += (relgot->reloc_count++
9432                             * sizeof (Elf64_External_Rela));
9433                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
9434                   }
9435
9436                 /* Init the .got section contents here if we're not
9437                    emitting a reloc.  */
9438                 else
9439                   {
9440                     relocation += rel->r_addend;
9441                     if (tls_type == (TLS_TLS | TLS_LD))
9442                       relocation = 1;
9443                     else if (tls_type != 0)
9444                       {
9445                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
9446                         if (tls_type == (TLS_TLS | TLS_TPREL))
9447                           relocation += DTP_OFFSET - TP_OFFSET;
9448
9449                         if (tls_type == (TLS_TLS | TLS_GD))
9450                           {
9451                             bfd_put_64 (output_bfd, relocation,
9452                                         got->contents + off + 8);
9453                             relocation = 1;
9454                           }
9455                       }
9456
9457                     bfd_put_64 (output_bfd, relocation,
9458                                 got->contents + off);
9459                   }
9460               }
9461
9462             if (off >= (bfd_vma) -2)
9463               abort ();
9464
9465             relocation = got->output_offset + off;
9466
9467             /* TOC base (r2) is TOC start plus 0x8000.  */
9468             addend = -TOC_BASE_OFF;
9469           }
9470           break;
9471
9472         case R_PPC64_PLT16_HA:
9473         case R_PPC64_PLT16_HI:
9474         case R_PPC64_PLT16_LO:
9475         case R_PPC64_PLT32:
9476         case R_PPC64_PLT64:
9477           /* Relocation is to the entry for this symbol in the
9478              procedure linkage table.  */
9479
9480           /* Resolve a PLT reloc against a local symbol directly,
9481              without using the procedure linkage table.  */
9482           if (h == NULL)
9483             break;
9484
9485           /* It's possible that we didn't make a PLT entry for this
9486              symbol.  This happens when statically linking PIC code,
9487              or when using -Bsymbolic.  Go find a match if there is a
9488              PLT entry.  */
9489           if (htab->plt != NULL)
9490             {
9491               struct plt_entry *ent;
9492               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
9493                 if (ent->addend == rel->r_addend
9494                     && ent->plt.offset != (bfd_vma) -1)
9495                   {
9496                     relocation = (htab->plt->output_section->vma
9497                                   + htab->plt->output_offset
9498                                   + ent->plt.offset);
9499                     unresolved_reloc = FALSE;
9500                   }
9501             }
9502           break;
9503
9504         case R_PPC64_TOC:
9505           /* Relocation value is TOC base.  */
9506           relocation = TOCstart;
9507           if (r_symndx == 0)
9508             relocation += htab->stub_group[input_section->id].toc_off;
9509           else if (unresolved_reloc)
9510             ;
9511           else if (sec != NULL && sec->id <= htab->top_id)
9512             relocation += htab->stub_group[sec->id].toc_off;
9513           else
9514             unresolved_reloc = TRUE;
9515           goto dodyn2;
9516
9517           /* TOC16 relocs.  We want the offset relative to the TOC base,
9518              which is the address of the start of the TOC plus 0x8000.
9519              The TOC consists of sections .got, .toc, .tocbss, and .plt,
9520              in this order.  */
9521         case R_PPC64_TOC16:
9522         case R_PPC64_TOC16_LO:
9523         case R_PPC64_TOC16_HI:
9524         case R_PPC64_TOC16_DS:
9525         case R_PPC64_TOC16_LO_DS:
9526         case R_PPC64_TOC16_HA:
9527           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
9528           break;
9529
9530           /* Relocate against the beginning of the section.  */
9531         case R_PPC64_SECTOFF:
9532         case R_PPC64_SECTOFF_LO:
9533         case R_PPC64_SECTOFF_HI:
9534         case R_PPC64_SECTOFF_DS:
9535         case R_PPC64_SECTOFF_LO_DS:
9536         case R_PPC64_SECTOFF_HA:
9537           if (sec != NULL)
9538             addend -= sec->output_section->vma;
9539           break;
9540
9541         case R_PPC64_REL14:
9542         case R_PPC64_REL14_BRNTAKEN:
9543         case R_PPC64_REL14_BRTAKEN:
9544         case R_PPC64_REL24:
9545           break;
9546
9547         case R_PPC64_TPREL16:
9548         case R_PPC64_TPREL16_LO:
9549         case R_PPC64_TPREL16_HI:
9550         case R_PPC64_TPREL16_HA:
9551         case R_PPC64_TPREL16_DS:
9552         case R_PPC64_TPREL16_LO_DS:
9553         case R_PPC64_TPREL16_HIGHER:
9554         case R_PPC64_TPREL16_HIGHERA:
9555         case R_PPC64_TPREL16_HIGHEST:
9556         case R_PPC64_TPREL16_HIGHESTA:
9557           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
9558           if (info->shared)
9559             /* The TPREL16 relocs shouldn't really be used in shared
9560                libs as they will result in DT_TEXTREL being set, but
9561                support them anyway.  */
9562             goto dodyn;
9563           break;
9564
9565         case R_PPC64_DTPREL16:
9566         case R_PPC64_DTPREL16_LO:
9567         case R_PPC64_DTPREL16_HI:
9568         case R_PPC64_DTPREL16_HA:
9569         case R_PPC64_DTPREL16_DS:
9570         case R_PPC64_DTPREL16_LO_DS:
9571         case R_PPC64_DTPREL16_HIGHER:
9572         case R_PPC64_DTPREL16_HIGHERA:
9573         case R_PPC64_DTPREL16_HIGHEST:
9574         case R_PPC64_DTPREL16_HIGHESTA:
9575           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
9576           break;
9577
9578         case R_PPC64_DTPMOD64:
9579           relocation = 1;
9580           addend = 0;
9581           goto dodyn;
9582
9583         case R_PPC64_TPREL64:
9584           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
9585           goto dodyn;
9586
9587         case R_PPC64_DTPREL64:
9588           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
9589           /* Fall thru */
9590
9591           /* Relocations that may need to be propagated if this is a
9592              dynamic object.  */
9593         case R_PPC64_REL30:
9594         case R_PPC64_REL32:
9595         case R_PPC64_REL64:
9596         case R_PPC64_ADDR14:
9597         case R_PPC64_ADDR14_BRNTAKEN:
9598         case R_PPC64_ADDR14_BRTAKEN:
9599         case R_PPC64_ADDR16:
9600         case R_PPC64_ADDR16_DS:
9601         case R_PPC64_ADDR16_HA:
9602         case R_PPC64_ADDR16_HI:
9603         case R_PPC64_ADDR16_HIGHER:
9604         case R_PPC64_ADDR16_HIGHERA:
9605         case R_PPC64_ADDR16_HIGHEST:
9606         case R_PPC64_ADDR16_HIGHESTA:
9607         case R_PPC64_ADDR16_LO:
9608         case R_PPC64_ADDR16_LO_DS:
9609         case R_PPC64_ADDR24:
9610         case R_PPC64_ADDR32:
9611         case R_PPC64_ADDR64:
9612         case R_PPC64_UADDR16:
9613         case R_PPC64_UADDR32:
9614         case R_PPC64_UADDR64:
9615           /* r_symndx will be zero only for relocs against symbols
9616              from removed linkonce sections, or sections discarded by
9617              a linker script.  */
9618         dodyn:
9619           if (r_symndx == 0)
9620             break;
9621           /* Fall thru.  */
9622
9623         dodyn2:
9624           if ((input_section->flags & SEC_ALLOC) == 0)
9625             break;
9626
9627           if (NO_OPD_RELOCS && is_opd)
9628             break;
9629
9630           if ((info->shared
9631                && (h == NULL
9632                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
9633                    || h->elf.root.type != bfd_link_hash_undefweak)
9634                && (MUST_BE_DYN_RELOC (r_type)
9635                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
9636               || (ELIMINATE_COPY_RELOCS
9637                   && !info->shared
9638                   && h != NULL
9639                   && h->elf.dynindx != -1
9640                   && !h->elf.non_got_ref
9641                   && h->elf.def_dynamic
9642                   && !h->elf.def_regular))
9643             {
9644               Elf_Internal_Rela outrel;
9645               bfd_boolean skip, relocate;
9646               asection *sreloc;
9647               bfd_byte *loc;
9648               bfd_vma out_off;
9649
9650               /* When generating a dynamic object, these relocations
9651                  are copied into the output file to be resolved at run
9652                  time.  */
9653
9654               skip = FALSE;
9655               relocate = FALSE;
9656
9657               out_off = _bfd_elf_section_offset (output_bfd, info,
9658                                                  input_section, rel->r_offset);
9659               if (out_off == (bfd_vma) -1)
9660                 skip = TRUE;
9661               else if (out_off == (bfd_vma) -2)
9662                 skip = TRUE, relocate = TRUE;
9663               out_off += (input_section->output_section->vma
9664                           + input_section->output_offset);
9665               outrel.r_offset = out_off;
9666               outrel.r_addend = rel->r_addend;
9667
9668               /* Optimize unaligned reloc use.  */
9669               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
9670                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
9671                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
9672               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
9673                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
9674                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
9675               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
9676                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
9677                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
9678
9679               if (skip)
9680                 memset (&outrel, 0, sizeof outrel);
9681               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
9682                        && !is_opd
9683                        && r_type != R_PPC64_TOC)
9684                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
9685               else
9686                 {
9687                   /* This symbol is local, or marked to become local,
9688                      or this is an opd section reloc which must point
9689                      at a local function.  */
9690                   outrel.r_addend += relocation;
9691                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
9692                     {
9693                       if (is_opd && h != NULL)
9694                         {
9695                           /* Lie about opd entries.  This case occurs
9696                              when building shared libraries and we
9697                              reference a function in another shared
9698                              lib.  The same thing happens for a weak
9699                              definition in an application that's
9700                              overridden by a strong definition in a
9701                              shared lib.  (I believe this is a generic
9702                              bug in binutils handling of weak syms.)
9703                              In these cases we won't use the opd
9704                              entry in this lib.  */
9705                           unresolved_reloc = FALSE;
9706                         }
9707                       outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9708
9709                       /* We need to relocate .opd contents for ld.so.
9710                          Prelink also wants simple and consistent rules
9711                          for relocs.  This make all RELATIVE relocs have
9712                          *r_offset equal to r_addend.  */
9713                       relocate = TRUE;
9714                     }
9715                   else
9716                     {
9717                       long indx = 0;
9718
9719                       if (bfd_is_abs_section (sec))
9720                         ;
9721                       else if (sec == NULL || sec->owner == NULL)
9722                         {
9723                           bfd_set_error (bfd_error_bad_value);
9724                           return FALSE;
9725                         }
9726                       else
9727                         {
9728                           asection *osec;
9729
9730                           osec = sec->output_section;
9731                           indx = elf_section_data (osec)->dynindx;
9732
9733                           /* We are turning this relocation into one
9734                              against a section symbol, so subtract out
9735                              the output section's address but not the
9736                              offset of the input section in the output
9737                              section.  */
9738                           outrel.r_addend -= osec->vma;
9739                         }
9740
9741                       outrel.r_info = ELF64_R_INFO (indx, r_type);
9742                     }
9743                 }
9744
9745               sreloc = elf_section_data (input_section)->sreloc;
9746               if (sreloc == NULL)
9747                 abort ();
9748
9749               loc = sreloc->contents;
9750               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
9751               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
9752
9753               /* If this reloc is against an external symbol, it will
9754                  be computed at runtime, so there's no need to do
9755                  anything now.  However, for the sake of prelink ensure
9756                  that the section contents are a known value.  */
9757               if (! relocate)
9758                 {
9759                   unresolved_reloc = FALSE;
9760                   /* The value chosen here is quite arbitrary as ld.so
9761                      ignores section contents except for the special
9762                      case of .opd where the contents might be accessed
9763                      before relocation.  Choose zero, as that won't
9764                      cause reloc overflow.  */
9765                   relocation = 0;
9766                   addend = 0;
9767                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
9768                      to improve backward compatibility with older
9769                      versions of ld.  */
9770                   if (r_type == R_PPC64_ADDR64)
9771                     addend = outrel.r_addend;
9772                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
9773                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
9774                     addend = (input_section->output_section->vma
9775                               + input_section->output_offset
9776                               + rel->r_offset);
9777                 }
9778             }
9779           break;
9780
9781         case R_PPC64_COPY:
9782         case R_PPC64_GLOB_DAT:
9783         case R_PPC64_JMP_SLOT:
9784         case R_PPC64_RELATIVE:
9785           /* We shouldn't ever see these dynamic relocs in relocatable
9786              files.  */
9787           /* Fall through.  */
9788
9789         case R_PPC64_PLTGOT16:
9790         case R_PPC64_PLTGOT16_DS:
9791         case R_PPC64_PLTGOT16_HA:
9792         case R_PPC64_PLTGOT16_HI:
9793         case R_PPC64_PLTGOT16_LO:
9794         case R_PPC64_PLTGOT16_LO_DS:
9795         case R_PPC64_PLTREL32:
9796         case R_PPC64_PLTREL64:
9797           /* These ones haven't been implemented yet.  */
9798
9799           (*_bfd_error_handler)
9800             (_("%B: relocation %s is not supported for symbol %s."),
9801              input_bfd,
9802              ppc64_elf_howto_table[r_type]->name, sym_name);
9803
9804           bfd_set_error (bfd_error_invalid_operation);
9805           ret = FALSE;
9806           continue;
9807         }
9808
9809       /* Do any further special processing.  */
9810       switch (r_type)
9811         {
9812         default:
9813           break;
9814
9815         case R_PPC64_ADDR16_HA:
9816         case R_PPC64_ADDR16_HIGHERA:
9817         case R_PPC64_ADDR16_HIGHESTA:
9818         case R_PPC64_GOT16_HA:
9819         case R_PPC64_PLTGOT16_HA:
9820         case R_PPC64_PLT16_HA:
9821         case R_PPC64_TOC16_HA:
9822         case R_PPC64_SECTOFF_HA:
9823         case R_PPC64_TPREL16_HA:
9824         case R_PPC64_DTPREL16_HA:
9825         case R_PPC64_GOT_TLSGD16_HA:
9826         case R_PPC64_GOT_TLSLD16_HA:
9827         case R_PPC64_GOT_TPREL16_HA:
9828         case R_PPC64_GOT_DTPREL16_HA:
9829         case R_PPC64_TPREL16_HIGHER:
9830         case R_PPC64_TPREL16_HIGHERA:
9831         case R_PPC64_TPREL16_HIGHEST:
9832         case R_PPC64_TPREL16_HIGHESTA:
9833         case R_PPC64_DTPREL16_HIGHER:
9834         case R_PPC64_DTPREL16_HIGHERA:
9835         case R_PPC64_DTPREL16_HIGHEST:
9836         case R_PPC64_DTPREL16_HIGHESTA:
9837           /* It's just possible that this symbol is a weak symbol
9838              that's not actually defined anywhere. In that case,
9839              'sec' would be NULL, and we should leave the symbol
9840              alone (it will be set to zero elsewhere in the link).  */
9841           if (sec != NULL)
9842             /* Add 0x10000 if sign bit in 0:15 is set.
9843                Bits 0:15 are not used.  */
9844             addend += 0x8000;
9845           break;
9846
9847         case R_PPC64_ADDR16_DS:
9848         case R_PPC64_ADDR16_LO_DS:
9849         case R_PPC64_GOT16_DS:
9850         case R_PPC64_GOT16_LO_DS:
9851         case R_PPC64_PLT16_LO_DS:
9852         case R_PPC64_SECTOFF_DS:
9853         case R_PPC64_SECTOFF_LO_DS:
9854         case R_PPC64_TOC16_DS:
9855         case R_PPC64_TOC16_LO_DS:
9856         case R_PPC64_PLTGOT16_DS:
9857         case R_PPC64_PLTGOT16_LO_DS:
9858         case R_PPC64_GOT_TPREL16_DS:
9859         case R_PPC64_GOT_TPREL16_LO_DS:
9860         case R_PPC64_GOT_DTPREL16_DS:
9861         case R_PPC64_GOT_DTPREL16_LO_DS:
9862         case R_PPC64_TPREL16_DS:
9863         case R_PPC64_TPREL16_LO_DS:
9864         case R_PPC64_DTPREL16_DS:
9865         case R_PPC64_DTPREL16_LO_DS:
9866           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
9867           mask = 3;
9868           /* If this reloc is against an lq insn, then the value must be
9869              a multiple of 16.  This is somewhat of a hack, but the
9870              "correct" way to do this by defining _DQ forms of all the
9871              _DS relocs bloats all reloc switches in this file.  It
9872              doesn't seem to make much sense to use any of these relocs
9873              in data, so testing the insn should be safe.  */
9874           if ((insn & (0x3f << 26)) == (56u << 26))
9875             mask = 15;
9876           if (((relocation + addend) & mask) != 0)
9877             {
9878               (*_bfd_error_handler)
9879                 (_("%B: error: relocation %s not a multiple of %d"),
9880                  input_bfd,
9881                  ppc64_elf_howto_table[r_type]->name,
9882                  mask + 1);
9883               bfd_set_error (bfd_error_bad_value);
9884               ret = FALSE;
9885               continue;
9886             }
9887           break;
9888         }
9889
9890       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
9891          because such sections are not SEC_ALLOC and thus ld.so will
9892          not process them.  */
9893       if (unresolved_reloc
9894           && !((input_section->flags & SEC_DEBUGGING) != 0
9895                && h->elf.def_dynamic))
9896         {
9897           (*_bfd_error_handler)
9898             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
9899              input_bfd,
9900              input_section,
9901              (long) rel->r_offset,
9902              ppc64_elf_howto_table[(int) r_type]->name,
9903              h->elf.root.root.string);
9904           ret = FALSE;
9905         }
9906
9907       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
9908                                     input_bfd,
9909                                     input_section,
9910                                     contents,
9911                                     rel->r_offset,
9912                                     relocation,
9913                                     addend);
9914
9915       if (r != bfd_reloc_ok)
9916         {
9917           if (sym_name == NULL)
9918             sym_name = "(null)";
9919           if (r == bfd_reloc_overflow)
9920             {
9921               if (warned)
9922                 continue;
9923               if (h != NULL
9924                   && h->elf.root.type == bfd_link_hash_undefweak
9925                   && ppc64_elf_howto_table[r_type]->pc_relative)
9926                 {
9927                   /* Assume this is a call protected by other code that
9928                      detects the symbol is undefined.  If this is the case,
9929                      we can safely ignore the overflow.  If not, the
9930                      program is hosed anyway, and a little warning isn't
9931                      going to help.  */
9932
9933                   continue;
9934                 }
9935
9936               if (!((*info->callbacks->reloc_overflow)
9937                     (info, sym_name, ppc64_elf_howto_table[r_type]->name,
9938                      rel->r_addend, input_bfd, input_section, rel->r_offset)))
9939                 return FALSE;
9940             }
9941           else
9942             {
9943               (*_bfd_error_handler)
9944                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
9945                  input_bfd,
9946                  input_section,
9947                  (long) rel->r_offset,
9948                  ppc64_elf_howto_table[r_type]->name,
9949                  sym_name,
9950                  (int) r);
9951               ret = FALSE;
9952             }
9953         }
9954     }
9955
9956   return ret;
9957 }
9958
9959 /* Adjust the value of any local symbols in opd sections.  */
9960
9961 static bfd_boolean
9962 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
9963                               const char *name ATTRIBUTE_UNUSED,
9964                               Elf_Internal_Sym *elfsym,
9965                               asection *input_sec,
9966                               struct elf_link_hash_entry *h)
9967 {
9968   long *opd_adjust, adjust;
9969   bfd_vma value;
9970
9971   if (h != NULL)
9972     return TRUE;
9973
9974   opd_adjust = get_opd_info (input_sec);
9975   if (opd_adjust == NULL)
9976     return TRUE;
9977
9978   value = elfsym->st_value - input_sec->output_offset;
9979   if (!info->relocatable)
9980     value -= input_sec->output_section->vma;
9981
9982   adjust = opd_adjust[value / 8];
9983   if (adjust == -1)
9984     elfsym->st_value = 0;
9985   else
9986     elfsym->st_value += adjust;
9987   return TRUE;
9988 }
9989
9990 /* Finish up dynamic symbol handling.  We set the contents of various
9991    dynamic sections here.  */
9992
9993 static bfd_boolean
9994 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
9995                                  struct bfd_link_info *info,
9996                                  struct elf_link_hash_entry *h,
9997                                  Elf_Internal_Sym *sym)
9998 {
9999   struct ppc_link_hash_table *htab;
10000   bfd *dynobj;
10001   struct plt_entry *ent;
10002   Elf_Internal_Rela rela;
10003   bfd_byte *loc;
10004
10005   htab = ppc_hash_table (info);
10006   dynobj = htab->elf.dynobj;
10007
10008   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
10009     if (ent->plt.offset != (bfd_vma) -1)
10010       {
10011         /* This symbol has an entry in the procedure linkage
10012            table.  Set it up.  */
10013
10014         if (htab->plt == NULL
10015             || htab->relplt == NULL
10016             || htab->glink == NULL)
10017           abort ();
10018
10019         /* Create a JMP_SLOT reloc to inform the dynamic linker to
10020            fill in the PLT entry.  */
10021         rela.r_offset = (htab->plt->output_section->vma
10022                          + htab->plt->output_offset
10023                          + ent->plt.offset);
10024         rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
10025         rela.r_addend = ent->addend;
10026
10027         loc = htab->relplt->contents;
10028         loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
10029                 * sizeof (Elf64_External_Rela));
10030         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
10031       }
10032
10033   if (h->needs_copy)
10034     {
10035       Elf_Internal_Rela rela;
10036       bfd_byte *loc;
10037
10038       /* This symbol needs a copy reloc.  Set it up.  */
10039
10040       if (h->dynindx == -1
10041           || (h->root.type != bfd_link_hash_defined
10042               && h->root.type != bfd_link_hash_defweak)
10043           || htab->relbss == NULL)
10044         abort ();
10045
10046       rela.r_offset = (h->root.u.def.value
10047                        + h->root.u.def.section->output_section->vma
10048                        + h->root.u.def.section->output_offset);
10049       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
10050       rela.r_addend = 0;
10051       loc = htab->relbss->contents;
10052       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
10053       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
10054     }
10055
10056   /* Mark some specially defined symbols as absolute.  */
10057   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
10058     sym->st_shndx = SHN_ABS;
10059
10060   return TRUE;
10061 }
10062
10063 /* Used to decide how to sort relocs in an optimal manner for the
10064    dynamic linker, before writing them out.  */
10065
10066 static enum elf_reloc_type_class
10067 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
10068 {
10069   enum elf_ppc64_reloc_type r_type;
10070
10071   r_type = ELF64_R_TYPE (rela->r_info);
10072   switch (r_type)
10073     {
10074     case R_PPC64_RELATIVE:
10075       return reloc_class_relative;
10076     case R_PPC64_JMP_SLOT:
10077       return reloc_class_plt;
10078     case R_PPC64_COPY:
10079       return reloc_class_copy;
10080     default:
10081       return reloc_class_normal;
10082     }
10083 }
10084
10085 /* Finish up the dynamic sections.  */
10086
10087 static bfd_boolean
10088 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
10089                                    struct bfd_link_info *info)
10090 {
10091   struct ppc_link_hash_table *htab;
10092   bfd *dynobj;
10093   asection *sdyn;
10094
10095   htab = ppc_hash_table (info);
10096   dynobj = htab->elf.dynobj;
10097   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
10098
10099   if (htab->elf.dynamic_sections_created)
10100     {
10101       Elf64_External_Dyn *dyncon, *dynconend;
10102
10103       if (sdyn == NULL || htab->got == NULL)
10104         abort ();
10105
10106       dyncon = (Elf64_External_Dyn *) sdyn->contents;
10107       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
10108       for (; dyncon < dynconend; dyncon++)
10109         {
10110           Elf_Internal_Dyn dyn;
10111           asection *s;
10112
10113           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
10114
10115           switch (dyn.d_tag)
10116             {
10117             default:
10118               continue;
10119
10120             case DT_PPC64_GLINK:
10121               s = htab->glink;
10122               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10123               /* We stupidly defined DT_PPC64_GLINK to be the start
10124                  of glink rather than the first entry point, which is
10125                  what ld.so needs, and now have a bigger stub to
10126                  support automatic multiple TOCs.  */
10127               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
10128               break;
10129
10130             case DT_PPC64_OPD:
10131               s = bfd_get_section_by_name (output_bfd, ".opd");
10132               if (s == NULL)
10133                 continue;
10134               dyn.d_un.d_ptr = s->vma;
10135               break;
10136
10137             case DT_PPC64_OPDSZ:
10138               s = bfd_get_section_by_name (output_bfd, ".opd");
10139               if (s == NULL)
10140                 continue;
10141               dyn.d_un.d_val = s->size;
10142               break;
10143
10144             case DT_PLTGOT:
10145               s = htab->plt;
10146               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10147               break;
10148
10149             case DT_JMPREL:
10150               s = htab->relplt;
10151               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10152               break;
10153
10154             case DT_PLTRELSZ:
10155               dyn.d_un.d_val = htab->relplt->size;
10156               break;
10157
10158             case DT_RELASZ:
10159               /* Don't count procedure linkage table relocs in the
10160                  overall reloc count.  */
10161               s = htab->relplt;
10162               if (s == NULL)
10163                 continue;
10164               dyn.d_un.d_val -= s->size;
10165               break;
10166
10167             case DT_RELA:
10168               /* We may not be using the standard ELF linker script.
10169                  If .rela.plt is the first .rela section, we adjust
10170                  DT_RELA to not include it.  */
10171               s = htab->relplt;
10172               if (s == NULL)
10173                 continue;
10174               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
10175                 continue;
10176               dyn.d_un.d_ptr += s->size;
10177               break;
10178             }
10179
10180           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
10181         }
10182     }
10183
10184   if (htab->got != NULL && htab->got->size != 0)
10185     {
10186       /* Fill in the first entry in the global offset table.
10187          We use it to hold the link-time TOCbase.  */
10188       bfd_put_64 (output_bfd,
10189                   elf_gp (output_bfd) + TOC_BASE_OFF,
10190                   htab->got->contents);
10191
10192       /* Set .got entry size.  */
10193       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
10194     }
10195
10196   if (htab->plt != NULL && htab->plt->size != 0)
10197     {
10198       /* Set .plt entry size.  */
10199       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
10200         = PLT_ENTRY_SIZE;
10201     }
10202
10203   /* We need to handle writing out multiple GOT sections ourselves,
10204      since we didn't add them to DYNOBJ.  We know dynobj is the first
10205      bfd.  */
10206   while ((dynobj = dynobj->link_next) != NULL)
10207     {
10208       asection *s;
10209
10210       if (!is_ppc64_elf_target (dynobj->xvec))
10211         continue;
10212
10213       s = ppc64_elf_tdata (dynobj)->got;
10214       if (s != NULL
10215           && s->size != 0
10216           && s->output_section != bfd_abs_section_ptr
10217           && !bfd_set_section_contents (output_bfd, s->output_section,
10218                                         s->contents, s->output_offset,
10219                                         s->size))
10220         return FALSE;
10221       s = ppc64_elf_tdata (dynobj)->relgot;
10222       if (s != NULL
10223           && s->size != 0
10224           && s->output_section != bfd_abs_section_ptr
10225           && !bfd_set_section_contents (output_bfd, s->output_section,
10226                                         s->contents, s->output_offset,
10227                                         s->size))
10228         return FALSE;
10229     }
10230
10231   return TRUE;
10232 }
10233
10234 #include "elf64-target.h"