bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /* This file is based on the 64-bit PowerPC ELF ABI.  It is also based
  23    on the file elf32-ppc.c.  */
  24
  25 #include "bfd.h"
  26 #include "sysdep.h"
  27 #include "bfdlink.h"
  28 #include "libbfd.h"
  29 #include "elf-bfd.h"
  30 #include "elf/ppc.h"
  31 #include "elf64-ppc.h"
  32
  33 #define USE_RELA                /* we want RELA relocations, not REL.  */
  34
  35
  36 static void ppc_howto_init
  37   PARAMS ((void));
  38 static reloc_howto_type *ppc64_elf_reloc_type_lookup
  39   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  40 static void ppc64_elf_info_to_howto
  41   PARAMS ((bfd *abfd, arelent *cache_ptr, Elf64_Internal_Rela *dst));
  42 static bfd_reloc_status_type ppc64_elf_addr16_ha_reloc
  43   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  44 static boolean ppc64_elf_set_private_flags
  45   PARAMS ((bfd *, flagword));
  46 static boolean ppc64_elf_merge_private_bfd_data
  47   PARAMS ((bfd *, bfd *));
  48 static boolean ppc64_elf_section_from_shdr
  49   PARAMS ((bfd *, Elf64_Internal_Shdr *, char *));
  50 static struct bfd_hash_entry *link_hash_newfunc
  51   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  52 static struct bfd_link_hash_table *ppc64_elf_link_hash_table_create
  53   PARAMS ((bfd *));
  54 static boolean create_linkage_sections
  55   PARAMS ((bfd *, struct bfd_link_info *));
  56 static boolean create_got_section
  57   PARAMS ((bfd *, struct bfd_link_info *));
  58 static boolean ppc64_elf_create_dynamic_sections
  59   PARAMS ((bfd *, struct bfd_link_info *));
  60 static void ppc64_elf_copy_indirect_symbol
  61   PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
  62 static boolean ppc64_elf_check_relocs
  63   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  64            const Elf_Internal_Rela *));
  65 static asection * ppc64_elf_gc_mark_hook
  66   PARAMS ((bfd *abfd, struct bfd_link_info *info, Elf_Internal_Rela *rel,
  67            struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
  68 static boolean ppc64_elf_gc_sweep_hook
  69   PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
  70            const Elf_Internal_Rela *relocs));
  71 static boolean func_desc_adjust
  72   PARAMS ((struct elf_link_hash_entry *, PTR));
  73 static boolean ppc64_elf_func_desc_adjust
  74   PARAMS ((bfd *, struct bfd_link_info *));
  75 static boolean ppc64_elf_adjust_dynamic_symbol
  76   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  77 static void ppc64_elf_hide_symbol
  78   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
  79 static boolean allocate_dynrelocs
  80   PARAMS ((struct elf_link_hash_entry *, PTR));
  81 static boolean readonly_dynrelocs
  82   PARAMS ((struct elf_link_hash_entry *, PTR));
  83 static enum elf_reloc_type_class ppc64_elf_reloc_type_class
  84   PARAMS ((const Elf_Internal_Rela *));
  85 static boolean ppc64_elf_size_dynamic_sections
  86   PARAMS ((bfd *, struct bfd_link_info *));
  87 static bfd_byte *build_plt_stub
  88   PARAMS ((bfd *, bfd_byte *, int, int));
  89 static boolean build_one_stub
  90   PARAMS ((struct elf_link_hash_entry *, PTR));
  91 static boolean ppc64_elf_fake_sections
  92   PARAMS ((bfd *, Elf64_Internal_Shdr *, asection *));
  93 static boolean ppc64_elf_relocate_section
  94   PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *,
  95            Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
  96            asection **));
  97 static boolean ppc64_elf_finish_dynamic_symbol
  98   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  99            Elf_Internal_Sym *));
 100 static boolean ppc64_elf_finish_dynamic_sections
 101   PARAMS ((bfd *, struct bfd_link_info *));
 102
 103
 104 /* Mask to set RA in memory instructions.  */
 105 #define RA_REGISTER_MASK 0x001f0000
 106
 107 /* Value to shift register by to insert RA.  */
 108 #define RA_REGISTER_SHIFT 16
 109
 110 /* The name of the dynamic interpreter.  This is put in the .interp
 111    section.  */
 112 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 113
 114 /* The size in bytes of an entry in the procedure linkage table.  */
 115 #define PLT_ENTRY_SIZE 24
 116
 117 /* The initial size of the plt reserved for the dynamic linker.  */
 118 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 119
 120 /* TOC base pointers offset from start of TOC.  */
 121 #define TOC_BASE_OFF (0x8000)
 122
 123 /* .plt call stub instructions.  */
 124 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 125 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 126 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 127 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 128 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 129                                         /* ld    %r11,xxx+16@l(%r12) */
 130 #define BCTR            0x4e800420      /* bctr                      */
 131
 132 /* The normal stub is this size.  */
 133 #define PLT_CALL_STUB_SIZE (7*4)
 134
 135 /* But sometimes the .plt entry crosses a 64k boundary, and we need
 136    to adjust the high word with this insn.  */
 137 #define ADDIS_R12_R12_1 0x3d8c0001      /* addis %r12,%r12,1    */
 138
 139 /* The .glink fixup call stub is the same as the .plt call stub, but
 140    the first instruction restores r2, and the std is omitted.  */
 141 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)    */
 142
 143 /* Always allow this much space.  */
 144 #define GLINK_CALL_STUB_SIZE (8*4)
 145
 146 /* Pad with this.  */
 147 #define NOP             0x60000000
 148
 149 /* .glink entries for the first 32k functions are two instructions. */
 150 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 151 #define B_DOT           0x48000000      /* b     .              */
 152
 153 /* After that, we need two instructions to load the index, followed by
 154    a branch.  */
 155 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 156 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 157
 158 /* Instructions to save and restore floating point regs.  */
 159 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 160 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 161 #define BLR             0x4e800020      /* blr                  */
 162
 163 /* Since .opd is an array of descriptors and each entry will end up
 164    with identical R_PPC64_RELATIVE relocs, there is really no need to
 165    propagate .opd relocs;  The dynamic linker should be taught to
 166    relocate .opd without reloc entries.  FIXME: .opd should be trimmed
 167    of unused values.  */
 168 #ifndef NO_OPD_RELOCS
 169 #define NO_OPD_RELOCS 0
 170 #endif
 171 \f
 172 /* Relocation HOWTO's.  */
 173 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC_max];
 174
 175 static reloc_howto_type ppc64_elf_howto_raw[] = {
 176   /* This reloc does nothing.  */
 177   HOWTO (R_PPC64_NONE,          /* type */
 178          0,                     /* rightshift */
 179          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 180          32,                    /* bitsize */
 181          false,                 /* pc_relative */
 182          0,                     /* bitpos */
 183          complain_overflow_bitfield, /* complain_on_overflow */
 184          bfd_elf_generic_reloc, /* special_function */
 185          "R_PPC64_NONE",        /* name */
 186          false,                 /* partial_inplace */
 187          0,                     /* src_mask */
 188          0,                     /* dst_mask */
 189          false),                /* pcrel_offset */
 190
 191   /* A standard 32 bit relocation.  */
 192   HOWTO (R_PPC64_ADDR32,        /* type */
 193          0,                     /* rightshift */
 194          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 195          32,                    /* bitsize */
 196          false,                 /* pc_relative */
 197          0,                     /* bitpos */
 198          complain_overflow_bitfield, /* complain_on_overflow */
 199          bfd_elf_generic_reloc, /* special_function */
 200          "R_PPC64_ADDR32",      /* name */
 201          false,                 /* partial_inplace */
 202          0,                     /* src_mask */
 203          0xffffffff,            /* dst_mask */
 204          false),                /* pcrel_offset */
 205
 206   /* An absolute 26 bit branch; the lower two bits must be zero.
 207      FIXME: we don't check that, we just clear them.  */
 208   HOWTO (R_PPC64_ADDR24,        /* type */
 209          0,                     /* rightshift */
 210          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 211          26,                    /* bitsize */
 212          false,                 /* pc_relative */
 213          0,                     /* bitpos */
 214          complain_overflow_bitfield, /* complain_on_overflow */
 215          bfd_elf_generic_reloc, /* special_function */
 216          "R_PPC64_ADDR24",      /* name */
 217          false,                 /* partial_inplace */
 218          0,                     /* src_mask */
 219          0x3fffffc,             /* dst_mask */
 220          false),                /* pcrel_offset */
 221
 222   /* A standard 16 bit relocation.  */
 223   HOWTO (R_PPC64_ADDR16,        /* type */
 224          0,                     /* rightshift */
 225          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 226          16,                    /* bitsize */
 227          false,                 /* pc_relative */
 228          0,                     /* bitpos */
 229          complain_overflow_bitfield, /* complain_on_overflow */
 230          bfd_elf_generic_reloc, /* special_function */
 231          "R_PPC64_ADDR16",      /* name */
 232          false,                 /* partial_inplace */
 233          0,                     /* src_mask */
 234          0xffff,                /* dst_mask */
 235          false),                /* pcrel_offset */
 236
 237   /* A 16 bit relocation without overflow.  */
 238   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 239          0,                     /* rightshift */
 240          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 241          16,                    /* bitsize */
 242          false,                 /* pc_relative */
 243          0,                     /* bitpos */
 244          complain_overflow_dont,/* complain_on_overflow */
 245          bfd_elf_generic_reloc, /* special_function */
 246          "R_PPC64_ADDR16_LO",   /* name */
 247          false,                 /* partial_inplace */
 248          0,                     /* src_mask */
 249          0xffff,                /* dst_mask */
 250          false),                /* pcrel_offset */
 251
 252   /* Bits 16-31 of an address.  */
 253   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 254          16,                    /* rightshift */
 255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 256          16,                    /* bitsize */
 257          false,                 /* pc_relative */
 258          0,                     /* bitpos */
 259          complain_overflow_dont, /* complain_on_overflow */
 260          bfd_elf_generic_reloc, /* special_function */
 261          "R_PPC64_ADDR16_HI",   /* name */
 262          false,                 /* partial_inplace */
 263          0,                     /* src_mask */
 264          0xffff,                /* dst_mask */
 265          false),                /* pcrel_offset */
 266
 267   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 268      bits, treated as a signed number, is negative.  */
 269   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 270          16,                    /* rightshift */
 271          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          16,                    /* bitsize */
 273          false,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          ppc64_elf_addr16_ha_reloc, /* special_function */
 277          "R_PPC64_ADDR16_HA",   /* name */
 278          false,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0xffff,                /* dst_mask */
 281          false),                /* pcrel_offset */
 282
 283   /* An absolute 16 bit branch; the lower two bits must be zero.
 284      FIXME: we don't check that, we just clear them.  */
 285   HOWTO (R_PPC64_ADDR14,        /* type */
 286          0,                     /* rightshift */
 287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 288          16,                    /* bitsize */
 289          false,                 /* pc_relative */
 290          0,                     /* bitpos */
 291          complain_overflow_bitfield, /* complain_on_overflow */
 292          bfd_elf_generic_reloc, /* special_function */
 293          "R_PPC64_ADDR14",      /* name */
 294          false,                 /* partial_inplace */
 295          0,                     /* src_mask */
 296          0xfffc,                /* dst_mask */
 297          false),                /* pcrel_offset */
 298
 299   /* An absolute 16 bit branch, for which bit 10 should be set to
 300      indicate that the branch is expected to be taken.  The lower two
 301      bits must be zero.  */
 302   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 303          0,                     /* rightshift */
 304          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 305          16,                    /* bitsize */
 306          false,                 /* pc_relative */
 307          0,                     /* bitpos */
 308          complain_overflow_bitfield, /* complain_on_overflow */
 309          bfd_elf_generic_reloc, /* special_function */
 310          "R_PPC64_ADDR14_BRTAKEN",/* name */
 311          false,                 /* partial_inplace */
 312          0,                     /* src_mask */
 313          0xfffc,                /* dst_mask */
 314          false),                /* pcrel_offset */
 315
 316   /* An absolute 16 bit branch, for which bit 10 should be set to
 317      indicate that the branch is not expected to be taken.  The lower
 318      two bits must be zero.  */
 319   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 320          0,                     /* rightshift */
 321          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 322          16,                    /* bitsize */
 323          false,                 /* pc_relative */
 324          0,                     /* bitpos */
 325          complain_overflow_bitfield, /* complain_on_overflow */
 326          bfd_elf_generic_reloc, /* special_function */
 327          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 328          false,                 /* partial_inplace */
 329          0,                     /* src_mask */
 330          0xfffc,                /* dst_mask */
 331          false),                /* pcrel_offset */
 332
 333   /* A relative 26 bit branch; the lower two bits must be zero.  */
 334   HOWTO (R_PPC64_REL24,         /* type */
 335          0,                     /* rightshift */
 336          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 337          26,                    /* bitsize */
 338          true,                  /* pc_relative */
 339          0,                     /* bitpos */
 340          complain_overflow_signed, /* complain_on_overflow */
 341          bfd_elf_generic_reloc, /* special_function */
 342          "R_PPC64_REL24",       /* name */
 343          false,                 /* partial_inplace */
 344          0,                     /* src_mask */
 345          0x3fffffc,             /* dst_mask */
 346          true),                 /* pcrel_offset */
 347
 348   /* A relative 16 bit branch; the lower two bits must be zero.  */
 349   HOWTO (R_PPC64_REL14,         /* type */
 350          0,                     /* rightshift */
 351          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 352          16,                    /* bitsize */
 353          true,                  /* pc_relative */
 354          0,                     /* bitpos */
 355          complain_overflow_signed, /* complain_on_overflow */
 356          bfd_elf_generic_reloc, /* special_function */
 357          "R_PPC64_REL14",       /* name */
 358          false,                 /* partial_inplace */
 359          0,                     /* src_mask */
 360          0xfffc,                /* dst_mask */
 361          true),                 /* pcrel_offset */
 362
 363   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 364      the branch is expected to be taken.  The lower two bits must be
 365      zero.  */
 366   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 367          0,                     /* rightshift */
 368          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          16,                    /* bitsize */
 370          true,                  /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_signed, /* complain_on_overflow */
 373          bfd_elf_generic_reloc, /* special_function */
 374          "R_PPC64_REL14_BRTAKEN", /* name */
 375          false,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xfffc,                /* dst_mask */
 378          true),                 /* pcrel_offset */
 379
 380   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 381      the branch is not expected to be taken.  The lower two bits must
 382      be zero.  */
 383   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 384          0,                     /* rightshift */
 385          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 386          16,                    /* bitsize */
 387          true,                  /* pc_relative */
 388          0,                     /* bitpos */
 389          complain_overflow_signed, /* complain_on_overflow */
 390          bfd_elf_generic_reloc, /* special_function */
 391          "R_PPC64_REL14_BRNTAKEN",/* name */
 392          false,                 /* partial_inplace */
 393          0,                     /* src_mask */
 394          0xfffc,                /* dst_mask */
 395          true),                 /* pcrel_offset */
 396
 397   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 398      symbol.  */
 399   HOWTO (R_PPC64_GOT16,         /* type */
 400          0,                     /* rightshift */
 401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 402          16,                    /* bitsize */
 403          false,                 /* pc_relative */
 404          0,                     /* bitpos */
 405          complain_overflow_signed, /* complain_on_overflow */
 406          bfd_elf_generic_reloc, /* special_function */
 407          "R_PPC64_GOT16",       /* name */
 408          false,                 /* partial_inplace */
 409          0,                     /* src_mask */
 410          0xffff,                /* dst_mask */
 411          false),                /* pcrel_offset */
 412
 413   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 414      the symbol.  */
 415   HOWTO (R_PPC64_GOT16_LO,      /* type */
 416          0,                     /* rightshift */
 417          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 418          16,                    /* bitsize */
 419          false,                 /* pc_relative */
 420          0,                     /* bitpos */
 421          complain_overflow_dont, /* complain_on_overflow */
 422          bfd_elf_generic_reloc, /* special_function */
 423          "R_PPC64_GOT16_LO",    /* name */
 424          false,                 /* partial_inplace */
 425          0,                     /* src_mask */
 426          0xffff,                /* dst_mask */
 427          false),                /* pcrel_offset */
 428
 429   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 430      the symbol.  */
 431   HOWTO (R_PPC64_GOT16_HI,      /* type */
 432          16,                    /* rightshift */
 433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          16,                    /* bitsize */
 435          false,                 /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_dont,/* complain_on_overflow */
 438          bfd_elf_generic_reloc, /* special_function */
 439          "R_PPC64_GOT16_HI",    /* name */
 440          false,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0xffff,                /* dst_mask */
 443          false),                /* pcrel_offset */
 444
 445   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 446      the symbol.  */
 447   HOWTO (R_PPC64_GOT16_HA,      /* type */
 448          16,                    /* rightshift */
 449          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 450          16,                    /* bitsize */
 451          false,                 /* pc_relative */
 452          0,                     /* bitpos */
 453          complain_overflow_dont,/* complain_on_overflow */
 454          ppc64_elf_addr16_ha_reloc, /* special_function */
 455          "R_PPC64_GOT16_HA",    /* name */
 456          false,                 /* partial_inplace */
 457          0,                     /* src_mask */
 458          0xffff,                /* dst_mask */
 459          false),                /* pcrel_offset */
 460
 461   /* This is used only by the dynamic linker.  The symbol should exist
 462      both in the object being run and in some shared library.  The
 463      dynamic linker copies the data addressed by the symbol from the
 464      shared library into the object, because the object being
 465      run has to have the data at some particular address.  */
 466   HOWTO (R_PPC64_COPY,          /* type */
 467          0,                     /* rightshift */
 468          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 469          32,                    /* bitsize */
 470          false,                 /* pc_relative */
 471          0,                     /* bitpos */
 472          complain_overflow_bitfield, /* complain_on_overflow */
 473          bfd_elf_generic_reloc,  /* special_function */
 474          "R_PPC64_COPY",        /* name */
 475          false,                 /* partial_inplace */
 476          0,                     /* src_mask */
 477          0,                     /* dst_mask */
 478          false),                /* pcrel_offset */
 479
 480   /* Like R_PPC64_ADDR64, but used when setting global offset table
 481      entries.  */
 482   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 483          0,                     /* rightshift */
 484          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 485          64,                    /* bitsize */
 486          false,                 /* pc_relative */
 487          0,                     /* bitpos */
 488          complain_overflow_dont, /* complain_on_overflow */
 489          bfd_elf_generic_reloc,  /* special_function */
 490          "R_PPC64_GLOB_DAT",    /* name */
 491          false,                 /* partial_inplace */
 492          0,                     /* src_mask */
 493          0xffffffffffffffff,    /* dst_mask */
 494          false),                /* pcrel_offset */
 495
 496   /* Created by the link editor.  Marks a procedure linkage table
 497      entry for a symbol.  */
 498   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 499          0,                     /* rightshift */
 500          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 501          0,                     /* bitsize */
 502          false,                 /* pc_relative */
 503          0,                     /* bitpos */
 504          complain_overflow_dont, /* complain_on_overflow */
 505          bfd_elf_generic_reloc, /* special_function */
 506          "R_PPC64_JMP_SLOT",    /* name */
 507          false,                 /* partial_inplace */
 508          0,                     /* src_mask */
 509          0,                     /* dst_mask */
 510          false),                /* pcrel_offset */
 511
 512   /* Used only by the dynamic linker.  When the object is run, this
 513      doubleword64 is set to the load address of the object, plus the
 514      addend.  */
 515   HOWTO (R_PPC64_RELATIVE,      /* type */
 516          0,                     /* rightshift */
 517          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 518          64,                    /* bitsize */
 519          false,                 /* pc_relative */
 520          0,                     /* bitpos */
 521          complain_overflow_dont, /* complain_on_overflow */
 522          bfd_elf_generic_reloc, /* special_function */
 523          "R_PPC64_RELATIVE",    /* name */
 524          false,                 /* partial_inplace */
 525          0,                     /* src_mask */
 526          0xffffffffffffffff,    /* dst_mask */
 527          false),                /* pcrel_offset */
 528
 529   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 530   HOWTO (R_PPC64_UADDR32,       /* type */
 531          0,                     /* rightshift */
 532          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 533          32,                    /* bitsize */
 534          false,                 /* pc_relative */
 535          0,                     /* bitpos */
 536          complain_overflow_bitfield, /* complain_on_overflow */
 537          bfd_elf_generic_reloc, /* special_function */
 538          "R_PPC64_UADDR32",     /* name */
 539          false,                 /* partial_inplace */
 540          0,                     /* src_mask */
 541          0xffffffff,            /* dst_mask */
 542          false),                /* pcrel_offset */
 543
 544   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 545   HOWTO (R_PPC64_UADDR16,       /* type */
 546          0,                     /* rightshift */
 547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 548          16,                    /* bitsize */
 549          false,                 /* pc_relative */
 550          0,                     /* bitpos */
 551          complain_overflow_bitfield, /* complain_on_overflow */
 552          bfd_elf_generic_reloc, /* special_function */
 553          "R_PPC64_UADDR16",     /* name */
 554          false,                 /* partial_inplace */
 555          0,                     /* src_mask */
 556          0xffff,                /* dst_mask */
 557          false),                /* pcrel_offset */
 558
 559   /* 32-bit PC relative.  */
 560   HOWTO (R_PPC64_REL32,         /* type */
 561          0,                     /* rightshift */
 562          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 563          32,                    /* bitsize */
 564          true,                  /* pc_relative */
 565          0,                     /* bitpos */
 566          /* FIXME: Verify.  Was complain_overflow_bitfield. */
 567          complain_overflow_signed, /* complain_on_overflow */
 568          bfd_elf_generic_reloc, /* special_function */
 569          "R_PPC64_REL32",       /* name */
 570          false,                 /* partial_inplace */
 571          0,                     /* src_mask */
 572          0xffffffff,            /* dst_mask */
 573          true),                 /* pcrel_offset */
 574
 575   /* 32-bit relocation to the symbol's procedure linkage table.  */
 576   HOWTO (R_PPC64_PLT32,         /* type */
 577          0,                     /* rightshift */
 578          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 579          32,                    /* bitsize */
 580          false,                 /* pc_relative */
 581          0,                     /* bitpos */
 582          complain_overflow_bitfield, /* complain_on_overflow */
 583          bfd_elf_generic_reloc, /* special_function */
 584          "R_PPC64_PLT32",       /* name */
 585          false,                 /* partial_inplace */
 586          0,                     /* src_mask */
 587          0,                     /* dst_mask */
 588          false),                /* pcrel_offset */
 589
 590   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 591      FIXME: R_PPC64_PLTREL32 not supported.  */
 592   HOWTO (R_PPC64_PLTREL32,      /* type */
 593          0,                     /* rightshift */
 594          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 595          32,                    /* bitsize */
 596          true,                  /* pc_relative */
 597          0,                     /* bitpos */
 598          complain_overflow_signed, /* complain_on_overflow */
 599          bfd_elf_generic_reloc, /* special_function */
 600          "R_PPC64_PLTREL32",    /* name */
 601          false,                 /* partial_inplace */
 602          0,                     /* src_mask */
 603          0,                     /* dst_mask */
 604          true),                 /* pcrel_offset */
 605
 606   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 607      the symbol.  */
 608   HOWTO (R_PPC64_PLT16_LO,      /* type */
 609          0,                     /* rightshift */
 610          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 611          16,                    /* bitsize */
 612          false,                 /* pc_relative */
 613          0,                     /* bitpos */
 614          complain_overflow_dont, /* complain_on_overflow */
 615          bfd_elf_generic_reloc, /* special_function */
 616          "R_PPC64_PLT16_LO",    /* name */
 617          false,                 /* partial_inplace */
 618          0,                     /* src_mask */
 619          0xffff,                /* dst_mask */
 620          false),                /* pcrel_offset */
 621
 622   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 623      the symbol.  */
 624   HOWTO (R_PPC64_PLT16_HI,      /* type */
 625          16,                    /* rightshift */
 626          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 627          16,                    /* bitsize */
 628          false,                 /* pc_relative */
 629          0,                     /* bitpos */
 630          complain_overflow_dont, /* complain_on_overflow */
 631          bfd_elf_generic_reloc, /* special_function */
 632          "R_PPC64_PLT16_HI",    /* name */
 633          false,                 /* partial_inplace */
 634          0,                     /* src_mask */
 635          0xffff,                /* dst_mask */
 636          false),                /* pcrel_offset */
 637
 638   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 639      the symbol.  */
 640   HOWTO (R_PPC64_PLT16_HA,      /* type */
 641          16,                    /* rightshift */
 642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 643          16,                    /* bitsize */
 644          false,                 /* pc_relative */
 645          0,                     /* bitpos */
 646          complain_overflow_dont, /* complain_on_overflow */
 647          ppc64_elf_addr16_ha_reloc, /* special_function */
 648          "R_PPC64_PLT16_HA",    /* name */
 649          false,                 /* partial_inplace */
 650          0,                     /* src_mask */
 651          0xffff,                /* dst_mask */
 652          false),                /* pcrel_offset */
 653
 654   /* 32-bit section relative relocation.  */
 655   /* FIXME: Verify R_PPC64_SECTOFF.  Seems strange with size=2 and
 656      dst_mask=0.  */
 657   HOWTO (R_PPC64_SECTOFF,       /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          true,                  /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_bitfield, /* complain_on_overflow */
 664          bfd_elf_generic_reloc, /* special_function */
 665          "R_PPC64_SECTOFF",     /* name */
 666          false,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0,                     /* dst_mask */
 669          true),                 /* pcrel_offset */
 670
 671   /* 16-bit lower half section relative relocation.  */
 672   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 673          0,                     /* rightshift */
 674          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          16,                    /* bitsize */
 676          false,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_dont, /* complain_on_overflow */
 679          bfd_elf_generic_reloc, /* special_function */
 680          "R_PPC64_SECTOFF_LO",  /* name */
 681          false,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffff,                /* dst_mask */
 684          false),                /* pcrel_offset */
 685
 686   /* 16-bit upper half section relative relocation.  */
 687   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 688          16,                    /* rightshift */
 689          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 690          16,                    /* bitsize */
 691          false,                 /* pc_relative */
 692          0,                     /* bitpos */
 693          complain_overflow_dont, /* complain_on_overflow */
 694          bfd_elf_generic_reloc, /* special_function */
 695          "R_PPC64_SECTOFF_HI",  /* name */
 696          false,                 /* partial_inplace */
 697          0,                     /* src_mask */
 698          0xffff,                /* dst_mask */
 699          false),                /* pcrel_offset */
 700
 701   /* 16-bit upper half adjusted section relative relocation.  */
 702   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 703          16,                    /* rightshift */
 704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 705          16,                    /* bitsize */
 706          false,                 /* pc_relative */
 707          0,                     /* bitpos */
 708          complain_overflow_dont, /* complain_on_overflow */
 709          ppc64_elf_addr16_ha_reloc, /* special_function */
 710          "R_PPC64_SECTOFF_HA",  /* name */
 711          false,                 /* partial_inplace */
 712          0,                     /* src_mask */
 713          0xffff,                /* dst_mask */
 714          false),                /* pcrel_offset */
 715
 716   /* Like R_PPC64_REL24 without touching the two least significant
 717      bits.  */
 718   /* FIXME: Verify R_PPC64_ADDR30.  */
 719   HOWTO (R_PPC64_ADDR30,        /* type */
 720          2,                     /* rightshift */
 721          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 722          30,                    /* bitsize */
 723          true,                  /* pc_relative */
 724          0,                     /* bitpos */
 725          complain_overflow_dont, /* complain_on_overflow */
 726          bfd_elf_generic_reloc, /* special_function */
 727          "R_PPC64_ADDR30",      /* name */
 728          false,                 /* partial_inplace */
 729          0,                     /* src_mask */
 730          0xfffffffc,            /* dst_mask */
 731          true),                 /* pcrel_offset */
 732
 733   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 734
 735   /* A standard 64-bit relocation.  */
 736   HOWTO (R_PPC64_ADDR64,        /* type */
 737          0,                     /* rightshift */
 738          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 739          64,                    /* bitsize */
 740          false,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_dont, /* complain_on_overflow */
 743          bfd_elf_generic_reloc, /* special_function */
 744          "R_PPC64_ADDR64",      /* name */
 745          false,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffffffffffffffff,    /* dst_mask */
 748          false),                /* pcrel_offset */
 749
 750   /* The bits 32-47 of an address.  */
 751   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 752          32,                    /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          false,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_dont, /* complain_on_overflow */
 758          bfd_elf_generic_reloc, /* special_function */
 759          "R_PPC64_ADDR16_HIGHER", /* name */
 760          false,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          false),                /* pcrel_offset */
 764
 765   /* The bits 32-47 of an address, plus 1 if the contents of the low
 766      16 bits, treated as a signed number, is negative.  */
 767   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 768          32,                    /* rightshift */
 769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 770          16,                    /* bitsize */
 771          false,                 /* pc_relative */
 772          0,                     /* bitpos */
 773          complain_overflow_dont, /* complain_on_overflow */
 774          ppc64_elf_addr16_ha_reloc, /* special_function */
 775          "R_PPC64_ADDR16_HIGHERA", /* name */
 776          false,                 /* partial_inplace */
 777          0,                     /* src_mask */
 778          0xffff,                /* dst_mask */
 779          false),                /* pcrel_offset */
 780
 781   /* The bits 48-63 of an address.  */
 782   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 783          48,                    /* rightshift */
 784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 785          16,                    /* bitsize */
 786          false,                 /* pc_relative */
 787          0,                     /* bitpos */
 788          complain_overflow_dont, /* complain_on_overflow */
 789          bfd_elf_generic_reloc, /* special_function */
 790          "R_PPC64_ADDR16_HIGHEST", /* name */
 791          false,                 /* partial_inplace */
 792          0,                     /* src_mask */
 793          0xffff,                /* dst_mask */
 794          false),                /* pcrel_offset */
 795
 796   /* The bits 48-63 of an address, plus 1 if the contents of the low
 797      16 bits, treated as a signed number, is negative.  */
 798   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 799          48,                    /* rightshift */
 800          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 801          16,                    /* bitsize */
 802          false,                 /* pc_relative */
 803          0,                     /* bitpos */
 804          complain_overflow_dont, /* complain_on_overflow */
 805          ppc64_elf_addr16_ha_reloc, /* special_function */
 806          "R_PPC64_ADDR16_HIGHESTA", /* name */
 807          false,                 /* partial_inplace */
 808          0,                     /* src_mask */
 809          0xffff,                /* dst_mask */
 810          false),                /* pcrel_offset */
 811
 812   /* Like ADDR64, but may be unaligned.  */
 813   HOWTO (R_PPC64_UADDR64,       /* type */
 814          0,                     /* rightshift */
 815          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 816          64,                    /* bitsize */
 817          false,                 /* pc_relative */
 818          0,                     /* bitpos */
 819          complain_overflow_dont, /* complain_on_overflow */
 820          bfd_elf_generic_reloc, /* special_function */
 821          "R_PPC64_UADDR64",     /* name */
 822          false,                 /* partial_inplace */
 823          0,                     /* src_mask */
 824          0xffffffffffffffff,    /* dst_mask */
 825          false),                /* pcrel_offset */
 826
 827   /* 64-bit relative relocation.  */
 828   HOWTO (R_PPC64_REL64,         /* type */
 829          0,                     /* rightshift */
 830          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 831          64,                    /* bitsize */
 832          true,                  /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_REL64",       /* name */
 837          false,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          0xffffffffffffffff,    /* dst_mask */
 840          true),                 /* pcrel_offset */
 841
 842   /* 64-bit relocation to the symbol's procedure linkage table. */
 843   HOWTO (R_PPC64_PLT64,         /* type */
 844          0,                     /* rightshift */
 845          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 846          64,                    /* bitsize */
 847          false,                 /* pc_relative */
 848          0,                     /* bitpos */
 849          complain_overflow_dont, /* complain_on_overflow */
 850          bfd_elf_generic_reloc, /* special_function */
 851          "R_PPC64_PLT64",       /* name */
 852          false,                 /* partial_inplace */
 853          0,                     /* src_mask */
 854          0,                     /* dst_mask */
 855          false),                /* pcrel_offset */
 856
 857   /* 64-bit PC relative relocation to the symbol's procedure linkage
 858      table.  */
 859   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 860   HOWTO (R_PPC64_PLTREL64,      /* type */
 861          0,                     /* rightshift */
 862          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 863          64,                    /* bitsize */
 864          true,                  /* pc_relative */
 865          0,                     /* bitpos */
 866          complain_overflow_dont, /* complain_on_overflow */
 867          bfd_elf_generic_reloc, /* special_function */
 868          "R_PPC64_PLTREL64",    /* name */
 869          false,                 /* partial_inplace */
 870          0,                     /* src_mask */
 871          0,                     /* dst_mask */
 872          true),                 /* pcrel_offset */
 873
 874   /* 16 bit TOC-relative relocation.  */
 875
 876   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 877   HOWTO (R_PPC64_TOC16,         /* type */
 878          0,                     /* rightshift */
 879          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 880          16,                    /* bitsize */
 881          false,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_signed, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC64_TOC16",       /* name */
 886          false,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          0xffff,                /* dst_mask */
 889          false),                /* pcrel_offset */
 890
 891   /* 16 bit TOC-relative relocation without overflow.  */
 892
 893   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 894   HOWTO (R_PPC64_TOC16_LO,      /* type */
 895          0,                     /* rightshift */
 896          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 897          16,                    /* bitsize */
 898          false,                 /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          bfd_elf_generic_reloc, /* special_function */
 902          "R_PPC64_TOC16_LO",    /* name */
 903          false,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          0xffff,                /* dst_mask */
 906          false),                /* pcrel_offset */
 907
 908   /* 16 bit TOC-relative relocation, high 16 bits.  */
 909
 910   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 911   HOWTO (R_PPC64_TOC16_HI,      /* type */
 912          16,                    /* rightshift */
 913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 914          16,                    /* bitsize */
 915          false,                 /* pc_relative */
 916          0,                     /* bitpos */
 917          complain_overflow_dont, /* complain_on_overflow */
 918          bfd_elf_generic_reloc, /* special_function */
 919          "R_PPC64_TOC16_HI",    /* name */
 920          false,                 /* partial_inplace */
 921          0,                     /* src_mask */
 922          0xffff,                /* dst_mask */
 923          false),                /* pcrel_offset */
 924
 925   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 926      contents of the low 16 bits, treated as a signed number, is
 927      negative.  */
 928
 929   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 930   HOWTO (R_PPC64_TOC16_HA,      /* type */
 931          16,                    /* rightshift */
 932          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 933          16,                    /* bitsize */
 934          false,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_addr16_ha_reloc, /* special_function */
 938          "R_PPC64_TOC16_HA",    /* name */
 939          false,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          0xffff,                /* dst_mask */
 942          false),                /* pcrel_offset */
 943
 944   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 945
 946   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 947   HOWTO (R_PPC64_TOC,           /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          false,                 /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_bitfield, /* complain_on_overflow */
 954          bfd_elf_generic_reloc, /* special_function */
 955          "R_PPC64_TOC",         /* name */
 956          false,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          0xffffffffffffffff,    /* dst_mask */
 959          false),                /* pcrel_offset */
 960
 961   /* Like R_PPC64_GOT16, but also informs the link editor that the
 962      value to relocate may (!) refer to a PLT entry which the link
 963      editor (a) may replace with the symbol value.  If the link editor
 964      is unable to fully resolve the symbol, it may (b) create a PLT
 965      entry and store the address to the new PLT entry in the GOT.
 966      This permits lazy resolution of function symbols at run time.
 967      The link editor may also skip all of this and just (c) emit a
 968      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
 969   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
 970     HOWTO (R_PPC64_PLTGOT16,    /* type */
 971          0,                     /* rightshift */
 972          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 973          16,                    /* bitsize */
 974          false,                 /* pc_relative */
 975          0,                     /* bitpos */
 976          complain_overflow_signed, /* complain_on_overflow */
 977          bfd_elf_generic_reloc, /* special_function */
 978          "R_PPC64_PLTGOT16",    /* name */
 979          false,                 /* partial_inplace */
 980          0,                     /* src_mask */
 981          0xffff,                /* dst_mask */
 982          false),                /* pcrel_offset */
 983
 984   /* Like R_PPC64_PLTGOT16, but without overflow.  */
 985   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
 986   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
 987          0,                     /* rightshift */
 988          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 989          16,                    /* bitsize */
 990          false,                 /* pc_relative */
 991          0,                     /* bitpos */
 992          complain_overflow_dont, /* complain_on_overflow */
 993          bfd_elf_generic_reloc, /* special_function */
 994          "R_PPC64_PLTGOT16_LO", /* name */
 995          false,                 /* partial_inplace */
 996          0,                     /* src_mask */
 997          0xffff,                /* dst_mask */
 998          false),                /* pcrel_offset */
 999
1000   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1001   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1002   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1003          16,                    /* rightshift */
1004          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1005          16,                    /* bitsize */
1006          false,                 /* pc_relative */
1007          0,                     /* bitpos */
1008          complain_overflow_dont, /* complain_on_overflow */
1009          bfd_elf_generic_reloc, /* special_function */
1010          "R_PPC64_PLTGOT16_HI", /* name */
1011          false,                 /* partial_inplace */
1012          0,                     /* src_mask */
1013          0xffff,                /* dst_mask */
1014          false),                /* pcrel_offset */
1015
1016   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1017      1 if the contents of the low 16 bits, treated as a signed number,
1018      is negative.  */
1019   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1020   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1021          16,                    /* rightshift */
1022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1023          16,                    /* bitsize */
1024          false,                 /* pc_relative */
1025          0,                     /* bitpos */
1026          complain_overflow_dont,/* complain_on_overflow */
1027          ppc64_elf_addr16_ha_reloc, /* special_function */
1028          "R_PPC64_PLTGOT16_HA", /* name */
1029          false,                 /* partial_inplace */
1030          0,                     /* src_mask */
1031          0xffff,                /* dst_mask */
1032          false),                /* pcrel_offset */
1033
1034   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1035   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1036          0,                     /* rightshift */
1037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1038          16,                    /* bitsize */
1039          false,                 /* pc_relative */
1040          0,                     /* bitpos */
1041          complain_overflow_bitfield, /* complain_on_overflow */
1042          bfd_elf_generic_reloc, /* special_function */
1043          "R_PPC64_ADDR16_DS",   /* name */
1044          false,                 /* partial_inplace */
1045          0,                     /* src_mask */
1046          0xfffc,                /* dst_mask */
1047          false),                /* pcrel_offset */
1048
1049   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1050   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1051          0,                     /* rightshift */
1052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1053          16,                    /* bitsize */
1054          false,                 /* pc_relative */
1055          0,                     /* bitpos */
1056          complain_overflow_dont,/* complain_on_overflow */
1057          bfd_elf_generic_reloc, /* special_function */
1058          "R_PPC64_ADDR16_LO_DS",/* name */
1059          false,                 /* partial_inplace */
1060          0,                     /* src_mask */
1061          0xfffc,                /* dst_mask */
1062          false),                /* pcrel_offset */
1063
1064   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1065   HOWTO (R_PPC64_GOT16_DS,      /* type */
1066          0,                     /* rightshift */
1067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1068          16,                    /* bitsize */
1069          false,                 /* pc_relative */
1070          0,                     /* bitpos */
1071          complain_overflow_signed, /* complain_on_overflow */
1072          bfd_elf_generic_reloc, /* special_function */
1073          "R_PPC64_GOT16_DS",    /* name */
1074          false,                 /* partial_inplace */
1075          0,                     /* src_mask */
1076          0xfffc,                /* dst_mask */
1077          false),                /* pcrel_offset */
1078
1079   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1080   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1081          0,                     /* rightshift */
1082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1083          16,                    /* bitsize */
1084          false,                 /* pc_relative */
1085          0,                     /* bitpos */
1086          complain_overflow_dont, /* complain_on_overflow */
1087          bfd_elf_generic_reloc, /* special_function */
1088          "R_PPC64_GOT16_LO_DS", /* name */
1089          false,                 /* partial_inplace */
1090          0,                     /* src_mask */
1091          0xfffc,                /* dst_mask */
1092          false),                /* pcrel_offset */
1093
1094   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1095   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1096          0,                     /* rightshift */
1097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1098          16,                    /* bitsize */
1099          false,                 /* pc_relative */
1100          0,                     /* bitpos */
1101          complain_overflow_dont, /* complain_on_overflow */
1102          bfd_elf_generic_reloc, /* special_function */
1103          "R_PPC64_PLT16_LO_DS", /* name */
1104          false,                 /* partial_inplace */
1105          0,                     /* src_mask */
1106          0xfffc,                /* dst_mask */
1107          false),                /* pcrel_offset */
1108
1109   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1110   /* FIXME: Verify R_PPC64_SECTOFF.  Seems strange with size=2 and
1111      dst_mask=0.  */
1112   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1113          0,                     /* rightshift */
1114          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          32,                    /* bitsize */
1116          true,                  /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_bitfield, /* complain_on_overflow */
1119          bfd_elf_generic_reloc, /* special_function */
1120          "R_PPC64_SECTOFF_DS",  /* name */
1121          false,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0,                     /* dst_mask */
1124          true),                 /* pcrel_offset */
1125
1126   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          false,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_dont, /* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_SECTOFF_LO_DS",/* name */
1136          false,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          false),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_TOC16_DS,      /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          false,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_signed, /* complain_on_overflow */
1149          bfd_elf_generic_reloc, /* special_function */
1150          "R_PPC64_TOC16_DS",    /* name */
1151          false,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          false),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          false,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_dont, /* complain_on_overflow */
1164          bfd_elf_generic_reloc, /* special_function */
1165          "R_PPC64_TOC16_LO_DS", /* name */
1166          false,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          false),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1172   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1173     HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1174          0,                     /* rightshift */
1175          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1176          16,                    /* bitsize */
1177          false,                 /* pc_relative */
1178          0,                     /* bitpos */
1179          complain_overflow_signed, /* complain_on_overflow */
1180          bfd_elf_generic_reloc, /* special_function */
1181          "R_PPC64_PLTGOT16_DS", /* name */
1182          false,                 /* partial_inplace */
1183          0,                     /* src_mask */
1184          0xfffc,                /* dst_mask */
1185          false),                /* pcrel_offset */
1186
1187   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1188   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1189   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          false,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_dont, /* complain_on_overflow */
1196          bfd_elf_generic_reloc, /* special_function */
1197          "R_PPC64_PLTGOT16_LO_DS",/* name */
1198          false,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          false),                /* pcrel_offset */
1202
1203   /* GNU extension to record C++ vtable hierarchy.  */
1204   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1205          0,                     /* rightshift */
1206          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          0,                     /* bitsize */
1208          false,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_dont, /* complain_on_overflow */
1211          NULL,                  /* special_function */
1212          "R_PPC64_GNU_VTINHERIT", /* name */
1213          false,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0,                     /* dst_mask */
1216          false),                /* pcrel_offset */
1217
1218   /* GNU extension to record C++ vtable member usage.  */
1219   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1220          0,                     /* rightshift */
1221          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1222          0,                     /* bitsize */
1223          false,                 /* pc_relative */
1224          0,                     /* bitpos */
1225          complain_overflow_dont, /* complain_on_overflow */
1226          NULL,                  /* special_function */
1227          "R_PPC64_GNU_VTENTRY", /* name */
1228          false,                 /* partial_inplace */
1229          0,                     /* src_mask */
1230          0,                     /* dst_mask */
1231          false),                /* pcrel_offset */
1232 };
1233
1234 \f
1235 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1236    be done.  */
1237
1238 static void
1239 ppc_howto_init ()
1240 {
1241   unsigned int i, type;
1242
1243   for (i = 0;
1244        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1245        i++)
1246     {
1247       type = ppc64_elf_howto_raw[i].type;
1248       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1249                           / sizeof (ppc64_elf_howto_table[0])));
1250       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1251     }
1252 }
1253
1254 static reloc_howto_type *
1255 ppc64_elf_reloc_type_lookup (abfd, code)
1256      bfd *abfd ATTRIBUTE_UNUSED;
1257      bfd_reloc_code_real_type code;
1258 {
1259   enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE;
1260
1261   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1262     /* Initialize howto table if needed.  */
1263     ppc_howto_init ();
1264
1265   switch ((int) code)
1266     {
1267     default:
1268       return (reloc_howto_type *) NULL;
1269
1270     case BFD_RELOC_NONE:                 ppc_reloc = R_PPC64_NONE;
1271       break;
1272     case BFD_RELOC_32:                   ppc_reloc = R_PPC64_ADDR32;
1273       break;
1274     case BFD_RELOC_PPC_BA26:             ppc_reloc = R_PPC64_ADDR24;
1275       break;
1276     case BFD_RELOC_16:                   ppc_reloc = R_PPC64_ADDR16;
1277       break;
1278     case BFD_RELOC_LO16:                 ppc_reloc = R_PPC64_ADDR16_LO;
1279       break;
1280     case BFD_RELOC_HI16:                 ppc_reloc = R_PPC64_ADDR16_HI;
1281       break;
1282     case BFD_RELOC_HI16_S:               ppc_reloc = R_PPC64_ADDR16_HA;
1283       break;
1284     case BFD_RELOC_PPC_BA16:             ppc_reloc = R_PPC64_ADDR14;
1285       break;
1286     case BFD_RELOC_PPC_BA16_BRTAKEN:     ppc_reloc = R_PPC64_ADDR14_BRTAKEN;
1287       break;
1288     case BFD_RELOC_PPC_BA16_BRNTAKEN:    ppc_reloc = R_PPC64_ADDR14_BRNTAKEN;
1289       break;
1290     case BFD_RELOC_PPC_B26:              ppc_reloc = R_PPC64_REL24;
1291       break;
1292     case BFD_RELOC_PPC_B16:              ppc_reloc = R_PPC64_REL14;
1293       break;
1294     case BFD_RELOC_PPC_B16_BRTAKEN:      ppc_reloc = R_PPC64_REL14_BRTAKEN;
1295       break;
1296     case BFD_RELOC_PPC_B16_BRNTAKEN:     ppc_reloc = R_PPC64_REL14_BRNTAKEN;
1297       break;
1298     case BFD_RELOC_16_GOTOFF:            ppc_reloc = R_PPC64_GOT16;
1299       break;
1300     case BFD_RELOC_LO16_GOTOFF:          ppc_reloc = R_PPC64_GOT16_LO;
1301       break;
1302     case BFD_RELOC_HI16_GOTOFF:          ppc_reloc = R_PPC64_GOT16_HI;
1303       break;
1304     case BFD_RELOC_HI16_S_GOTOFF:        ppc_reloc = R_PPC64_GOT16_HA;
1305       break;
1306     case BFD_RELOC_PPC_COPY:             ppc_reloc = R_PPC64_COPY;
1307       break;
1308     case BFD_RELOC_PPC_GLOB_DAT:         ppc_reloc = R_PPC64_GLOB_DAT;
1309       break;
1310     case BFD_RELOC_32_PCREL:             ppc_reloc = R_PPC64_REL32;
1311       break;
1312     case BFD_RELOC_32_PLTOFF:            ppc_reloc = R_PPC64_PLT32;
1313       break;
1314     case BFD_RELOC_32_PLT_PCREL:         ppc_reloc = R_PPC64_PLTREL32;
1315       break;
1316     case BFD_RELOC_LO16_PLTOFF:          ppc_reloc = R_PPC64_PLT16_LO;
1317       break;
1318     case BFD_RELOC_HI16_PLTOFF:          ppc_reloc = R_PPC64_PLT16_HI;
1319       break;
1320     case BFD_RELOC_HI16_S_PLTOFF:        ppc_reloc = R_PPC64_PLT16_HA;
1321       break;
1322     case BFD_RELOC_32_BASEREL:           ppc_reloc = R_PPC64_SECTOFF;
1323       break;
1324     case BFD_RELOC_LO16_BASEREL:         ppc_reloc = R_PPC64_SECTOFF_LO;
1325       break;
1326     case BFD_RELOC_HI16_BASEREL:         ppc_reloc = R_PPC64_SECTOFF_HI;
1327       break;
1328     case BFD_RELOC_HI16_S_BASEREL:       ppc_reloc = R_PPC64_SECTOFF_HA;
1329       break;
1330     case BFD_RELOC_CTOR:                 ppc_reloc = R_PPC64_ADDR64;
1331       break;
1332     case BFD_RELOC_64:                   ppc_reloc = R_PPC64_ADDR64;
1333       break;
1334     case BFD_RELOC_PPC64_HIGHER:         ppc_reloc = R_PPC64_ADDR16_HIGHER;
1335       break;
1336     case BFD_RELOC_PPC64_HIGHER_S:       ppc_reloc = R_PPC64_ADDR16_HIGHERA;
1337       break;
1338     case BFD_RELOC_PPC64_HIGHEST:        ppc_reloc = R_PPC64_ADDR16_HIGHEST;
1339       break;
1340     case BFD_RELOC_PPC64_HIGHEST_S:      ppc_reloc = R_PPC64_ADDR16_HIGHESTA;
1341       break;
1342     case BFD_RELOC_64_PCREL:             ppc_reloc = R_PPC64_REL64;
1343       break;
1344     case BFD_RELOC_64_PLTOFF:            ppc_reloc = R_PPC64_PLT64;
1345       break;
1346     case BFD_RELOC_64_PLT_PCREL:         ppc_reloc = R_PPC64_PLTREL64;
1347       break;
1348     case BFD_RELOC_PPC_TOC16:            ppc_reloc = R_PPC64_TOC16;
1349       break;
1350     case BFD_RELOC_PPC64_TOC16_LO:       ppc_reloc = R_PPC64_TOC16_LO;
1351       break;
1352     case BFD_RELOC_PPC64_TOC16_HI:       ppc_reloc = R_PPC64_TOC16_HI;
1353       break;
1354     case BFD_RELOC_PPC64_TOC16_HA:       ppc_reloc = R_PPC64_TOC16_HA;
1355       break;
1356     case BFD_RELOC_PPC64_TOC:            ppc_reloc = R_PPC64_TOC;
1357       break;
1358     case BFD_RELOC_PPC64_PLTGOT16:       ppc_reloc = R_PPC64_PLTGOT16;
1359       break;
1360     case BFD_RELOC_PPC64_PLTGOT16_LO:    ppc_reloc = R_PPC64_PLTGOT16_LO;
1361       break;
1362     case BFD_RELOC_PPC64_PLTGOT16_HI:    ppc_reloc = R_PPC64_PLTGOT16_HI;
1363       break;
1364     case BFD_RELOC_PPC64_PLTGOT16_HA:    ppc_reloc = R_PPC64_PLTGOT16_HA;
1365       break;
1366     case BFD_RELOC_PPC64_ADDR16_DS:      ppc_reloc = R_PPC64_ADDR16_DS;
1367       break;
1368     case BFD_RELOC_PPC64_ADDR16_LO_DS:   ppc_reloc = R_PPC64_ADDR16_LO_DS;
1369       break;
1370     case BFD_RELOC_PPC64_GOT16_DS:       ppc_reloc = R_PPC64_GOT16_DS;
1371       break;
1372     case BFD_RELOC_PPC64_GOT16_LO_DS:    ppc_reloc = R_PPC64_GOT16_LO_DS;
1373       break;
1374     case BFD_RELOC_PPC64_PLT16_LO_DS:    ppc_reloc = R_PPC64_PLT16_LO_DS;
1375       break;
1376     case BFD_RELOC_PPC64_SECTOFF_DS:     ppc_reloc = R_PPC64_SECTOFF_DS;
1377       break;
1378     case BFD_RELOC_PPC64_SECTOFF_LO_DS:  ppc_reloc = R_PPC64_SECTOFF_LO_DS;
1379       break;
1380     case BFD_RELOC_PPC64_TOC16_DS:       ppc_reloc = R_PPC64_TOC16_DS;
1381       break;
1382     case BFD_RELOC_PPC64_TOC16_LO_DS:    ppc_reloc = R_PPC64_TOC16_LO_DS;
1383       break;
1384     case BFD_RELOC_PPC64_PLTGOT16_DS:    ppc_reloc = R_PPC64_PLTGOT16_DS;
1385       break;
1386     case BFD_RELOC_PPC64_PLTGOT16_LO_DS: ppc_reloc = R_PPC64_PLTGOT16_LO_DS;
1387       break;
1388     case BFD_RELOC_VTABLE_INHERIT:       ppc_reloc = R_PPC64_GNU_VTINHERIT;
1389       break;
1390     case BFD_RELOC_VTABLE_ENTRY:         ppc_reloc = R_PPC64_GNU_VTENTRY;
1391       break;
1392     }
1393
1394   return ppc64_elf_howto_table[(int) ppc_reloc];
1395 };
1396
1397 /* Set the howto pointer for a PowerPC ELF reloc.  */
1398
1399 static void
1400 ppc64_elf_info_to_howto (abfd, cache_ptr, dst)
1401      bfd *abfd ATTRIBUTE_UNUSED;
1402      arelent *cache_ptr;
1403      Elf64_Internal_Rela *dst;
1404 {
1405   unsigned int type;
1406
1407   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1408     /* Initialize howto table if needed.  */
1409     ppc_howto_init ();
1410
1411   type = ELF64_R_TYPE (dst->r_info);
1412   BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1413                       / sizeof (ppc64_elf_howto_table[0])));
1414   cache_ptr->howto = ppc64_elf_howto_table[type];
1415 }
1416
1417 /* Handle the R_PPC_ADDR16_HA and similar relocs.  */
1418
1419 static bfd_reloc_status_type
1420 ppc64_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
1421                            output_bfd, error_message)
1422      bfd *abfd ATTRIBUTE_UNUSED;
1423      arelent *reloc_entry;
1424      asymbol *symbol;
1425      PTR data ATTRIBUTE_UNUSED;
1426      asection *input_section;
1427      bfd *output_bfd;
1428      char **error_message ATTRIBUTE_UNUSED;
1429 {
1430   bfd_vma relocation;
1431
1432   if (output_bfd != NULL)
1433     {
1434       reloc_entry->address += input_section->output_offset;
1435       return bfd_reloc_ok;
1436     }
1437
1438   if (reloc_entry->address > input_section->_cooked_size)
1439     return bfd_reloc_outofrange;
1440
1441   if (bfd_is_com_section (symbol->section))
1442     relocation = 0;
1443   else
1444     relocation = symbol->value;
1445
1446   relocation += symbol->section->output_section->vma;
1447   relocation += symbol->section->output_offset;
1448   relocation += reloc_entry->addend;
1449
1450   reloc_entry->addend += (relocation & 0x8000) << 1;
1451
1452   return bfd_reloc_continue;
1453 }
1454
1455 /* Function to set whether a module needs the -mrelocatable bit set.  */
1456
1457 static boolean
1458 ppc64_elf_set_private_flags (abfd, flags)
1459      bfd *abfd;
1460      flagword flags;
1461 {
1462   BFD_ASSERT (!elf_flags_init (abfd)
1463               || elf_elfheader (abfd)->e_flags == flags);
1464
1465   elf_elfheader (abfd)->e_flags = flags;
1466   elf_flags_init (abfd) = true;
1467   return true;
1468 }
1469
1470 /* Merge backend specific data from an object file to the output
1471    object file when linking.  */
1472 static boolean
1473 ppc64_elf_merge_private_bfd_data (ibfd, obfd)
1474      bfd *ibfd;
1475      bfd *obfd;
1476 {
1477   flagword old_flags;
1478   flagword new_flags;
1479   boolean error;
1480
1481   /* Check if we have the same endianess.  */
1482   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1483       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1484     {
1485       const char *msg;
1486
1487       if (bfd_big_endian (ibfd))
1488         msg = _("%s: compiled for a big endian system and target is little endian");
1489       else
1490         msg = _("%s: compiled for a little endian system and target is big endian");
1491
1492       (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
1493
1494       bfd_set_error (bfd_error_wrong_format);
1495       return false;
1496     }
1497
1498   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1499       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1500     return true;
1501
1502   new_flags = elf_elfheader (ibfd)->e_flags;
1503   old_flags = elf_elfheader (obfd)->e_flags;
1504   if (!elf_flags_init (obfd))
1505     {
1506       /* First call, no flags set.  */
1507       elf_flags_init (obfd) = true;
1508       elf_elfheader (obfd)->e_flags = new_flags;
1509     }
1510
1511   else if (new_flags == old_flags)
1512     /* Compatible flags are ok.  */
1513     ;
1514
1515   else
1516     {
1517       /* Incompatible flags.  Warn about -mrelocatable mismatch.
1518          Allow -mrelocatable-lib to be linked with either.  */
1519       error = false;
1520       if ((new_flags & EF_PPC_RELOCATABLE) != 0
1521           && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
1522         {
1523           error = true;
1524           (*_bfd_error_handler)
1525             (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
1526              bfd_archive_filename (ibfd));
1527         }
1528       else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
1529                && (old_flags & EF_PPC_RELOCATABLE) != 0)
1530         {
1531           error = true;
1532           (*_bfd_error_handler)
1533             (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
1534              bfd_archive_filename (ibfd));
1535         }
1536
1537       /* The output is -mrelocatable-lib iff both the input files are.  */
1538       if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
1539         elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
1540
1541       /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
1542          but each input file is either -mrelocatable or -mrelocatable-lib.  */
1543       if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
1544           && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
1545           && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
1546         elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
1547
1548       /* Do not warn about eabi vs. V.4 mismatch, just or in the bit
1549          if any module uses it.  */
1550       elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
1551
1552       new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1553       old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1554
1555       /* Warn about any other mismatches.  */
1556       if (new_flags != old_flags)
1557         {
1558           error = true;
1559           (*_bfd_error_handler)
1560             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1561              bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
1562         }
1563
1564       if (error)
1565         {
1566           bfd_set_error (bfd_error_bad_value);
1567           return false;
1568         }
1569     }
1570
1571   return true;
1572 }
1573
1574 /* Handle a PowerPC specific section when reading an object file.  This
1575    is called when elfcode.h finds a section with an unknown type.  */
1576
1577 static boolean
1578 ppc64_elf_section_from_shdr (abfd, hdr, name)
1579      bfd *abfd;
1580      Elf64_Internal_Shdr *hdr;
1581      char *name;
1582 {
1583   asection *newsect;
1584   flagword flags;
1585
1586   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1587     return false;
1588
1589   newsect = hdr->bfd_section;
1590   flags = bfd_get_section_flags (abfd, newsect);
1591   if (hdr->sh_flags & SHF_EXCLUDE)
1592     flags |= SEC_EXCLUDE;
1593
1594   if (hdr->sh_type == SHT_ORDERED)
1595     flags |= SEC_SORT_ENTRIES;
1596
1597   bfd_set_section_flags (abfd, newsect, flags);
1598   return true;
1599 }
1600 \f
1601 /* The following functions are specific to the ELF linker, while
1602    functions above are used generally.  Those named ppc64_elf_* are
1603    called by the main ELF linker code.  They appear in this file more
1604    or less in the order in which they are called.  eg.
1605    ppc64_elf_check_relocs is called early in the link process,
1606    ppc64_elf_finish_dynamic_sections is one of the last functions
1607    called.
1608
1609    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
1610    functions have both a function code symbol and a function descriptor
1611    symbol.  A call to foo in a relocatable object file looks like:
1612
1613    .            .text
1614    .    x:
1615    .            bl      .foo
1616    .            nop
1617
1618    The function definition in another object file might be:
1619
1620    .            .section .opd
1621    .    foo:    .quad   .foo
1622    .            .quad   .TOC.@tocbase
1623    .            .quad   0
1624    .
1625    .            .text
1626    .    .foo:   blr
1627
1628    When the linker resolves the call during a static link, the branch
1629    unsurprisingly just goes to .foo and the .opd information is unused.
1630    If the function definition is in a shared library, things are a little
1631    different:  The call goes via a plt call stub, the opd information gets
1632    copied to the plt, and the linker patches the nop.
1633
1634    .    x:
1635    .            bl      .foo_stub
1636    .            ld      2,40(1)
1637    .
1638    .
1639    .    .foo_stub:
1640    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
1641    .            addi    12,12,Lfoo@toc@l        # is slightly optimised, but
1642    .            std     2,40(1)                 # this is the general idea
1643    .            ld      11,0(12)
1644    .            ld      2,8(12)
1645    .            mtctr   11
1646    .            ld      11,16(12)
1647    .            bctr
1648    .
1649    .            .section .plt
1650    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
1651
1652    The "reloc ()" notation is supposed to indicate that the linker emits
1653    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
1654    copying.
1655
1656    What are the difficulties here?  Well, firstly, the relocations
1657    examined by the linker in check_relocs are against the function code
1658    sym .foo, while the dynamic relocation in the plt is emitted against
1659    the function descriptor symbol, foo.  Somewhere along the line, we need
1660    to carefully copy dynamic link information from one symbol to the other.
1661    Secondly, the generic part of the elf linker will make .foo a dynamic
1662    symbol as is normal for most other backends.  We need foo dynamic
1663    instead, at least for an application final link.  However, when
1664    creating a shared library containing foo, we need to have both symbols
1665    dynamic so that references to .foo are satisfied during the early
1666    stages of linking.  Otherwise the linker might decide to pull in a
1667    definition from some other object, eg. a static library.  */
1668
1669 /* The linker needs to keep track of the number of relocs that it
1670    decides to copy as dynamic relocs in check_relocs for each symbol.
1671    This is so that it can later discard them if they are found to be
1672    unnecessary.  We store the information in a field extending the
1673    regular ELF linker hash table.  */
1674
1675 struct ppc_dyn_relocs
1676 {
1677   struct ppc_dyn_relocs *next;
1678
1679   /* The input section of the reloc.  */
1680   asection *sec;
1681
1682   /* Total number of relocs copied for the input section.  */
1683   bfd_size_type count;
1684
1685   /* Number of pc-relative relocs copied for the input section.  */
1686   bfd_size_type pc_count;
1687 };
1688
1689 /* Of those relocs that might be copied as dynamic relocs, this macro
1690    selects between relative and absolute types.  */
1691
1692 #define IS_ABSOLUTE_RELOC(RTYPE)                \
1693   ((RTYPE) != R_PPC64_REL14                     \
1694    && (RTYPE) != R_PPC64_REL14_BRNTAKEN         \
1695    && (RTYPE) != R_PPC64_REL14_BRTAKEN          \
1696    && (RTYPE) != R_PPC64_REL24                  \
1697    && (RTYPE) != R_PPC64_REL32                  \
1698    && (RTYPE) != R_PPC64_REL64)
1699
1700 /* ppc64 ELF linker hash entry.  */
1701
1702 struct ppc_link_hash_entry
1703 {
1704   struct elf_link_hash_entry elf;
1705
1706   /* Track dynamic relocs copied for this symbol.  */
1707   struct ppc_dyn_relocs *dyn_relocs;
1708
1709   /* Flag function code and descriptor symbols.  */
1710   unsigned int is_func:1;
1711   unsigned int is_func_descriptor:1;
1712 };
1713
1714 /* ppc64 ELF linker hash table.  */
1715
1716 struct ppc_link_hash_table
1717 {
1718   struct elf_link_hash_table elf;
1719
1720   /* Short-cuts to get to dynamic linker sections.  */
1721   asection *sgot;
1722   asection *srelgot;
1723   asection *splt;
1724   asection *srelplt;
1725   asection *sdynbss;
1726   asection *srelbss;
1727   asection *sstub;
1728   asection *sglink;
1729   asection *sfpr;
1730
1731   /* Set on error.  */
1732   int plt_overflow;
1733
1734   /* Small local sym to section mapping cache.  */
1735   struct sym_sec_cache sym_sec;
1736 };
1737
1738 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
1739
1740 #define ppc_hash_table(p) \
1741   ((struct ppc_link_hash_table *) ((p)->hash))
1742
1743 /* Create an entry in a ppc64 ELF linker hash table.  */
1744
1745 static struct bfd_hash_entry *
1746 link_hash_newfunc (entry, table, string)
1747      struct bfd_hash_entry *entry;
1748      struct bfd_hash_table *table;
1749      const char *string;
1750 {
1751   /* Allocate the structure if it has not already been allocated by a
1752      subclass.  */
1753   if (entry == NULL)
1754     {
1755       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
1756       if (entry == NULL)
1757         return entry;
1758     }
1759
1760   /* Call the allocation method of the superclass.  */
1761   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1762   if (entry != NULL)
1763     {
1764       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
1765
1766       eh->dyn_relocs = NULL;
1767       eh->is_func = 0;
1768       eh->is_func_descriptor = 0;
1769     }
1770
1771   return entry;
1772 }
1773
1774 /* Create a ppc64 ELF linker hash table.  */
1775
1776 static struct bfd_link_hash_table *
1777 ppc64_elf_link_hash_table_create (abfd)
1778      bfd *abfd;
1779 {
1780   struct ppc_link_hash_table *htab;
1781   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
1782
1783   htab = (struct ppc_link_hash_table *) bfd_alloc (abfd, amt);
1784   if (htab == NULL)
1785     return NULL;
1786
1787   if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
1788     {
1789       bfd_release (abfd, htab);
1790       return NULL;
1791     }
1792
1793   htab->sgot = NULL;
1794   htab->srelgot = NULL;
1795   htab->splt = NULL;
1796   htab->srelplt = NULL;
1797   htab->sdynbss = NULL;
1798   htab->srelbss = NULL;
1799   htab->sstub = NULL;
1800   htab->sglink = NULL;
1801   htab->sfpr = NULL;
1802   htab->plt_overflow = 0;
1803   htab->sym_sec.abfd = NULL;
1804
1805   return &htab->elf.root;
1806 }
1807
1808 /* Create sections for linker generated code.  */
1809
1810 static boolean
1811 create_linkage_sections (dynobj, info)
1812      bfd *dynobj;
1813      struct bfd_link_info *info;
1814 {
1815   struct ppc_link_hash_table *htab;
1816   flagword flags;
1817
1818   htab = ppc_hash_table (info);
1819
1820   /* Create .sfpr for code to save and restore fp regs.  */
1821   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
1822            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1823   htab->sfpr = bfd_make_section (dynobj, ".sfpr");
1824   if (htab->sfpr == NULL
1825       || ! bfd_set_section_flags (dynobj, htab->sfpr, flags)
1826       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
1827     return false;
1828
1829   /* Create .stub and .glink for global linkage functions.  */
1830   htab->sstub = bfd_make_section (dynobj, ".stub");
1831   if (htab->sstub == NULL
1832       || ! bfd_set_section_flags (dynobj, htab->sstub, flags)
1833       || ! bfd_set_section_alignment (dynobj, htab->sstub, 2))
1834     return false;
1835   htab->sglink = bfd_make_section (dynobj, ".glink");
1836   if (htab->sglink == NULL
1837       || ! bfd_set_section_flags (dynobj, htab->sglink, flags)
1838       || ! bfd_set_section_alignment (dynobj, htab->sglink, 2))
1839     return false;
1840
1841   return true;
1842 }
1843
1844 /* Create .got and .rela.got sections in DYNOBJ, and set up
1845    shortcuts to them in our hash table.  */
1846
1847 static boolean
1848 create_got_section (dynobj, info)
1849      bfd *dynobj;
1850      struct bfd_link_info *info;
1851 {
1852   struct ppc_link_hash_table *htab;
1853
1854   if (! _bfd_elf_create_got_section (dynobj, info))
1855     return false;
1856
1857   htab = ppc_hash_table (info);
1858   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1859   if (!htab->sgot)
1860     abort ();
1861
1862   htab->srelgot = bfd_make_section (dynobj, ".rela.got");
1863   if (!htab->srelgot
1864       || ! bfd_set_section_flags (dynobj, htab->srelgot,
1865                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1866                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
1867                                    | SEC_READONLY))
1868       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
1869     return false;
1870   return true;
1871 }
1872
1873 /* Create the dynamic sections, and set up shortcuts.  */
1874
1875 static boolean
1876 ppc64_elf_create_dynamic_sections (dynobj, info)
1877      bfd *dynobj;
1878      struct bfd_link_info *info;
1879 {
1880   struct ppc_link_hash_table *htab;
1881
1882   htab = ppc_hash_table (info);
1883   if (!htab->sgot && !create_got_section (dynobj, info))
1884     return false;
1885
1886   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1887     return false;
1888
1889   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1890   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1891   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1892   if (!info->shared)
1893     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1894
1895   if (!htab->splt || !htab->srelplt || !htab->sdynbss
1896       || (!info->shared && !htab->srelbss))
1897     abort ();
1898
1899   return true;
1900 }
1901
1902 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1903
1904 static void
1905 ppc64_elf_copy_indirect_symbol (dir, ind)
1906      struct elf_link_hash_entry *dir, *ind;
1907 {
1908   struct ppc_link_hash_entry *edir, *eind;
1909
1910   edir = (struct ppc_link_hash_entry *) dir;
1911   eind = (struct ppc_link_hash_entry *) ind;
1912
1913   if (eind->dyn_relocs != NULL)
1914     {
1915       if (edir->dyn_relocs != NULL)
1916         {
1917           struct ppc_dyn_relocs **pp;
1918           struct ppc_dyn_relocs *p;
1919
1920           if (ind->root.type == bfd_link_hash_indirect)
1921             abort ();
1922
1923           /* Add reloc counts against the weak sym to the strong sym
1924              list.  Merge any entries against the same section.  */
1925           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1926             {
1927               struct ppc_dyn_relocs *q;
1928
1929               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1930                 if (q->sec == p->sec)
1931                   {
1932                     q->pc_count += p->pc_count;
1933                     q->count += p->count;
1934                     *pp = p->next;
1935                     break;
1936                   }
1937               if (q == NULL)
1938                 pp = &p->next;
1939             }
1940           *pp = edir->dyn_relocs;
1941         }
1942
1943       edir->dyn_relocs = eind->dyn_relocs;
1944       eind->dyn_relocs = NULL;
1945     }
1946
1947   edir->is_func |= eind->is_func;
1948   edir->is_func_descriptor |= eind->is_func_descriptor;
1949
1950   _bfd_elf_link_hash_copy_indirect (dir, ind);
1951 }
1952
1953 /* Look through the relocs for a section during the first phase, and
1954    calculate needed space in the global offset table, procedure
1955    linkage table, and dynamic reloc sections.  */
1956
1957 static boolean
1958 ppc64_elf_check_relocs (abfd, info, sec, relocs)
1959      bfd *abfd;
1960      struct bfd_link_info *info;
1961      asection *sec;
1962      const Elf_Internal_Rela *relocs;
1963 {
1964   struct ppc_link_hash_table *htab;
1965   Elf_Internal_Shdr *symtab_hdr;
1966   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1967   const Elf_Internal_Rela *rel;
1968   const Elf_Internal_Rela *rel_end;
1969   asection *sreloc;
1970   boolean is_opd;
1971
1972   if (info->relocateable)
1973     return true;
1974
1975   htab = ppc_hash_table (info);
1976   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1977
1978   sym_hashes = elf_sym_hashes (abfd);
1979   sym_hashes_end = (sym_hashes
1980                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym));
1981   if (!elf_bad_symtab (abfd))
1982     sym_hashes_end -= symtab_hdr->sh_info;
1983
1984   sreloc = NULL;
1985   is_opd = strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0;
1986
1987   if (htab->elf.dynobj == NULL)
1988     htab->elf.dynobj = abfd;
1989   if (htab->sfpr == NULL
1990       && !create_linkage_sections (htab->elf.dynobj, info))
1991     return false;
1992
1993   rel_end = relocs + sec->reloc_count;
1994   for (rel = relocs; rel < rel_end; rel++)
1995     {
1996       unsigned long r_symndx;
1997       struct elf_link_hash_entry *h;
1998       enum elf_ppc_reloc_type r_type;
1999
2000       r_symndx = ELF64_R_SYM (rel->r_info);
2001       if (r_symndx < symtab_hdr->sh_info)
2002         h = NULL;
2003       else
2004         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2005
2006       r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2007       switch (r_type)
2008         {
2009           /* GOT16 relocations */
2010         case R_PPC64_GOT16:
2011         case R_PPC64_GOT16_DS:
2012         case R_PPC64_GOT16_HA:
2013         case R_PPC64_GOT16_HI:
2014         case R_PPC64_GOT16_LO:
2015         case R_PPC64_GOT16_LO_DS:
2016
2017           /* This symbol requires a global offset table entry.  */
2018           if (htab->sgot == NULL
2019               && !create_got_section (htab->elf.dynobj, info))
2020             return false;
2021
2022           if (h != NULL)
2023             {
2024               h->got.refcount += 1;
2025             }
2026           else
2027             {
2028               bfd_signed_vma *local_got_refcounts;
2029
2030               /* This is a global offset table entry for a local symbol.  */
2031               local_got_refcounts = elf_local_got_refcounts (abfd);
2032               if (local_got_refcounts == NULL)
2033                 {
2034                   bfd_size_type size;
2035
2036                   size = symtab_hdr->sh_info;
2037                   size *= sizeof (bfd_signed_vma);
2038                   local_got_refcounts = ((bfd_signed_vma *)
2039                                          bfd_zalloc (abfd, size));
2040                   if (local_got_refcounts == NULL)
2041                     return false;
2042                   elf_local_got_refcounts (abfd) = local_got_refcounts;
2043                 }
2044               local_got_refcounts[r_symndx] += 1;
2045             }
2046           break;
2047
2048         case R_PPC64_PLT16_HA:
2049         case R_PPC64_PLT16_HI:
2050         case R_PPC64_PLT16_LO:
2051         case R_PPC64_PLT32:
2052         case R_PPC64_PLT64:
2053           /* This symbol requires a procedure linkage table entry.  We
2054              actually build the entry in adjust_dynamic_symbol,
2055              because this might be a case of linking PIC code without
2056              linking in any dynamic objects, in which case we don't
2057              need to generate a procedure linkage table after all.  */
2058           if (h == NULL)
2059             {
2060               /* It does not make sense to have a procedure linkage
2061                  table entry for a local symbol.  */
2062               bfd_set_error (bfd_error_bad_value);
2063               return false;
2064             }
2065
2066           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2067           h->plt.refcount += 1;
2068           ((struct ppc_link_hash_entry *) h)->is_func = 1;
2069           break;
2070
2071           /* The following relocations don't need to propagate the
2072              relocation if linking a shared object since they are
2073              section relative.  */
2074         case R_PPC64_SECTOFF:
2075         case R_PPC64_SECTOFF_LO:
2076         case R_PPC64_SECTOFF_HI:
2077         case R_PPC64_SECTOFF_HA:
2078         case R_PPC64_SECTOFF_DS:
2079         case R_PPC64_SECTOFF_LO_DS:
2080         case R_PPC64_TOC16:
2081         case R_PPC64_TOC16_LO:
2082         case R_PPC64_TOC16_HI:
2083         case R_PPC64_TOC16_HA:
2084         case R_PPC64_TOC16_DS:
2085         case R_PPC64_TOC16_LO_DS:
2086           break;
2087
2088           /* This relocation describes the C++ object vtable hierarchy.
2089              Reconstruct it for later use during GC.  */
2090         case R_PPC64_GNU_VTINHERIT:
2091           if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2092             return false;
2093           break;
2094
2095           /* This relocation describes which C++ vtable entries are actually
2096              used.  Record for later use during GC.  */
2097         case R_PPC64_GNU_VTENTRY:
2098           if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2099             return false;
2100           break;
2101
2102         case R_PPC64_REL24:
2103           if (h != NULL
2104               && h->root.root.string[0] == '.'
2105               && h->root.root.string[1] != 0)
2106             {
2107               /* We may need a .plt entry if the function this reloc
2108                  refers to is in a shared lib.  */
2109               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2110               h->plt.refcount += 1;
2111               ((struct ppc_link_hash_entry *) h)->is_func = 1;
2112             }
2113           break;
2114
2115         case R_PPC64_ADDR64:
2116           if (is_opd
2117               && h != NULL
2118               && h->root.root.string[0] == '.'
2119               && h->root.root.string[1] != 0)
2120             {
2121               struct elf_link_hash_entry *fdh;
2122
2123               fdh = elf_link_hash_lookup (&htab->elf, h->root.root.string + 1,
2124                                           false, false, false);
2125               if (fdh != NULL)
2126                 {
2127                   /* Ensure the function descriptor symbol string is
2128                      part of the code symbol string.  We aren't
2129                      changing the name here, just allowing some tricks
2130                      in ppc64_elf_hide_symbol.  */
2131                   fdh->root.root.string = h->root.root.string + 1;
2132                   ((struct ppc_link_hash_entry *) fdh)->is_func_descriptor = 1;
2133                   ((struct ppc_link_hash_entry *) h)->is_func = 1;
2134                 }
2135             }
2136           /* Fall through.  */
2137
2138         case R_PPC64_REL64:
2139         case R_PPC64_REL32:
2140         case R_PPC64_REL14:
2141         case R_PPC64_REL14_BRTAKEN:
2142         case R_PPC64_REL14_BRNTAKEN:
2143         case R_PPC64_ADDR14:
2144         case R_PPC64_ADDR14_BRNTAKEN:
2145         case R_PPC64_ADDR14_BRTAKEN:
2146         case R_PPC64_ADDR16:
2147         case R_PPC64_ADDR16_DS:
2148         case R_PPC64_ADDR16_HA:
2149         case R_PPC64_ADDR16_HI:
2150         case R_PPC64_ADDR16_HIGHER:
2151         case R_PPC64_ADDR16_HIGHERA:
2152         case R_PPC64_ADDR16_HIGHEST:
2153         case R_PPC64_ADDR16_HIGHESTA:
2154         case R_PPC64_ADDR16_LO:
2155         case R_PPC64_ADDR16_LO_DS:
2156         case R_PPC64_ADDR24:
2157         case R_PPC64_ADDR30:
2158         case R_PPC64_ADDR32:
2159         case R_PPC64_UADDR16:
2160         case R_PPC64_UADDR32:
2161         case R_PPC64_UADDR64:
2162         case R_PPC64_TOC:
2163           /* Don't propagate .opd relocs.  */
2164           if (NO_OPD_RELOCS && is_opd)
2165             break;
2166
2167           /* If we are creating a shared library, and this is a reloc
2168              against a global symbol, or a non PC relative reloc
2169              against a local symbol, then we need to copy the reloc
2170              into the shared library.  However, if we are linking with
2171              -Bsymbolic, we do not need to copy a reloc against a
2172              global symbol which is defined in an object we are
2173              including in the link (i.e., DEF_REGULAR is set).  At
2174              this point we have not seen all the input files, so it is
2175              possible that DEF_REGULAR is not set now but will be set
2176              later (it is never cleared).  In case of a weak definition,
2177              DEF_REGULAR may be cleared later by a strong definition in
2178              a shared library.  We account for that possibility below by
2179              storing information in the relocs_copied field of the hash
2180              table entry.  A similar situation occurs when creating
2181              shared libraries and symbol visibility changes render the
2182              symbol local.
2183
2184              If on the other hand, we are creating an executable, we
2185              may need to keep relocations for symbols satisfied by a
2186              dynamic library if we manage to avoid copy relocs for the
2187              symbol.  */
2188           if ((info->shared
2189                && (sec->flags & SEC_ALLOC) != 0
2190                && (IS_ABSOLUTE_RELOC (r_type)
2191                    || (h != NULL
2192                        && (! info->symbolic
2193                            || h->root.type == bfd_link_hash_defweak
2194                            || (h->elf_link_hash_flags
2195                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2196               || (!info->shared
2197                   && (sec->flags & SEC_ALLOC) != 0
2198                   && h != NULL
2199                   && (h->root.type == bfd_link_hash_defweak
2200                       || (h->elf_link_hash_flags
2201                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
2202             {
2203               struct ppc_dyn_relocs *p;
2204               struct ppc_dyn_relocs **head;
2205
2206               /* We must copy these reloc types into the output file.
2207                  Create a reloc section in dynobj and make room for
2208                  this reloc.  */
2209               if (sreloc == NULL)
2210                 {
2211                   const char *name;
2212                   bfd *dynobj;
2213
2214                   name = (bfd_elf_string_from_elf_section
2215                           (abfd,
2216                            elf_elfheader (abfd)->e_shstrndx,
2217                            elf_section_data (sec)->rel_hdr.sh_name));
2218                   if (name == NULL)
2219                     return false;
2220
2221                   if (strncmp (name, ".rela", 5) != 0
2222                       || strcmp (bfd_get_section_name (abfd, sec),
2223                                  name + 5) != 0)
2224                     {
2225                       (*_bfd_error_handler)
2226                         (_("%s: bad relocation section name `%s\'"),
2227                          bfd_archive_filename (abfd), name);
2228                       bfd_set_error (bfd_error_bad_value);
2229                     }
2230
2231                   dynobj = htab->elf.dynobj;
2232                   sreloc = bfd_get_section_by_name (dynobj, name);
2233                   if (sreloc == NULL)
2234                     {
2235                       flagword flags;
2236
2237                       sreloc = bfd_make_section (dynobj, name);
2238                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
2239                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2240                       if ((sec->flags & SEC_ALLOC) != 0)
2241                         flags |= SEC_ALLOC | SEC_LOAD;
2242                       if (sreloc == NULL
2243                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
2244                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
2245                         return false;
2246                     }
2247                   elf_section_data (sec)->sreloc = sreloc;
2248                 }
2249
2250               /* If this is a global symbol, we count the number of
2251                  relocations we need for this symbol.  */
2252               if (h != NULL)
2253                 {
2254                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
2255                 }
2256               else
2257                 {
2258                   /* Track dynamic relocs needed for local syms too.
2259                      We really need local syms available to do this
2260                      easily.  Oh well.  */
2261
2262                   asection *s;
2263                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
2264                                                  sec, r_symndx);
2265                   if (s == NULL)
2266                     return false;
2267
2268                   head = ((struct ppc_dyn_relocs **)
2269                           &elf_section_data (s)->local_dynrel);
2270                 }
2271
2272               p = *head;
2273               if (p == NULL || p->sec != sec)
2274                 {
2275                   p = ((struct ppc_dyn_relocs *)
2276                        bfd_alloc (htab->elf.dynobj,
2277                                   (bfd_size_type) sizeof *p));
2278                   if (p == NULL)
2279                     return false;
2280                   p->next = *head;
2281                   *head = p;
2282                   p->sec = sec;
2283                   p->count = 0;
2284                   p->pc_count = 0;
2285                 }
2286
2287               p->count += 1;
2288               if (!IS_ABSOLUTE_RELOC (r_type))
2289                 p->pc_count += 1;
2290             }
2291           break;
2292
2293         default:
2294         }
2295     }
2296
2297   return true;
2298 }
2299
2300 /* Return the section that should be marked against GC for a given
2301    relocation.  */
2302
2303 static asection *
2304 ppc64_elf_gc_mark_hook (abfd, info, rel, h, sym)
2305      bfd *abfd;
2306      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2307      Elf_Internal_Rela *rel;
2308      struct elf_link_hash_entry *h;
2309      Elf_Internal_Sym *sym;
2310 {
2311   if (h != NULL)
2312     {
2313       enum elf_ppc_reloc_type r_type;
2314
2315       r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2316       switch (r_type)
2317         {
2318         case R_PPC64_GNU_VTINHERIT:
2319         case R_PPC64_GNU_VTENTRY:
2320           break;
2321
2322         default:
2323           switch (h->root.type)
2324             {
2325             case bfd_link_hash_defined:
2326             case bfd_link_hash_defweak:
2327               return h->root.u.def.section;
2328
2329             case bfd_link_hash_common:
2330               return h->root.u.c.p->section;
2331
2332             default:
2333               break;
2334             }
2335         }
2336     }
2337   else
2338     {
2339       return bfd_section_from_elf_index (abfd, sym->st_shndx);
2340     }
2341
2342   return NULL;
2343 }
2344
2345 /* Update the .got, .plt. and dynamic reloc reference counts for the
2346    section being removed.  */
2347
2348 static boolean
2349 ppc64_elf_gc_sweep_hook (abfd, info, sec, relocs)
2350      bfd *abfd;
2351      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2352      asection *sec;
2353      const Elf_Internal_Rela *relocs;
2354 {
2355   Elf_Internal_Shdr *symtab_hdr;
2356   struct elf_link_hash_entry **sym_hashes;
2357   bfd_signed_vma *local_got_refcounts;
2358   const Elf_Internal_Rela *rel, *relend;
2359
2360   elf_section_data (sec)->local_dynrel = NULL;
2361
2362   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2363   sym_hashes = elf_sym_hashes (abfd);
2364   local_got_refcounts = elf_local_got_refcounts (abfd);
2365
2366   relend = relocs + sec->reloc_count;
2367   for (rel = relocs; rel < relend; rel++)
2368     {
2369       unsigned long r_symndx;
2370       enum elf_ppc_reloc_type r_type;
2371       struct elf_link_hash_entry *h;
2372
2373       r_symndx = ELF64_R_SYM (rel->r_info);
2374       r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2375       switch (r_type)
2376         {
2377         case R_PPC64_GOT16:
2378         case R_PPC64_GOT16_DS:
2379         case R_PPC64_GOT16_HA:
2380         case R_PPC64_GOT16_HI:
2381         case R_PPC64_GOT16_LO:
2382         case R_PPC64_GOT16_LO_DS:
2383           if (r_symndx >= symtab_hdr->sh_info)
2384             {
2385               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2386               if (h->got.refcount > 0)
2387                 h->got.refcount--;
2388             }
2389           else
2390             {
2391               if (local_got_refcounts[r_symndx] > 0)
2392                 local_got_refcounts[r_symndx]--;
2393             }
2394           break;
2395
2396         case R_PPC64_PLT16_HA:
2397         case R_PPC64_PLT16_HI:
2398         case R_PPC64_PLT16_LO:
2399         case R_PPC64_PLT32:
2400         case R_PPC64_PLT64:
2401           if (r_symndx >= symtab_hdr->sh_info)
2402             {
2403               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2404               if (h->plt.refcount > 0)
2405                 h->plt.refcount--;
2406             }
2407           break;
2408
2409         case R_PPC64_REL24:
2410           if (r_symndx >= symtab_hdr->sh_info)
2411             {
2412               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2413               if (h->plt.refcount > 0)
2414                 h->plt.refcount--;
2415             }
2416           break;
2417
2418         case R_PPC64_REL14:
2419         case R_PPC64_REL14_BRNTAKEN:
2420         case R_PPC64_REL14_BRTAKEN:
2421         case R_PPC64_REL32:
2422         case R_PPC64_REL64:
2423           if (r_symndx >= symtab_hdr->sh_info)
2424             {
2425               struct ppc_link_hash_entry *eh;
2426               struct ppc_dyn_relocs **pp;
2427               struct ppc_dyn_relocs *p;
2428
2429               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2430               eh = (struct ppc_link_hash_entry *) h;
2431
2432               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2433                 if (p->sec == sec)
2434                   {
2435                     p->pc_count -= 1;
2436                     p->count -= 1;
2437                     if (p->count == 0)
2438                       *pp = p->next;
2439                     break;
2440                   }
2441             }
2442           break;
2443
2444         case R_PPC64_ADDR14:
2445         case R_PPC64_ADDR14_BRNTAKEN:
2446         case R_PPC64_ADDR14_BRTAKEN:
2447         case R_PPC64_ADDR16:
2448         case R_PPC64_ADDR16_DS:
2449         case R_PPC64_ADDR16_HA:
2450         case R_PPC64_ADDR16_HI:
2451         case R_PPC64_ADDR16_HIGHER:
2452         case R_PPC64_ADDR16_HIGHERA:
2453         case R_PPC64_ADDR16_HIGHEST:
2454         case R_PPC64_ADDR16_HIGHESTA:
2455         case R_PPC64_ADDR16_LO:
2456         case R_PPC64_ADDR16_LO_DS:
2457         case R_PPC64_ADDR24:
2458         case R_PPC64_ADDR30:
2459         case R_PPC64_ADDR32:
2460         case R_PPC64_ADDR64:
2461         case R_PPC64_UADDR16:
2462         case R_PPC64_UADDR32:
2463         case R_PPC64_UADDR64:
2464         case R_PPC64_TOC:
2465           if (r_symndx >= symtab_hdr->sh_info)
2466             {
2467               struct ppc_link_hash_entry *eh;
2468               struct ppc_dyn_relocs **pp;
2469               struct ppc_dyn_relocs *p;
2470
2471               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2472               eh = (struct ppc_link_hash_entry *) h;
2473
2474               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2475                 if (p->sec == sec)
2476                   {
2477                     p->count -= 1;
2478                     if (p->count == 0)
2479                       *pp = p->next;
2480                     break;
2481                   }
2482             }
2483           break;
2484
2485         default:
2486           break;
2487         }
2488     }
2489   return true;
2490 }
2491
2492 /* Called via elf_link_hash_traverse to transfer dynamic linking
2493    information on function code symbol entries to their corresponding
2494    function descriptor symbol entries.  */
2495 static boolean
2496 func_desc_adjust (h, inf)
2497      struct elf_link_hash_entry *h;
2498      PTR inf;
2499 {
2500   struct bfd_link_info *info;
2501   struct ppc_link_hash_table *htab;
2502
2503   if (h->root.type == bfd_link_hash_indirect
2504       || h->root.type == bfd_link_hash_warning)
2505     return true;
2506
2507   info = (struct bfd_link_info *) inf;
2508   htab = ppc_hash_table (info);
2509
2510   /* If this is a function code symbol, transfer dynamic linking
2511      information to the function descriptor symbol.  */
2512   if (!((struct ppc_link_hash_entry *) h)->is_func)
2513     return true;
2514
2515   if (h->plt.refcount > 0
2516       && h->root.root.string[0] == '.'
2517       && h->root.root.string[1] != '\0')
2518     {
2519       struct elf_link_hash_entry *fdh;
2520       boolean force_local;
2521
2522       /* Find the corresponding function descriptor symbol.  Create it
2523          as undefined if necessary.  */
2524
2525       fdh = elf_link_hash_lookup (&htab->elf, h->root.root.string + 1,
2526                                   false, false, true);
2527
2528       if (fdh == NULL
2529           && info->shared
2530           && (h->root.type == bfd_link_hash_undefined
2531               || h->root.type == bfd_link_hash_undefweak))
2532         {
2533           bfd *abfd;
2534           asymbol *newsym;
2535
2536           abfd = h->root.u.undef.abfd;
2537           newsym = bfd_make_empty_symbol (abfd);
2538           newsym->name = h->root.root.string + 1;
2539           newsym->section = bfd_und_section_ptr;
2540           newsym->value = 0;
2541           newsym->flags = BSF_OBJECT;
2542           if (h->root.type == bfd_link_hash_undefweak)
2543             newsym->flags |= BSF_WEAK;
2544
2545           if ( !(_bfd_generic_link_add_one_symbol
2546                  (info, abfd, newsym->name, newsym->flags,
2547                   newsym->section, newsym->value, NULL, false, false,
2548                   (struct bfd_link_hash_entry **) &fdh)))
2549             {
2550               return false;
2551             }
2552           fdh->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
2553         }
2554
2555       if (fdh != NULL
2556           && (fdh->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
2557           && (info->shared
2558               || (fdh->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2559               || (fdh->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0))
2560         {
2561           if (fdh->dynindx == -1)
2562             if (! bfd_elf64_link_record_dynamic_symbol (info, fdh))
2563               return false;
2564           fdh->elf_link_hash_flags |= (h->elf_link_hash_flags
2565                                        & (ELF_LINK_HASH_REF_REGULAR
2566                                           | ELF_LINK_HASH_REF_DYNAMIC
2567                                           | ELF_LINK_HASH_REF_REGULAR_NONWEAK
2568                                           | ELF_LINK_NON_GOT_REF));
2569           if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2570             {
2571               fdh->plt.refcount = h->plt.refcount;
2572               fdh->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2573             }
2574           ((struct ppc_link_hash_entry *) fdh)->is_func_descriptor = 1;
2575           fdh->root.root.string = h->root.root.string + 1;
2576         }
2577
2578       /* Now that the info is on the function descriptor, clear the
2579          function code sym info.  Any function code syms for which we
2580          don't have a definition in a regular file, we force local.
2581          This prevents a shared library from exporting syms that have
2582          been imported from another library.  Function code syms that
2583          are really in the library we must leave global to prevent the
2584          linker dragging in a definition from a static library.  */
2585       force_local = ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2586                      && info->shared);
2587       _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2588     }
2589
2590   return true;
2591 }
2592
2593 #define MIN_SAVE_FPR 14
2594 #define MAX_SAVE_FPR 31
2595
2596 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
2597    this hook to a) provide some gcc support functions, and b) transfer
2598    dynamic linking information gathered so far on function code symbol
2599    entries, to their corresponding function descriptor symbol entries.  */
2600 static boolean
2601 ppc64_elf_func_desc_adjust (obfd, info)
2602      bfd *obfd ATTRIBUTE_UNUSED;
2603      struct bfd_link_info *info;
2604 {
2605   struct ppc_link_hash_table *htab;
2606   unsigned int lowest_savef = MAX_SAVE_FPR + 2;
2607   unsigned int lowest_restf = MAX_SAVE_FPR + 2;
2608   unsigned int i;
2609   struct elf_link_hash_entry *h;
2610   char sym[10];
2611
2612   htab = ppc_hash_table (info);
2613
2614   if (htab->sfpr == NULL)
2615     /* We don't have any relocs.  */
2616     return true;
2617
2618   /* First provide any missing ._savef* and ._restf* functions.  */
2619   memcpy (sym, "._savef14", 10);
2620   for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
2621     {
2622       sym[7] = i / 10 + '0';
2623       sym[8] = i % 10 + '0';
2624       h = elf_link_hash_lookup (&htab->elf, sym, false, false, true);
2625       if (h != NULL
2626           && h->root.type == bfd_link_hash_undefined)
2627         {
2628           if (lowest_savef > i)
2629             lowest_savef = i;
2630           h->root.type = bfd_link_hash_defined;
2631           h->root.u.def.section = htab->sfpr;
2632           h->root.u.def.value = (i - lowest_savef) * 4;
2633           h->type = STT_FUNC;
2634           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2635           _bfd_elf_link_hash_hide_symbol (info, h, info->shared);
2636         }
2637     }
2638
2639   memcpy (sym, "._restf14", 10);
2640   for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
2641     {
2642       sym[7] = i / 10 + '0';
2643       sym[8] = i % 10 + '0';
2644       h = elf_link_hash_lookup (&htab->elf, sym, false, false, true);
2645       if (h != NULL
2646           && h->root.type == bfd_link_hash_undefined)
2647         {
2648           if (lowest_restf > i)
2649             lowest_restf = i;
2650           h->root.type = bfd_link_hash_defined;
2651           h->root.u.def.section = htab->sfpr;
2652           h->root.u.def.value = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
2653                                  + (i - lowest_restf) * 4);
2654           h->type = STT_FUNC;
2655           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2656           _bfd_elf_link_hash_hide_symbol (info, h, info->shared);
2657         }
2658     }
2659
2660   htab->sfpr->_raw_size = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
2661                            + (MAX_SAVE_FPR + 2 - lowest_restf) * 4);
2662
2663   if (htab->sfpr->_raw_size == 0)
2664     {
2665       _bfd_strip_section_from_output (info, htab->sfpr);
2666     }
2667   else
2668     {
2669       bfd_byte *p = (bfd_byte *) bfd_alloc (htab->elf.dynobj,
2670                                             htab->sfpr->_raw_size);
2671       if (p == NULL)
2672         return false;
2673       htab->sfpr->contents = p;
2674
2675       for (i = lowest_savef; i <= MAX_SAVE_FPR; i++)
2676         {
2677           unsigned int fpr = i << 21;
2678           unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
2679           bfd_put_32 (htab->elf.dynobj, STFD_FR0_0R1 + fpr + stackoff, p);
2680           p += 4;
2681         }
2682       bfd_put_32 (htab->elf.dynobj, BLR, p);
2683       p += 4;
2684
2685       for (i = lowest_restf; i <= MAX_SAVE_FPR; i++)
2686         {
2687           unsigned int fpr = i << 21;
2688           unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
2689           bfd_put_32 (htab->elf.dynobj, LFD_FR0_0R1 + fpr + stackoff, p);
2690           p += 4;
2691         }
2692       bfd_put_32 (htab->elf.dynobj, BLR, p);
2693       p += 4;
2694     }
2695
2696   elf_link_hash_traverse (&htab->elf, func_desc_adjust, (PTR) info);
2697   return true;
2698 }
2699
2700 /* Adjust a symbol defined by a dynamic object and referenced by a
2701    regular object.  The current definition is in some section of the
2702    dynamic object, but we're not including those sections.  We have to
2703    change the definition to something the rest of the link can
2704    understand.  */
2705
2706 static boolean
2707 ppc64_elf_adjust_dynamic_symbol (info, h)
2708      struct bfd_link_info *info;
2709      struct elf_link_hash_entry *h;
2710 {
2711   struct ppc_link_hash_table *htab;
2712   struct ppc_link_hash_entry * eh;
2713   struct ppc_dyn_relocs *p;
2714   asection *s;
2715   unsigned int power_of_two;
2716
2717   htab = ppc_hash_table (info);
2718
2719   /* Deal with function syms.  */
2720   if (h->type == STT_FUNC
2721       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2722     {
2723       /* Clear procedure linkage table information for any symbol that
2724          won't need a .plt entry.  */
2725       if (!((struct ppc_link_hash_entry *) h)->is_func_descriptor
2726           || h->plt.refcount <= 0
2727           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2728           || (! info->shared
2729               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2730               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
2731         {
2732           h->plt.offset = (bfd_vma) -1;
2733           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2734         }
2735       return true;
2736     }
2737   else
2738     h->plt.offset = (bfd_vma) -1;
2739
2740   /* If this is a weak symbol, and there is a real definition, the
2741      processor independent code will have arranged for us to see the
2742      real definition first, and we can just use the same value.  */
2743   if (h->weakdef != NULL)
2744     {
2745       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2746                   || h->weakdef->root.type == bfd_link_hash_defweak);
2747       h->root.u.def.section = h->weakdef->root.u.def.section;
2748       h->root.u.def.value = h->weakdef->root.u.def.value;
2749       return true;
2750     }
2751
2752   /* This is a reference to a symbol defined by a dynamic object which
2753      is not a function.  */
2754
2755   /* If we are creating a shared library, we must presume that the
2756      only references to the symbol are via the global offset table.
2757      For such cases we need not do anything here; the relocations will
2758      be handled correctly by relocate_section.  */
2759   if (info->shared)
2760     return true;
2761
2762   /* If there are no references to this symbol that do not use the
2763      GOT, we don't need to generate a copy reloc.  */
2764   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2765     return true;
2766
2767   eh = (struct ppc_link_hash_entry *) h;
2768   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2769     {
2770       s = p->sec->output_section;
2771       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2772         break;
2773     }
2774
2775   /* If we didn't find any dynamic relocs in read-only sections, then
2776      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2777   if (p == NULL)
2778     {
2779       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
2780       return true;
2781     }
2782
2783   /* We must allocate the symbol in our .dynbss section, which will
2784      become part of the .bss section of the executable.  There will be
2785      an entry for this symbol in the .dynsym section.  The dynamic
2786      object will contain position independent code, so all references
2787      from the dynamic object to this symbol will go through the global
2788      offset table.  The dynamic linker will use the .dynsym entry to
2789      determine the address it must put in the global offset table, so
2790      both the dynamic object and the regular object will refer to the
2791      same memory location for the variable.  */
2792
2793   /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
2794      copy the initial value out of the dynamic object and into the
2795      runtime process image.  We need to remember the offset into the
2796      .rela.bss section we are going to use.  */
2797   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2798     {
2799       htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
2800       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2801     }
2802
2803   /* We need to figure out the alignment required for this symbol.  I
2804      have no idea how ELF linkers handle this.  */
2805   power_of_two = bfd_log2 (h->size);
2806   if (power_of_two > 4)
2807     power_of_two = 4;
2808
2809   /* Apply the required alignment.  */
2810   s = htab->sdynbss;
2811   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
2812   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
2813     {
2814       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
2815         return false;
2816     }
2817
2818   /* Define the symbol as being at this point in the section.  */
2819   h->root.u.def.section = s;
2820   h->root.u.def.value = s->_raw_size;
2821
2822   /* Increment the section size to make room for the symbol.  */
2823   s->_raw_size += h->size;
2824
2825   return true;
2826 }
2827
2828 /* If given a function descriptor symbol, hide both the function code
2829    sym and the descriptor.  */
2830 static void
2831 ppc64_elf_hide_symbol (info, h, force_local)
2832      struct bfd_link_info *info;
2833      struct elf_link_hash_entry *h;
2834      boolean force_local;
2835 {
2836   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2837
2838   if (((struct ppc_link_hash_entry *) h)->is_func_descriptor)
2839     {
2840       const char *name;
2841       struct elf_link_hash_entry *fh;
2842       struct ppc_link_hash_table *htab;
2843
2844       name = h->root.root.string - 1;
2845       htab = ppc_hash_table (info);
2846       fh = elf_link_hash_lookup (&htab->elf, name, false, false, false);
2847       if (fh != NULL)
2848         _bfd_elf_link_hash_hide_symbol (info, fh, force_local);
2849     }
2850 }
2851
2852 /* This is the condition under which ppc64_elf_finish_dynamic_symbol
2853    will be called from elflink.h.  If elflink.h doesn't call our
2854    finish_dynamic_symbol routine, we'll need to do something about
2855    initializing any .plt and .got entries in ppc64_elf_relocate_section.  */
2856 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
2857   ((DYN)                                                                \
2858    && ((INFO)->shared                                                   \
2859        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
2860    && ((H)->dynindx != -1                                               \
2861        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
2862
2863 /* Allocate space in .plt, .got and associated reloc sections for
2864    dynamic relocs.  */
2865
2866 static boolean
2867 allocate_dynrelocs (h, inf)
2868      struct elf_link_hash_entry *h;
2869      PTR inf;
2870 {
2871   struct bfd_link_info *info;
2872   struct ppc_link_hash_table *htab;
2873   asection *s;
2874   struct ppc_link_hash_entry *eh;
2875   struct ppc_dyn_relocs *p;
2876
2877   if (h->root.type == bfd_link_hash_indirect
2878       || h->root.type == bfd_link_hash_warning)
2879     return true;
2880
2881   info = (struct bfd_link_info *) inf;
2882   htab = ppc_hash_table (info);
2883
2884   if (htab->elf.dynamic_sections_created
2885       && h->plt.refcount > 0
2886       && h->dynindx != -1)
2887     {
2888       BFD_ASSERT (((struct ppc_link_hash_entry *) h)->is_func_descriptor);
2889
2890       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
2891         {
2892           /* If this is the first .plt entry, make room for the special
2893              first entry.  */
2894           s = htab->splt;
2895           if (s->_raw_size == 0)
2896             s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
2897
2898           h->plt.offset = s->_raw_size;
2899
2900           /* Make room for this entry.  */
2901           s->_raw_size += PLT_ENTRY_SIZE;
2902
2903           /* Make room for the .stub and .glink code.  */
2904           s = htab->sstub;
2905           s->_raw_size += PLT_CALL_STUB_SIZE;
2906
2907           s = htab->sglink;
2908           if (s->_raw_size == 0)
2909             s->_raw_size += GLINK_CALL_STUB_SIZE;
2910           /* We need bigger stubs past index 32767.  */
2911           if (s->_raw_size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
2912             s->_raw_size += 4;
2913           s->_raw_size += 2*4;
2914
2915           /* We also need to make an entry in the .rela.plt section.  */
2916           s = htab->srelplt;
2917           s->_raw_size += sizeof (Elf64_External_Rela);
2918         }
2919       else
2920         {
2921           h->plt.offset = (bfd_vma) -1;
2922           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2923         }
2924     }
2925   else
2926     {
2927       h->plt.offset = (bfd_vma) -1;
2928       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2929     }
2930
2931   if (h->got.refcount > 0)
2932     {
2933       boolean dyn;
2934
2935       /* Make sure this symbol is output as a dynamic symbol.
2936          Undefined weak syms won't yet be marked as dynamic.  */
2937       if (h->dynindx == -1
2938           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2939         {
2940           if (! bfd_elf64_link_record_dynamic_symbol (info, h))
2941             return false;
2942         }
2943
2944       s = htab->sgot;
2945       h->got.offset = s->_raw_size;
2946       s->_raw_size += 8;
2947       dyn = htab->elf.dynamic_sections_created;
2948       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
2949         htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
2950     }
2951   else
2952     h->got.offset = (bfd_vma) -1;
2953
2954   eh = (struct ppc_link_hash_entry *) h;
2955   if (eh->dyn_relocs == NULL)
2956     return true;
2957
2958   /* In the shared -Bsymbolic case, discard space allocated for
2959      dynamic pc-relative relocs against symbols which turn out to be
2960      defined in regular objects.  For the normal shared case, discard
2961      space for relocs that have become local due to symbol visibility
2962      changes.  */
2963
2964   if (info->shared)
2965     {
2966       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2967           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2968               || info->symbolic))
2969         {
2970           struct ppc_dyn_relocs **pp;
2971
2972           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2973             {
2974               p->count -= p->pc_count;
2975               p->pc_count = 0;
2976               if (p->count == 0)
2977                 *pp = p->next;
2978               else
2979                 pp = &p->next;
2980             }
2981         }
2982     }
2983   else
2984     {
2985       /* For the non-shared case, discard space for relocs against
2986          symbols which turn out to need copy relocs or are not
2987          dynamic.  */
2988
2989       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2990           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2991                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2992               || (htab->elf.dynamic_sections_created
2993                   && (h->root.type == bfd_link_hash_undefweak
2994                       || h->root.type == bfd_link_hash_undefined))))
2995         {
2996           /* Make sure this symbol is output as a dynamic symbol.
2997              Undefined weak syms won't yet be marked as dynamic.  */
2998           if (h->dynindx == -1
2999               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3000             {
3001               if (! bfd_elf64_link_record_dynamic_symbol (info, h))
3002                 return false;
3003             }
3004
3005           /* If that succeeded, we know we'll be keeping all the
3006              relocs.  */
3007           if (h->dynindx != -1)
3008             goto keep;
3009         }
3010
3011       eh->dyn_relocs = NULL;
3012
3013     keep: ;
3014     }
3015
3016   /* Finally, allocate space.  */
3017   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3018     {
3019       asection *sreloc = elf_section_data (p->sec)->sreloc;
3020       sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
3021     }
3022
3023   return true;
3024 }
3025
3026 /* Find any dynamic relocs that apply to read-only sections.  */
3027
3028 static boolean
3029 readonly_dynrelocs (h, inf)
3030      struct elf_link_hash_entry *h;
3031      PTR inf;
3032 {
3033   struct ppc_link_hash_entry *eh;
3034   struct ppc_dyn_relocs *p;
3035
3036   eh = (struct ppc_link_hash_entry *) h;
3037   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3038     {
3039       asection *s = p->sec->output_section;
3040
3041       if (s != NULL && (s->flags & SEC_READONLY) != 0)
3042         {
3043           struct bfd_link_info *info = (struct bfd_link_info *) inf;
3044
3045           info->flags |= DF_TEXTREL;
3046
3047           /* Not an error, just cut short the traversal.  */
3048           return false;
3049         }
3050     }
3051   return true;
3052 }
3053
3054 /* Set the sizes of the dynamic sections.  */
3055
3056 static boolean
3057 ppc64_elf_size_dynamic_sections (output_bfd, info)
3058      bfd *output_bfd ATTRIBUTE_UNUSED;
3059      struct bfd_link_info *info;
3060 {
3061   struct ppc_link_hash_table *htab;
3062   bfd *dynobj;
3063   asection *s;
3064   boolean relocs;
3065   bfd *ibfd;
3066
3067   htab = ppc_hash_table (info);
3068   dynobj = htab->elf.dynobj;
3069   if (dynobj == NULL)
3070     abort ();
3071
3072   if (htab->elf.dynamic_sections_created)
3073     {
3074       /* Set the contents of the .interp section to the interpreter.  */
3075       if (! info->shared)
3076         {
3077           s = bfd_get_section_by_name (dynobj, ".interp");
3078           if (s == NULL)
3079             abort ();
3080           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3081           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3082         }
3083     }
3084
3085   /* Set up .got offsets for local syms, and space for local dynamic
3086      relocs.  */
3087   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3088     {
3089       bfd_signed_vma *local_got;
3090       bfd_signed_vma *end_local_got;
3091       bfd_size_type locsymcount;
3092       Elf_Internal_Shdr *symtab_hdr;
3093       asection *srel;
3094
3095       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3096         continue;
3097
3098       for (s = ibfd->sections; s != NULL; s = s->next)
3099         {
3100           struct ppc_dyn_relocs *p;
3101
3102           for (p = *((struct ppc_dyn_relocs **)
3103                      &elf_section_data (s)->local_dynrel);
3104                p != NULL;
3105                p = p->next)
3106             {
3107               if (!bfd_is_abs_section (p->sec)
3108                   && bfd_is_abs_section (p->sec->output_section))
3109                 {
3110                   /* Input section has been discarded, either because
3111                      it is a copy of a linkonce section or due to
3112                      linker script /DISCARD/, so we'll be discarding
3113                      the relocs too.  */
3114                 }
3115               else if (p->count != 0)
3116                 {
3117                   srel = elf_section_data (p->sec)->sreloc;
3118                   srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
3119                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3120                     info->flags |= DF_TEXTREL;
3121                 }
3122             }
3123         }
3124
3125       local_got = elf_local_got_refcounts (ibfd);
3126       if (!local_got)
3127         continue;
3128
3129       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3130       locsymcount = symtab_hdr->sh_info;
3131       end_local_got = local_got + locsymcount;
3132       s = htab->sgot;
3133       srel = htab->srelgot;
3134       for (; local_got < end_local_got; ++local_got)
3135         {
3136           if (*local_got > 0)
3137             {
3138               *local_got = s->_raw_size;
3139               s->_raw_size += 8;
3140               if (info->shared)
3141                 srel->_raw_size += sizeof (Elf64_External_Rela);
3142             }
3143           else
3144             *local_got = (bfd_vma) -1;
3145         }
3146     }
3147
3148   /* Allocate global sym .plt and .got entries, and space for global
3149      sym dynamic relocs.  */
3150   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
3151
3152   /* We now have determined the sizes of the various dynamic sections.
3153      Allocate memory for them.  */
3154   relocs = false;
3155   for (s = dynobj->sections; s != NULL; s = s->next)
3156     {
3157       bfd_vma size;
3158
3159       if ((s->flags & SEC_LINKER_CREATED) == 0)
3160         continue;
3161
3162       if (s == htab->splt
3163           || s == htab->sgot
3164           || s == htab->sstub
3165           || s == htab->sglink)
3166         {
3167           /* Strip this section if we don't need it; see the
3168              comment below.  */
3169         }
3170       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
3171         {
3172           if (s->_raw_size == 0)
3173             {
3174               /* If we don't need this section, strip it from the
3175                  output file.  This is mostly to handle .rela.bss and
3176                  .rela.plt.  We must create both sections in
3177                  create_dynamic_sections, because they must be created
3178                  before the linker maps input sections to output
3179                  sections.  The linker does that before
3180                  adjust_dynamic_symbol is called, and it is that
3181                  function which decides whether anything needs to go
3182                  into these sections.  */
3183             }
3184           else
3185             {
3186               if (s != htab->srelplt)
3187                 relocs = true;
3188
3189               /* We use the reloc_count field as a counter if we need
3190                  to copy relocs into the output file.  */
3191               s->reloc_count = 0;
3192             }
3193         }
3194       else
3195         {
3196           /* It's not one of our sections, so don't allocate space.  */
3197           continue;
3198         }
3199
3200       if (s->_raw_size == 0)
3201         {
3202           _bfd_strip_section_from_output (info, s);
3203           continue;
3204         }
3205
3206       /* Allocate memory for the section contents.  We use bfd_zalloc
3207          here in case unused entries are not reclaimed before the
3208          section's contents are written out.  This should not happen,
3209          but this way if it does, we get a R_PPC64_NONE reloc instead
3210          of garbage.  */
3211       size = s->_raw_size;
3212       if (s == htab->sstub)
3213         {
3214           /* .stub may grow.  Allocate enough for the maximum growth.  */
3215           size += (size + 65536 + 65535) / 65536 * 4;
3216         }
3217       s->contents = (bfd_byte *) bfd_zalloc (dynobj, size);
3218       if (s->contents == NULL)
3219         return false;
3220     }
3221
3222   if (htab->elf.dynamic_sections_created)
3223     {
3224       /* Add some entries to the .dynamic section.  We fill in the
3225          values later, in ppc64_elf_finish_dynamic_sections, but we
3226          must add the entries now so that we get the correct size for
3227          the .dynamic section.  The DT_DEBUG entry is filled in by the
3228          dynamic linker and used by the debugger.  */
3229 #define add_dynamic_entry(TAG, VAL) \
3230   bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3231
3232       if (!info->shared)
3233         {
3234           if (!add_dynamic_entry (DT_DEBUG, 0))
3235             return false;
3236         }
3237
3238       if (htab->splt->_raw_size != 0)
3239         {
3240           if (!add_dynamic_entry (DT_PLTGOT, 0)
3241               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3242               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3243               || !add_dynamic_entry (DT_JMPREL, 0)
3244               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
3245             return false;
3246         }
3247
3248       if (NO_OPD_RELOCS)
3249         {
3250           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
3251               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
3252             return false;
3253         }
3254
3255       if (relocs)
3256         {
3257           if (!add_dynamic_entry (DT_RELA, 0)
3258               || !add_dynamic_entry (DT_RELASZ, 0)
3259               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3260             return false;
3261
3262           /* If any dynamic relocs apply to a read-only section,
3263              then we need a DT_TEXTREL entry.  */
3264           if ((info->flags & DF_TEXTREL) == 0)
3265             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
3266                                     (PTR) info);
3267
3268           if ((info->flags & DF_TEXTREL) != 0)
3269             {
3270               if (!add_dynamic_entry (DT_TEXTREL, 0))
3271                 return false;
3272             }
3273         }
3274     }
3275 #undef add_dynamic_entry
3276
3277   return true;
3278 }
3279
3280 /* Called after we have seen all the input files/sections, but before
3281    final symbol resolution and section placement has been determined.
3282
3283    We use this hook to provide a value for TOCstart, which we store in
3284    the output bfd elf_gp.  */
3285
3286 boolean
3287 ppc64_elf_set_toc (obfd, info)
3288      bfd *obfd;
3289      struct bfd_link_info *info;
3290 {
3291   if (!info->relocateable)
3292     {
3293       asection *s;
3294       bfd_vma TOCstart;
3295
3296       /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
3297          order.  The TOC starts where the first of these sections starts.  */
3298       s = bfd_get_section_by_name (obfd, ".got");
3299       if (s == NULL)
3300         s = bfd_get_section_by_name (obfd, ".toc");
3301       if (s == NULL)
3302         s = bfd_get_section_by_name (obfd, ".tocbss");
3303       if (s == NULL)
3304         s = bfd_get_section_by_name (obfd, ".plt");
3305       if (s == NULL)
3306         {
3307           /* This may happen for
3308              o  references to TOC base (SYM@toc / TOC[tc0]) without a
3309              .toc directive
3310              o  bad linker script
3311              o --gc-sections and empty TOC sections
3312
3313              FIXME: Warn user?  */
3314
3315           /* Look for a likely section.  We probably won't even be
3316              using TOCstart.  */
3317           for (s = obfd->sections; s != NULL; s = s->next)
3318             if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
3319                 == (SEC_ALLOC | SEC_SMALL_DATA))
3320               break;
3321           if (s == NULL)
3322             for (s = obfd->sections; s != NULL; s = s->next)
3323               if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
3324                   == (SEC_ALLOC | SEC_SMALL_DATA))
3325                 break;
3326           if (s == NULL)
3327             for (s = obfd->sections; s != NULL; s = s->next)
3328               if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
3329                 break;
3330           if (s == NULL)
3331             for (s = obfd->sections; s != NULL; s = s->next)
3332               if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
3333                 break;
3334         }
3335
3336       TOCstart = 0;
3337       if (s != NULL)
3338         TOCstart = s->output_section->vma + s->output_offset;
3339
3340       elf_gp (obfd) = TOCstart;
3341     }
3342   return true;
3343 }
3344
3345 /* PowerPC64 .plt entries are 24 bytes long, which doesn't divide
3346    evenly into 64k.  Sometimes with a large enough .plt, we'll need to
3347    use offsets differing in the high 16 bits when accessing a .plt
3348    entry from a .plt call stub.  This function adjusts the size of
3349    .stub to accommodate the extra stub instruction needed in such
3350    cases.  */
3351
3352 boolean
3353 ppc64_elf_size_stubs (obfd, info, changed)
3354      bfd *obfd;
3355      struct bfd_link_info *info;
3356      int *changed;
3357 {
3358   struct ppc_link_hash_table *htab = ppc_hash_table (info);
3359   bfd_vma plt_offset, next_64k;
3360   long base, num, extra;
3361
3362   /* .plt and .stub should be both present, or both absent.  */
3363   if ((htab->splt == NULL || htab->splt->_raw_size == 0)
3364       != (htab->sstub == NULL || htab->sstub->_raw_size == 0))
3365     abort ();
3366
3367   /* If no .plt, then nothing to do.  */
3368   if (htab->splt == NULL || htab->splt->_raw_size == 0)
3369     return true;
3370
3371   plt_offset = (htab->splt->output_section->vma
3372                 + htab->splt->output_offset
3373                 - elf_gp (obfd));
3374   next_64k = (plt_offset + 65535) & -65536;
3375
3376   /* If the .plt doesn't have any entries crossing a 64k boundary,
3377      then there is no need for bigger stubs.  */
3378   if (plt_offset + htab->splt->_raw_size <= next_64k)
3379     return true;
3380
3381   /* OK, so we have at least one transition.  Since .plt entries are
3382      24 bytes long, we'll strike it lucky every 3*64k, with the 64k
3383      boundary between .plt entries.  */
3384   base = next_64k / 65536;
3385   num = (plt_offset + htab->splt->_raw_size - next_64k) / 65536;
3386   extra = (base % 3 + num + 1) * 2 / 3;
3387
3388   /* Allow one extra instruction for each EXTRA.  The change in .stub
3389      may change the location of .toc and .plt.  .toc and .plt ought to
3390      move as a group, but someone might be playing with eg. .plt
3391      alignment, so don't allow .stub size to decrease.  */
3392   if (htab->sstub->_cooked_size < htab->sstub->_raw_size + extra * 4)
3393     {
3394       htab->sstub->_cooked_size = htab->sstub->_raw_size + extra * 4;
3395       *changed = true;
3396     }
3397   return true;
3398 }
3399
3400 /* Build a .plt call stub.  */
3401
3402 static bfd_byte *
3403 build_plt_stub (obfd, p, offset, glink)
3404      bfd *obfd;
3405      bfd_byte *p;
3406      int offset;
3407      int glink;
3408 {
3409 #define PPC_LO(v) ((v) & 0xffff)
3410 #define PPC_HI(v) (((v) >> 16) & 0xffff)
3411 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
3412
3413   if (glink)
3414     bfd_put_32 (obfd, LD_R2_40R1, p),                   p += 4;
3415   bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
3416   if (!glink)
3417     bfd_put_32 (obfd, STD_R2_40R1, p),                  p += 4;
3418   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
3419   if (PPC_HA (offset + 8) != PPC_HA (offset))
3420     bfd_put_32 (obfd, ADDIS_R12_R12_1, p),              p += 4;
3421   offset += 8;
3422   bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p),   p += 4;
3423   if (PPC_HA (offset + 8) != PPC_HA (offset))
3424     bfd_put_32 (obfd, ADDIS_R12_R12_1, p),              p += 4;
3425   offset += 8;
3426   bfd_put_32 (obfd, MTCTR_R11, p),                      p += 4;
3427   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
3428   bfd_put_32 (obfd, BCTR, p),                           p += 4;
3429   return p;
3430 }
3431
3432 /* Build the stubs for one function call.  */
3433
3434 static boolean
3435 build_one_stub (h, inf)
3436      struct elf_link_hash_entry *h;
3437      PTR inf;
3438 {
3439   struct bfd_link_info *info;
3440   struct ppc_link_hash_table *htab;
3441
3442   if (h->root.type == bfd_link_hash_indirect
3443       || h->root.type == bfd_link_hash_warning)
3444     return true;
3445
3446   info = (struct bfd_link_info *) inf;
3447   htab = ppc_hash_table (info);
3448
3449   if (htab->elf.dynamic_sections_created
3450       && h->plt.offset != (bfd_vma) -1
3451       && ((struct ppc_link_hash_entry *) h)->is_func_descriptor)
3452     {
3453       struct elf_link_hash_entry *fh;
3454       asection *s;
3455       bfd_vma plt_r2;
3456       bfd_byte *p;
3457       unsigned int indx;
3458
3459       fh = elf_link_hash_lookup (&htab->elf, h->root.root.string - 1,
3460                                  false, false, true);
3461
3462       if (fh == NULL)
3463         abort ();
3464
3465       BFD_ASSERT (((struct ppc_link_hash_entry *) fh)->is_func);
3466
3467       /* Build the .plt call stub.  */
3468       plt_r2 = (htab->splt->output_section->vma
3469                 + htab->splt->output_offset
3470                 + h->plt.offset
3471                 - elf_gp (htab->splt->output_section->owner)
3472                 - TOC_BASE_OFF);
3473
3474       if (plt_r2 + 0x80000000 > 0xffffffff
3475           || (plt_r2 & 3) != 0)
3476         {
3477           (*_bfd_error_handler)
3478             (_("linkage table error against `%s'"),
3479              h->root.root.string);
3480           bfd_set_error (bfd_error_bad_value);
3481           htab->plt_overflow = true;
3482           return false;
3483         }
3484
3485       s = htab->sstub;
3486       /* Steal plt.offset to store the stub offset.  */
3487       fh->plt.offset = s->_cooked_size;
3488       p = s->contents + s->_cooked_size;
3489       p = build_plt_stub (s->owner, p, (int) plt_r2, 0);
3490       s->_cooked_size = p - s->contents;
3491
3492       /* Build the .glink lazy link call stub.  */
3493       s = htab->sglink;
3494       p = s->contents + s->_cooked_size;
3495       indx = s->reloc_count;
3496       if (indx < 0x8000)
3497         {
3498           bfd_put_32 (s->owner, LI_R0_0 | indx, p);
3499           p += 4;
3500         }
3501       else
3502         {
3503           bfd_put_32 (s->owner, LIS_R0_0 | PPC_HI (indx), p);
3504           p += 4;
3505           bfd_put_32 (s->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
3506           p += 4;
3507         }
3508       bfd_put_32 (s->owner, B_DOT | ((s->contents - p) & 0x3fffffc), p);
3509       p += 4;
3510       s->_cooked_size = p - s->contents;
3511       s->reloc_count += 1;
3512     }
3513   return true;
3514 }
3515
3516 boolean
3517 ppc64_elf_build_stubs (obfd, info)
3518      bfd *obfd;
3519      struct bfd_link_info *info;
3520 {
3521   struct ppc_link_hash_table *htab = ppc_hash_table (info);
3522   bfd_vma old_stub_size;
3523   bfd_vma plt_r2;
3524   bfd_byte *p;
3525
3526   /* If no .plt stubs, then nothing to do.  */
3527   if (htab->sstub == NULL || htab->sstub->_raw_size == 0)
3528     return true;
3529
3530   old_stub_size = htab->sstub->_cooked_size;
3531   htab->sstub->_cooked_size = 0;
3532
3533   /* Build the .glink plt call stub.  */
3534   plt_r2 = (htab->splt->output_section->vma
3535             + htab->splt->output_offset
3536             - elf_gp (obfd)
3537             - TOC_BASE_OFF);
3538   p = htab->sglink->contents;
3539   p = build_plt_stub (htab->sglink->owner, p, (int) plt_r2, 1);
3540   while (p - htab->sglink->contents < GLINK_CALL_STUB_SIZE)
3541     {
3542       bfd_put_32 (htab->sglink->owner, NOP, p);
3543       p += 4;
3544     }
3545   htab->sglink->_cooked_size = p - htab->sglink->contents;
3546
3547   /* Use reloc_count to count entries.  */
3548   htab->sglink->reloc_count = 0;
3549
3550   elf_link_hash_traverse (&htab->elf, build_one_stub, (PTR) info);
3551   htab->sglink->reloc_count = 0;
3552
3553   if (htab->plt_overflow)
3554     return false;
3555
3556   if (old_stub_size != htab->sstub->_cooked_size
3557       || htab->sglink->_raw_size != htab->sglink->_cooked_size)
3558     {
3559       (*_bfd_error_handler)
3560         (_("stub section size doesn't match calculated size"));
3561       bfd_set_error (bfd_error_bad_value);
3562       return false;
3563     }
3564   return true;
3565 }
3566
3567 /* Set up any other section flags and such that may be necessary.  */
3568
3569 static boolean
3570 ppc64_elf_fake_sections (abfd, shdr, asect)
3571      bfd *abfd ATTRIBUTE_UNUSED;
3572      Elf64_Internal_Shdr *shdr;
3573      asection *asect;
3574 {
3575   if ((asect->flags & SEC_EXCLUDE) != 0)
3576     shdr->sh_flags |= SHF_EXCLUDE;
3577
3578   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
3579     shdr->sh_type = SHT_ORDERED;
3580
3581   return true;
3582 }
3583
3584 /* The RELOCATE_SECTION function is called by the ELF backend linker
3585    to handle the relocations for a section.
3586
3587    The relocs are always passed as Rela structures; if the section
3588    actually uses Rel structures, the r_addend field will always be
3589    zero.
3590
3591    This function is responsible for adjust the section contents as
3592    necessary, and (if using Rela relocs and generating a
3593    relocateable output file) adjusting the reloc addend as
3594    necessary.
3595
3596    This function does not have to worry about setting the reloc
3597    address or the reloc symbol index.
3598
3599    LOCAL_SYMS is a pointer to the swapped in local symbols.
3600
3601    LOCAL_SECTIONS is an array giving the section in the input file
3602    corresponding to the st_shndx field of each local symbol.
3603
3604    The global hash table entry for the global symbols can be found
3605    via elf_sym_hashes (input_bfd).
3606
3607    When generating relocateable output, this function must handle
3608    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
3609    going to be the section symbol corresponding to the output
3610    section, which means that the addend must be adjusted
3611    accordingly.  */
3612
3613 static boolean
3614 ppc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
3615                             contents, relocs, local_syms, local_sections)
3616      bfd *output_bfd;
3617      struct bfd_link_info *info;
3618      bfd *input_bfd;
3619      asection *input_section;
3620      bfd_byte *contents;
3621      Elf_Internal_Rela *relocs;
3622      Elf_Internal_Sym *local_syms;
3623      asection **local_sections;
3624 {
3625   struct ppc_link_hash_table *htab;
3626   Elf_Internal_Shdr *symtab_hdr;
3627   struct elf_link_hash_entry **sym_hashes;
3628   Elf_Internal_Rela *rel;
3629   Elf_Internal_Rela *relend;
3630   bfd_vma *local_got_offsets;
3631   bfd_vma TOCstart;
3632   boolean ret = true;
3633   boolean is_opd;
3634
3635   /* Initialize howto table if needed.  */
3636   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
3637     ppc_howto_init ();
3638
3639   htab = ppc_hash_table (info);
3640   local_got_offsets = elf_local_got_offsets (input_bfd);
3641   TOCstart = elf_gp (output_bfd);
3642   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3643   sym_hashes = elf_sym_hashes (input_bfd);
3644   is_opd = strcmp (bfd_get_section_name (abfd, input_section), ".opd") == 0;
3645
3646   rel = relocs;
3647   relend = relocs + input_section->reloc_count;
3648   for (; rel < relend; rel++)
3649     {
3650       enum elf_ppc_reloc_type r_type;
3651       bfd_vma offset;
3652       bfd_vma addend;
3653       bfd_reloc_status_type r;
3654       Elf_Internal_Sym *sym;
3655       asection *sec;
3656       struct elf_link_hash_entry *h;
3657       const char *sym_name;
3658       unsigned long r_symndx;
3659       bfd_vma relocation;
3660       boolean unresolved_reloc;
3661       boolean has_nop;
3662       long insn;
3663
3664       r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
3665       r_symndx = ELF64_R_SYM (rel->r_info);
3666
3667       if (info->relocateable)
3668         {
3669           /* This is a relocatable link.  We don't have to change
3670              anything, unless the reloc is against a section symbol,
3671              in which case we have to adjust according to where the
3672              section symbol winds up in the output section.  */
3673           if (r_symndx < symtab_hdr->sh_info)
3674             {
3675               sym = local_syms + r_symndx;
3676               if ((unsigned) ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3677                 {
3678                   sec = local_sections[r_symndx];
3679                   rel->r_addend += sec->output_offset + sym->st_value;
3680                 }
3681             }
3682           continue;
3683         }
3684
3685       /* This is a final link.  */
3686
3687       offset = rel->r_offset;
3688       addend = rel->r_addend;
3689       r = bfd_reloc_other;
3690       sym = (Elf_Internal_Sym *) 0;
3691       sec = (asection *) 0;
3692       h = (struct elf_link_hash_entry *) 0;
3693       sym_name = (const char *) 0;
3694       unresolved_reloc = false;
3695
3696       if (r_type == R_PPC64_TOC)
3697         {
3698           /* Relocation value is TOC base.  Symbol is ignored.  */
3699           relocation = TOCstart + TOC_BASE_OFF;
3700         }
3701       else if (r_symndx < symtab_hdr->sh_info)
3702         {
3703           /* It's a local symbol.  */
3704           sym = local_syms + r_symndx;
3705           sec = local_sections[r_symndx];
3706           sym_name = "<local symbol>";
3707
3708           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3709           addend = rel->r_addend;
3710         }
3711       else
3712         {
3713           /* It's a global symbol.  */
3714           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3715           while (h->root.type == bfd_link_hash_indirect
3716                  || h->root.type == bfd_link_hash_warning)
3717             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3718           sym_name = h->root.root.string;
3719           relocation = 0;
3720           if (h->root.type == bfd_link_hash_defined
3721               || h->root.type == bfd_link_hash_defweak)
3722             {
3723               sec = h->root.u.def.section;
3724               if (sec->output_section == NULL)
3725                 /* Set a flag that will be cleared later if we find a
3726                    relocation value for this symbol.  output_section
3727                    is typically NULL for symbols satisfied by a shared
3728                    library.  */
3729                 unresolved_reloc = true;
3730               else
3731                 relocation = (h->root.u.def.value
3732                               + sec->output_section->vma
3733                               + sec->output_offset);
3734             }
3735           else if (h->root.type == bfd_link_hash_undefweak)
3736             ;
3737           else if (info->shared
3738                    && (!info->symbolic || info->allow_shlib_undefined)
3739                    && !info->no_undefined
3740                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3741             ;
3742           else
3743             {
3744               if (! ((*info->callbacks->undefined_symbol)
3745                      (info, h->root.root.string, input_bfd, input_section,
3746                       offset, (!info->shared
3747                                || info->no_undefined
3748                                || ELF_ST_VISIBILITY (h->other)))))
3749                 return false;
3750             }
3751         }
3752
3753       /* First handle relocations that tweak non-addend part of insn.  */
3754       insn = 0;
3755       switch (r_type)
3756         {
3757         default:
3758           break;
3759
3760           /* Branch taken prediction relocations.  */
3761         case R_PPC64_ADDR14_BRTAKEN:
3762         case R_PPC64_REL14_BRTAKEN:
3763           insn = 0x01 << 21; /* Set 't' bit, lowest bit of BO field. */
3764           /* Fall thru. */
3765
3766           /* Branch not taken prediction relocations.  */
3767         case R_PPC64_ADDR14_BRNTAKEN:
3768         case R_PPC64_REL14_BRNTAKEN:
3769           insn |= bfd_get_32 (output_bfd, contents + offset) & ~(0x01 << 21);
3770           /* Set 'a' bit.  This is 0b00010 in BO field for branch on CR(BI)
3771              insns (BO == 001at or 011at), and 0b01000 for branch on CTR
3772              insns (BO == 1a00t or 1a01t).  */
3773           if ((insn & (0x14 << 21)) == (0x04 << 21))
3774             insn |= 0x02 << 21;
3775           else if ((insn & (0x14 << 21)) == (0x10 << 21))
3776             insn |= 0x08 << 21;
3777           else
3778             break;
3779
3780           bfd_put_32 (output_bfd, (bfd_vma) insn, contents + offset);
3781           break;
3782
3783         case R_PPC64_REL24:
3784         case R_PPC64_ADDR24:
3785           /* An ADDR24 or REL24 branching to a linkage function may be
3786              followed by a nop that we have to replace with a ld in
3787              order to restore the TOC base pointer.  Only calls to
3788              shared objects need to alter the TOC base.  These are
3789              recognized by their need for a PLT entry.  */
3790           has_nop = 0;
3791           if (h != NULL
3792               && h->plt.offset != (bfd_vma) -1
3793               && htab->sstub != NULL)
3794             {
3795               /* plt.offset here is the offset into the stub section.  */
3796               relocation = (htab->sstub->output_section->vma
3797                             + htab->sstub->output_offset
3798                             + h->plt.offset);
3799               unresolved_reloc = false;
3800
3801               /* Make sure that there really is an instruction after
3802                  the branch that we can decode.  */
3803               if (offset + 8 <= input_section->_cooked_size)
3804                 {
3805                   bfd_byte *pnext;
3806
3807                   pnext = contents + offset + 4;
3808                   insn = bfd_get_32 (input_bfd, pnext);
3809
3810                   if (insn == 0x60000000         /* nop (ori  r0,r0,0) */
3811                       || insn == 0x4def7b82      /* cror 15,15,15 */
3812                       || insn == 0x4ffffb82) /* cror 31,31,31 */
3813                     {
3814                       bfd_put_32 (input_bfd,
3815                                   (bfd_vma) 0xe8410028, /* ld r2,40(r1) */
3816                                   pnext);
3817                       has_nop = 1;
3818                     }
3819                 }
3820             }
3821
3822           if (h != NULL
3823               && h->root.type == bfd_link_hash_undefweak
3824               && r_type == R_PPC64_REL24
3825               && addend == 0
3826               && relocation == 0)
3827             {
3828               /* Tweak calls to undefined weak functions to behave as
3829                  if the "called" function immediately returns.  We can
3830                  thus call to a weak function without first checking
3831                  whether the function is defined.  */
3832               relocation = 4;
3833               if (has_nop)
3834                 relocation = 8;
3835             }
3836           break;
3837         }
3838
3839       /* Set `addend'.  */
3840       switch (r_type)
3841         {
3842         default:
3843           (*_bfd_error_handler)
3844             (_("%s: unknown relocation type %d for symbol %s"),
3845              bfd_archive_filename (input_bfd), (int) r_type, sym_name);
3846
3847           bfd_set_error (bfd_error_bad_value);
3848           ret = false;
3849           continue;
3850
3851         case R_PPC64_NONE:
3852         case R_PPC_GNU_VTINHERIT:
3853         case R_PPC_GNU_VTENTRY:
3854           continue;
3855
3856           /* GOT16 relocations.  Like an ADDR16 using the symbol's
3857              address in the GOT as relocation value instead of the
3858              symbols value itself.  Also, create a GOT entry for the
3859              symbol and put the symbol value there.  */
3860         case R_PPC64_GOT16:
3861         case R_PPC64_GOT16_LO:
3862         case R_PPC64_GOT16_HI:
3863         case R_PPC64_GOT16_HA:
3864         case R_PPC64_GOT16_DS:
3865         case R_PPC64_GOT16_LO_DS:
3866           {
3867             /* Relocation is to the entry for this symbol in the global
3868                offset table.  */
3869             bfd_vma off;
3870
3871             if (htab->sgot == NULL)
3872               abort ();
3873
3874             if (h != NULL)
3875               {
3876                 boolean dyn;
3877
3878                 off = h->got.offset;
3879                 dyn = htab->elf.dynamic_sections_created;
3880                 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
3881                     || (info->shared
3882                         && (info->symbolic
3883                             || h->dynindx == -1
3884                             || (h->elf_link_hash_flags
3885                                 & ELF_LINK_FORCED_LOCAL))
3886                         && (h->elf_link_hash_flags
3887                             & ELF_LINK_HASH_DEF_REGULAR)))
3888                   {
3889                     /* This is actually a static link, or it is a
3890                        -Bsymbolic link and the symbol is defined
3891                        locally, or the symbol was forced to be local
3892                        because of a version file.  We must initialize
3893                        this entry in the global offset table.  Since the
3894                        offset must always be a multiple of 8, we use the
3895                        least significant bit to record whether we have
3896                        initialized it already.
3897
3898                        When doing a dynamic link, we create a .rel.got
3899                        relocation entry to initialize the value.  This
3900                        is done in the finish_dynamic_symbol routine.  */
3901                     if ((off & 1) != 0)
3902                       off &= ~1;
3903                     else
3904                       {
3905                         bfd_put_64 (output_bfd, relocation,
3906                                     htab->sgot->contents + off);
3907                         h->got.offset |= 1;
3908                       }
3909                   }
3910                 else
3911                   unresolved_reloc = false;
3912               }
3913             else
3914               {
3915                 if (local_got_offsets == NULL)
3916                   abort ();
3917
3918                 off = local_got_offsets[r_symndx];
3919
3920                 /* The offset must always be a multiple of 8.  We use
3921                    the least significant bit to record whether we have
3922                    already processed this entry.  */
3923                 if ((off & 1) != 0)
3924                   off &= ~1;
3925                 else
3926                   {
3927                     bfd_put_64 (output_bfd, relocation,
3928                                 htab->sgot->contents + off);
3929
3930                     if (info->shared)
3931                       {
3932                         Elf_Internal_Rela outrel;
3933                         Elf64_External_Rela *loc;
3934
3935                         /* We need to generate a R_PPC64_RELATIVE reloc
3936                            for the dynamic linker.  */
3937                         outrel.r_offset = (htab->sgot->output_section->vma
3938                                            + htab->sgot->output_offset
3939                                            + off);
3940                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
3941                         outrel.r_addend = relocation;
3942                         loc = (Elf64_External_Rela *) htab->srelgot->contents;
3943                         loc += htab->srelgot->reloc_count++;
3944                         bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3945                       }
3946
3947                     local_got_offsets[r_symndx] |= 1;
3948                   }
3949               }
3950
3951             if (off >= (bfd_vma) -2)
3952               abort ();
3953
3954             relocation = htab->sgot->output_offset + off;
3955
3956             /* TOC base (r2) is TOC start plus 0x8000.  */
3957             addend -= TOC_BASE_OFF;
3958           }
3959           break;
3960
3961         case R_PPC64_PLT16_HA:
3962         case R_PPC64_PLT16_HI:
3963         case R_PPC64_PLT16_LO:
3964         case R_PPC64_PLT32:
3965         case R_PPC64_PLT64:
3966           /* Relocation is to the entry for this symbol in the
3967              procedure linkage table.  */
3968
3969           /* Resolve a PLT reloc against a local symbol directly,
3970              without using the procedure linkage table.  */
3971           if (h == NULL)
3972             break;
3973
3974           if (h->plt.offset == (bfd_vma) -1
3975               || htab->splt == NULL)
3976             {
3977               /* We didn't make a PLT entry for this symbol.  This
3978                  happens when statically linking PIC code, or when
3979                  using -Bsymbolic.  */
3980               break;
3981             }
3982
3983           relocation = (htab->splt->output_section->vma
3984                         + htab->splt->output_offset
3985                         + h->plt.offset);
3986           unresolved_reloc = false;
3987           break;
3988
3989           /* TOC16 relocs.  We want the offset relative to the TOC base,
3990              which is the address of the start of the TOC plus 0x8000.
3991              The TOC consists of sections .got, .toc, .tocbss, and .plt,
3992              in this order.  */
3993         case R_PPC64_TOC16:
3994         case R_PPC64_TOC16_LO:
3995         case R_PPC64_TOC16_HI:
3996         case R_PPC64_TOC16_DS:
3997         case R_PPC64_TOC16_LO_DS:
3998         case R_PPC64_TOC16_HA:
3999           addend -= TOCstart + TOC_BASE_OFF;
4000           break;
4001
4002           /* Relocate against the beginning of the section.  */
4003         case R_PPC64_SECTOFF:
4004         case R_PPC64_SECTOFF_LO:
4005         case R_PPC64_SECTOFF_HI:
4006         case R_PPC64_SECTOFF_DS:
4007         case R_PPC64_SECTOFF_LO_DS:
4008         case R_PPC64_SECTOFF_HA:
4009           if (sec != (asection *) 0)
4010             addend -= sec->output_section->vma;
4011           break;
4012
4013         case R_PPC64_REL24:
4014           break;
4015
4016           /* Relocations that may need to be propagated if this is a
4017              dynamic object.  */
4018         case R_PPC64_REL14:
4019         case R_PPC64_REL14_BRNTAKEN:
4020         case R_PPC64_REL14_BRTAKEN:
4021         case R_PPC64_REL32:
4022         case R_PPC64_REL64:
4023         case R_PPC64_ADDR14:
4024         case R_PPC64_ADDR14_BRNTAKEN:
4025         case R_PPC64_ADDR14_BRTAKEN:
4026         case R_PPC64_ADDR16:
4027         case R_PPC64_ADDR16_DS:
4028         case R_PPC64_ADDR16_HA:
4029         case R_PPC64_ADDR16_HI:
4030         case R_PPC64_ADDR16_HIGHER:
4031         case R_PPC64_ADDR16_HIGHERA:
4032         case R_PPC64_ADDR16_HIGHEST:
4033         case R_PPC64_ADDR16_HIGHESTA:
4034         case R_PPC64_ADDR16_LO:
4035         case R_PPC64_ADDR16_LO_DS:
4036         case R_PPC64_ADDR24:
4037         case R_PPC64_ADDR30:
4038         case R_PPC64_ADDR32:
4039         case R_PPC64_ADDR64:
4040         case R_PPC64_UADDR16:
4041         case R_PPC64_UADDR32:
4042         case R_PPC64_UADDR64:
4043           /* r_symndx will be zero only for relocs against symbols
4044              from removed linkonce sections, or sections discarded by
4045              a linker script.  */
4046           if (r_symndx == 0)
4047             break;
4048           /* Fall thru.  */
4049
4050         case R_PPC64_TOC:
4051           if ((input_section->flags & SEC_ALLOC) == 0)
4052             break;
4053
4054           if (NO_OPD_RELOCS && is_opd)
4055             break;
4056
4057           if ((info->shared
4058                && (IS_ABSOLUTE_RELOC (r_type)
4059                    || (h != NULL
4060                        && h->dynindx != -1
4061                        && (! info->symbolic
4062                            || (h->elf_link_hash_flags
4063                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
4064               || (!info->shared
4065                   && h != NULL
4066                   && h->dynindx != -1
4067                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
4068                   && (((h->elf_link_hash_flags
4069                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4070                        && (h->elf_link_hash_flags
4071                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
4072                       || h->root.type == bfd_link_hash_undefweak
4073                       || h->root.type == bfd_link_hash_undefined)))
4074             {
4075               Elf_Internal_Rela outrel;
4076               boolean skip, relocate;
4077               asection *sreloc;
4078               Elf64_External_Rela *loc;
4079
4080               /* When generating a dynamic object, these relocations
4081                  are copied into the output file to be resolved at run
4082                  time.  */
4083
4084               skip = false;
4085
4086               outrel.r_offset =
4087                 _bfd_elf_section_offset (output_bfd, info, input_section,
4088                                          rel->r_offset);
4089               if (outrel.r_offset == (bfd_vma) -1)
4090                 skip = true;
4091
4092               outrel.r_offset += (input_section->output_section->vma
4093                                   + input_section->output_offset);
4094               outrel.r_addend = addend;
4095
4096               if (skip)
4097                 {
4098                   relocate = false;
4099                   memset (&outrel, 0, sizeof outrel);
4100                 }
4101               else if (h != NULL
4102                        && h->dynindx != -1
4103                        && !is_opd
4104                        && (!IS_ABSOLUTE_RELOC (r_type)
4105                            || !info->shared
4106                            || !info->symbolic
4107                            || (h->elf_link_hash_flags
4108                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
4109                 {
4110                   relocate = false;
4111                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
4112                 }
4113               else
4114                 {
4115                   /* This symbol is local, or marked to become local,
4116                      or this is an opd section reloc which must point
4117                      at a local function.  */
4118                   outrel.r_addend += relocation;
4119                   relocate = true;
4120                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
4121                     {
4122                       outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
4123                     }
4124                   else
4125                     {
4126                       long indx = 0;
4127
4128                       if (bfd_is_abs_section (sec))
4129                         ;
4130                       else if (sec == NULL || sec->owner == NULL)
4131                         {
4132                           bfd_set_error (bfd_error_bad_value);
4133                           return false;
4134                         }
4135                       else
4136                         {
4137                           asection *osec;
4138
4139                           osec = sec->output_section;
4140                           indx = elf_section_data (osec)->dynindx;
4141
4142                           /* We are turning this relocation into one
4143                              against a section symbol, so subtract out
4144                              the output section's address but not the
4145                              offset of the input section in the output
4146                              section.  */
4147                           outrel.r_addend -= osec->vma;
4148                         }
4149
4150                       outrel.r_info = ELF64_R_INFO (indx, r_type);
4151                     }
4152                 }
4153
4154               sreloc = elf_section_data (input_section)->sreloc;
4155               if (sreloc == NULL)
4156                 abort ();
4157
4158               loc = (Elf64_External_Rela *) sreloc->contents;
4159               loc += sreloc->reloc_count++;
4160               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4161
4162               /* If this reloc is against an external symbol, it will
4163                  be computed at runtime, so there's no need to do
4164                  anything now.  */
4165               if (! relocate)
4166                 continue;
4167             }
4168           break;
4169
4170         case R_PPC64_COPY:
4171         case R_PPC64_GLOB_DAT:
4172         case R_PPC64_JMP_SLOT:
4173         case R_PPC64_RELATIVE:
4174           /* We shouldn't ever see these dynamic relocs in relocatable
4175              files.  */
4176           /* Fall thru */
4177
4178         case R_PPC64_PLTGOT16:
4179         case R_PPC64_PLTGOT16_DS:
4180         case R_PPC64_PLTGOT16_HA:
4181         case R_PPC64_PLTGOT16_HI:
4182         case R_PPC64_PLTGOT16_LO:
4183         case R_PPC64_PLTGOT16_LO_DS:
4184         case R_PPC64_PLTREL32:
4185         case R_PPC64_PLTREL64:
4186           /* These ones haven't been implemented yet.  */
4187
4188           (*_bfd_error_handler)
4189             (_("%s: Relocation %s is not supported for symbol %s."),
4190              bfd_archive_filename (input_bfd),
4191              ppc64_elf_howto_table[(int) r_type]->name, sym_name);
4192
4193           bfd_set_error (bfd_error_invalid_operation);
4194           ret = false;
4195           continue;
4196         }
4197
4198       /* Do any further special processing.  */
4199       switch (r_type)
4200         {
4201         default:
4202           break;
4203
4204         case R_PPC64_ADDR16_HA:
4205         case R_PPC64_ADDR16_HIGHERA:
4206         case R_PPC64_ADDR16_HIGHESTA:
4207         case R_PPC64_PLT16_HA:
4208         case R_PPC64_TOC16_HA:
4209         case R_PPC64_SECTOFF_HA:
4210           /* It's just possible that this symbol is a weak symbol
4211              that's not actually defined anywhere. In that case,
4212              'sec' would be NULL, and we should leave the symbol
4213              alone (it will be set to zero elsewhere in the link).  */
4214           if (sec != NULL)
4215             /* Add 0x10000 if sign bit in 0:15 is set.  */
4216             addend += ((relocation + addend) & 0x8000) << 1;
4217           break;
4218
4219         case R_PPC64_ADDR16_DS:
4220         case R_PPC64_ADDR16_LO_DS:
4221         case R_PPC64_GOT16_DS:
4222         case R_PPC64_GOT16_LO_DS:
4223         case R_PPC64_PLT16_LO_DS:
4224         case R_PPC64_SECTOFF_DS:
4225         case R_PPC64_SECTOFF_LO_DS:
4226         case R_PPC64_TOC16_DS:
4227         case R_PPC64_TOC16_LO_DS:
4228         case R_PPC64_PLTGOT16_DS:
4229         case R_PPC64_PLTGOT16_LO_DS:
4230           if (((relocation + addend) & 3) != 0)
4231             {
4232               (*_bfd_error_handler)
4233                 (_("%s: error: relocation %s not a multiple of 4"),
4234                  bfd_archive_filename (input_bfd),
4235                  ppc64_elf_howto_table[(int) r_type]->name);
4236               bfd_set_error (bfd_error_bad_value);
4237               ret = false;
4238               continue;
4239             }
4240           break;
4241         }
4242
4243       /* FIXME: Why do we allow debugging sections to escape this error?
4244          More importantly, why do we not emit dynamic relocs above in
4245          debugging sections (which are ! SEC_ALLOC)?  If we had
4246          emitted the dynamic reloc, we could remove the fudge here.  */
4247       if (unresolved_reloc
4248           && !(info->shared
4249                && (input_section->flags & SEC_DEBUGGING) != 0
4250                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
4251         (*_bfd_error_handler)
4252           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
4253            bfd_archive_filename (input_bfd),
4254            bfd_get_section_name (input_bfd, input_section),
4255            (long) rel->r_offset,
4256            h->root.root.string);
4257
4258       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
4259                                     input_bfd,
4260                                     input_section,
4261                                     contents,
4262                                     offset,
4263                                     relocation,
4264                                     addend);
4265
4266       if (r == bfd_reloc_ok)
4267         ;
4268       else if (r == bfd_reloc_overflow)
4269         {
4270           const char *name;
4271
4272           if (h != NULL)
4273             {
4274               if (h->root.type == bfd_link_hash_undefweak
4275                   && ppc64_elf_howto_table[(int) r_type]->pc_relative)
4276                 {
4277                   /* Assume this is a call protected by other code that
4278                      detects the symbol is undefined.  If this is the case,
4279                      we can safely ignore the overflow.  If not, the
4280                      program is hosed anyway, and a little warning isn't
4281                      going to help.  */
4282
4283                   continue;
4284                 }
4285
4286               name = h->root.root.string;
4287             }
4288           else
4289             {
4290               name = bfd_elf_string_from_elf_section (input_bfd,
4291                                                       symtab_hdr->sh_link,
4292                                                       sym->st_name);
4293               if (name == NULL)
4294                 continue;
4295               if (*name == '\0')
4296                 name = bfd_section_name (input_bfd, sec);
4297             }
4298
4299           if (! ((*info->callbacks->reloc_overflow)
4300                  (info, name, ppc64_elf_howto_table[(int) r_type]->name,
4301                   (bfd_vma) 0, input_bfd, input_section, offset)))
4302             return false;
4303         }
4304       else
4305         ret = false;
4306     }
4307
4308   return ret;
4309 }
4310
4311 /* Finish up dynamic symbol handling.  We set the contents of various
4312    dynamic sections here.  */
4313
4314 static boolean
4315 ppc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
4316      bfd *output_bfd;
4317      struct bfd_link_info *info;
4318      struct elf_link_hash_entry *h;
4319      Elf_Internal_Sym *sym;
4320 {
4321   struct ppc_link_hash_table *htab;
4322   bfd *dynobj;
4323
4324   htab = ppc_hash_table (info);
4325   dynobj = htab->elf.dynobj;
4326
4327   if (h->plt.offset != (bfd_vma) -1
4328       && ((struct ppc_link_hash_entry *) h)->is_func_descriptor)
4329     {
4330       Elf_Internal_Rela rela;
4331       Elf64_External_Rela *loc;
4332
4333       /* This symbol has an entry in the procedure linkage table.  Set
4334          it up.  */
4335
4336       if (htab->splt == NULL
4337           || htab->srelplt == NULL
4338           || htab->sglink == NULL)
4339         abort ();
4340
4341       /* Create a JMP_SLOT reloc to inform the dynamic linker to
4342          fill in the PLT entry.  */
4343
4344       rela.r_offset = (htab->splt->output_section->vma
4345                        + htab->splt->output_offset
4346                        + h->plt.offset);
4347       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
4348       rela.r_addend = 0;
4349
4350       loc = (Elf64_External_Rela *) htab->srelplt->contents;
4351       loc += (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
4352       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
4353     }
4354
4355   if (h->got.offset != (bfd_vma) -1)
4356     {
4357       Elf_Internal_Rela rela;
4358       Elf64_External_Rela *loc;
4359
4360       /* This symbol has an entry in the global offset table.  Set it
4361          up.  */
4362
4363       if (htab->sgot == NULL || htab->srelgot == NULL)
4364         abort ();
4365
4366       rela.r_offset = (htab->sgot->output_section->vma
4367                        + htab->sgot->output_offset
4368                        + (h->got.offset &~ (bfd_vma) 1));
4369
4370       /* If this is a static link, or it is a -Bsymbolic link and the
4371          symbol is defined locally or was forced to be local because
4372          of a version file, we just want to emit a RELATIVE reloc.
4373          The entry in the global offset table will already have been
4374          initialized in the relocate_section function.  */
4375       if (info->shared
4376           && (info->symbolic
4377               || h->dynindx == -1
4378               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
4379           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4380         {
4381           BFD_ASSERT((h->got.offset & 1) != 0);
4382           rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
4383           rela.r_addend = (h->root.u.def.value
4384                            + h->root.u.def.section->output_section->vma
4385                            + h->root.u.def.section->output_offset);
4386         }
4387       else
4388         {
4389           BFD_ASSERT ((h->got.offset & 1) == 0);
4390           bfd_put_64 (output_bfd, (bfd_vma) 0,
4391                       htab->sgot->contents + h->got.offset);
4392           rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_GLOB_DAT);
4393           rela.r_addend = 0;
4394         }
4395
4396       loc = (Elf64_External_Rela *) htab->srelgot->contents;
4397       loc += htab->srelgot->reloc_count++;
4398       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
4399     }
4400
4401   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4402     {
4403       Elf_Internal_Rela rela;
4404       Elf64_External_Rela *loc;
4405
4406       /* This symbol needs a copy reloc.  Set it up.  */
4407
4408       if (h->dynindx == -1
4409           || (h->root.type != bfd_link_hash_defined
4410               && h->root.type != bfd_link_hash_defweak)
4411           || htab->srelbss == NULL)
4412         abort ();
4413
4414       rela.r_offset = (h->root.u.def.value
4415                        + h->root.u.def.section->output_section->vma
4416                        + h->root.u.def.section->output_offset);
4417       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
4418       rela.r_addend = 0;
4419       loc = (Elf64_External_Rela *) htab->srelbss->contents;
4420       loc += htab->srelbss->reloc_count++;
4421       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
4422     }
4423
4424   /* Mark some specially defined symbols as absolute.  */
4425   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
4426     sym->st_shndx = SHN_ABS;
4427
4428   return true;
4429 }
4430
4431 /* Used to decide how to sort relocs in an optimal manner for the
4432    dynamic linker, before writing them out.  */
4433
4434 static enum elf_reloc_type_class
4435 ppc64_elf_reloc_type_class (rela)
4436      const Elf_Internal_Rela *rela;
4437 {
4438   enum elf_ppc_reloc_type r_type;
4439
4440   r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rela->r_info);
4441   switch (r_type)
4442     {
4443     case R_PPC64_RELATIVE:
4444       return reloc_class_relative;
4445     case R_PPC64_JMP_SLOT:
4446       return reloc_class_plt;
4447     case R_PPC64_COPY:
4448       return reloc_class_copy;
4449     default:
4450       return reloc_class_normal;
4451     }
4452 }
4453
4454 /* Finish up the dynamic sections.  */
4455
4456 static boolean
4457 ppc64_elf_finish_dynamic_sections (output_bfd, info)
4458      bfd *output_bfd;
4459      struct bfd_link_info *info;
4460 {
4461   struct ppc_link_hash_table *htab;
4462   bfd *dynobj;
4463   asection *sdyn;
4464
4465   htab = ppc_hash_table (info);
4466   dynobj = htab->elf.dynobj;
4467   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4468
4469   if (htab->elf.dynamic_sections_created)
4470     {
4471       Elf64_External_Dyn *dyncon, *dynconend;
4472
4473       if (sdyn == NULL || htab->sgot == NULL)
4474         abort ();
4475
4476       dyncon = (Elf64_External_Dyn *) sdyn->contents;
4477       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4478       for (; dyncon < dynconend; dyncon++)
4479         {
4480           Elf_Internal_Dyn dyn;
4481           asection *s;
4482
4483           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4484
4485           switch (dyn.d_tag)
4486             {
4487             default:
4488               continue;
4489
4490             case DT_PPC64_GLINK:
4491               dyn.d_un.d_ptr = (htab->sglink->output_section->vma
4492                                 + htab->sglink->output_offset);
4493               break;
4494
4495             case DT_PPC64_OPD:
4496               s = bfd_get_section_by_name (output_bfd, ".opd");
4497               if (s != NULL)
4498                 dyn.d_un.d_ptr = s->vma;
4499               break;
4500
4501             case DT_PPC64_OPDSZ:
4502               s = bfd_get_section_by_name (output_bfd, ".opd");
4503               if (s != NULL)
4504                 dyn.d_un.d_val = s->_raw_size;
4505               break;
4506
4507             case DT_PLTGOT:
4508               dyn.d_un.d_ptr = (htab->splt->output_section->vma
4509                                 + htab->splt->output_offset);
4510               break;
4511
4512             case DT_JMPREL:
4513               dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
4514                                 + htab->srelplt->output_offset);
4515               break;
4516
4517             case DT_PLTRELSZ:
4518               dyn.d_un.d_val = htab->srelplt->_raw_size;
4519               break;
4520
4521             case DT_RELASZ:
4522               /* Don't count procedure linkage table relocs in the
4523                  overall reloc count.  */
4524               if (htab->srelplt != NULL)
4525                 dyn.d_un.d_val -= htab->srelplt->_raw_size;
4526               break;
4527             }
4528
4529           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
4530         }
4531     }
4532
4533   if (htab->sgot != NULL && htab->sgot->_raw_size != 0)
4534     {
4535       /* Fill in the first entry in the global offset table.
4536          We use it to hold the link-time TOCbase.  */
4537       bfd_put_64 (output_bfd,
4538                   elf_gp (output_bfd) + TOC_BASE_OFF,
4539                   htab->sgot->contents);
4540
4541       /* Set .got entry size.  */
4542       elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 8;
4543     }
4544
4545   if (htab->splt != NULL && htab->splt->_raw_size != 0)
4546     {
4547       /* Set .plt entry size.  */
4548       elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize
4549         = PLT_ENTRY_SIZE;
4550     }
4551
4552   return true;
4553 }
4554
4555 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
4556 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
4557 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
4558 #define TARGET_BIG_NAME         "elf64-powerpc"
4559 #define ELF_ARCH                bfd_arch_powerpc
4560 #define ELF_MACHINE_CODE        EM_PPC64
4561 #define ELF_MAXPAGESIZE         0x10000
4562 #define elf_info_to_howto       ppc64_elf_info_to_howto
4563
4564 #ifdef  EM_CYGNUS_POWERPC
4565 #define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
4566 #endif
4567
4568 #ifdef EM_PPC_OLD
4569 #define ELF_MACHINE_ALT2        EM_PPC_OLD
4570 #endif
4571
4572 #define elf_backend_want_got_sym 0
4573 #define elf_backend_want_plt_sym 0
4574 #define elf_backend_plt_alignment 3
4575 #define elf_backend_plt_not_loaded 1
4576 #define elf_backend_got_symbol_offset 0
4577 #define elf_backend_got_header_size 8
4578 #define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
4579 #define elf_backend_can_gc_sections 1
4580 #define elf_backend_can_refcount 1
4581
4582 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
4583 #define bfd_elf64_bfd_set_private_flags       ppc64_elf_set_private_flags
4584 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
4585 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
4586
4587 #define elf_backend_section_from_shdr         ppc64_elf_section_from_shdr
4588 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
4589 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
4590 #define elf_backend_check_relocs              ppc64_elf_check_relocs
4591 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
4592 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
4593 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
4594 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
4595 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
4596 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
4597 #define elf_backend_fake_sections             ppc64_elf_fake_sections
4598 #define elf_backend_relocate_section          ppc64_elf_relocate_section
4599 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
4600 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
4601 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
4602
4603 #include "elf64-target.h"