bfd/elf64-ppc.c

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