bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
   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   unsigned int fake:1;
3212
3213   /* Whether global opd/toc sym has been adjusted or not.
3214      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3215      should be set for all globals defined in any opd/toc section.  */
3216   unsigned int adjust_done:1;
3217
3218   /* Set if we twiddled this symbol to weak at some stage.  */
3219   unsigned int was_undefined:1;
3220
3221   /* Contexts in which symbol is used in the GOT (or TOC).
3222      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3223      corresponding relocs are encountered during check_relocs.
3224      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3225      indicate the corresponding GOT entry type is not needed.
3226      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3227      a TPREL one.  We use a separate flag rather than setting TPREL
3228      just for convenience in distinguishing the two cases.  */
3229 #define TLS_GD           1      /* GD reloc. */
3230 #define TLS_LD           2      /* LD reloc. */
3231 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3232 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3233 #define TLS_TLS         16      /* Any TLS reloc.  */
3234 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3235 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3236   char tls_mask;
3237 };
3238
3239 /* ppc64 ELF linker hash table.  */
3240
3241 struct ppc_link_hash_table
3242 {
3243   struct elf_link_hash_table elf;
3244
3245   /* The stub hash table.  */
3246   struct bfd_hash_table stub_hash_table;
3247
3248   /* Another hash table for plt_branch stubs.  */
3249   struct bfd_hash_table branch_hash_table;
3250
3251   /* Linker stub bfd.  */
3252   bfd *stub_bfd;
3253
3254   /* Linker call-backs.  */
3255   asection * (*add_stub_section) (const char *, asection *);
3256   void (*layout_sections_again) (void);
3257
3258   /* Array to keep track of which stub sections have been created, and
3259      information on stub grouping.  */
3260   struct map_stub {
3261     /* This is the section to which stubs in the group will be attached.  */
3262     asection *link_sec;
3263     /* The stub section.  */
3264     asection *stub_sec;
3265     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3266     bfd_vma toc_off;
3267   } *stub_group;
3268
3269   /* Temp used when calculating TOC pointers.  */
3270   bfd_vma toc_curr;
3271
3272   /* Highest input section id.  */
3273   int top_id;
3274
3275   /* Highest output section index.  */
3276   int top_index;
3277
3278   /* List of input sections for each output section.  */
3279   asection **input_list;
3280
3281   /* Short-cuts to get to dynamic linker sections.  */
3282   asection *got;
3283   asection *plt;
3284   asection *relplt;
3285   asection *dynbss;
3286   asection *relbss;
3287   asection *glink;
3288   asection *sfpr;
3289   asection *brlt;
3290   asection *relbrlt;
3291
3292   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3293   struct ppc_link_hash_entry *tls_get_addr;
3294   struct ppc_link_hash_entry *tls_get_addr_fd;
3295
3296   /* Statistics.  */
3297   unsigned long stub_count[ppc_stub_plt_call];
3298
3299   /* Number of stubs against global syms.  */
3300   unsigned long stub_globals;
3301
3302   /* Set if we should emit symbols for stubs.  */
3303   unsigned int emit_stub_syms:1;
3304
3305   /* Support for multiple toc sections.  */
3306   unsigned int no_multi_toc:1;
3307   unsigned int multi_toc_needed:1;
3308
3309   /* Set on error.  */
3310   unsigned int stub_error:1;
3311
3312   /* Flag set when small branches are detected.  Used to
3313      select suitable defaults for the stub group size.  */
3314   unsigned int has_14bit_branch:1;
3315
3316   /* Temp used by ppc64_elf_check_directives.  */
3317   unsigned int twiddled_syms:1;
3318
3319   /* Incremented every time we size stubs.  */
3320   unsigned int stub_iteration;
3321
3322   /* Small local sym to section mapping cache.  */
3323   struct sym_sec_cache sym_sec;
3324 };
3325
3326 /* Rename some of the generic section flags to better document how they
3327    are used here.  */
3328 #define has_toc_reloc has_gp_reloc
3329 #define makes_toc_func_call need_finalize_relax
3330 #define call_check_in_progress reloc_done
3331
3332 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3333
3334 #define ppc_hash_table(p) \
3335   ((struct ppc_link_hash_table *) ((p)->hash))
3336
3337 #define ppc_stub_hash_lookup(table, string, create, copy) \
3338   ((struct ppc_stub_hash_entry *) \
3339    bfd_hash_lookup ((table), (string), (create), (copy)))
3340
3341 #define ppc_branch_hash_lookup(table, string, create, copy) \
3342   ((struct ppc_branch_hash_entry *) \
3343    bfd_hash_lookup ((table), (string), (create), (copy)))
3344
3345 /* Create an entry in the stub hash table.  */
3346
3347 static struct bfd_hash_entry *
3348 stub_hash_newfunc (struct bfd_hash_entry *entry,
3349                    struct bfd_hash_table *table,
3350                    const char *string)
3351 {
3352   /* Allocate the structure if it has not already been allocated by a
3353      subclass.  */
3354   if (entry == NULL)
3355     {
3356       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3357       if (entry == NULL)
3358         return entry;
3359     }
3360
3361   /* Call the allocation method of the superclass.  */
3362   entry = bfd_hash_newfunc (entry, table, string);
3363   if (entry != NULL)
3364     {
3365       struct ppc_stub_hash_entry *eh;
3366
3367       /* Initialize the local fields.  */
3368       eh = (struct ppc_stub_hash_entry *) entry;
3369       eh->stub_type = ppc_stub_none;
3370       eh->stub_sec = NULL;
3371       eh->stub_offset = 0;
3372       eh->target_value = 0;
3373       eh->target_section = NULL;
3374       eh->h = NULL;
3375       eh->id_sec = NULL;
3376     }
3377
3378   return entry;
3379 }
3380
3381 /* Create an entry in the branch hash table.  */
3382
3383 static struct bfd_hash_entry *
3384 branch_hash_newfunc (struct bfd_hash_entry *entry,
3385                      struct bfd_hash_table *table,
3386                      const char *string)
3387 {
3388   /* Allocate the structure if it has not already been allocated by a
3389      subclass.  */
3390   if (entry == NULL)
3391     {
3392       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3393       if (entry == NULL)
3394         return entry;
3395     }
3396
3397   /* Call the allocation method of the superclass.  */
3398   entry = bfd_hash_newfunc (entry, table, string);
3399   if (entry != NULL)
3400     {
3401       struct ppc_branch_hash_entry *eh;
3402
3403       /* Initialize the local fields.  */
3404       eh = (struct ppc_branch_hash_entry *) entry;
3405       eh->offset = 0;
3406       eh->iter = 0;
3407     }
3408
3409   return entry;
3410 }
3411
3412 /* Create an entry in a ppc64 ELF linker hash table.  */
3413
3414 static struct bfd_hash_entry *
3415 link_hash_newfunc (struct bfd_hash_entry *entry,
3416                    struct bfd_hash_table *table,
3417                    const char *string)
3418 {
3419   /* Allocate the structure if it has not already been allocated by a
3420      subclass.  */
3421   if (entry == NULL)
3422     {
3423       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3424       if (entry == NULL)
3425         return entry;
3426     }
3427
3428   /* Call the allocation method of the superclass.  */
3429   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3430   if (entry != NULL)
3431     {
3432       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3433
3434       memset (&eh->stub_cache, 0,
3435               (sizeof (struct ppc_link_hash_entry)
3436                - offsetof (struct ppc_link_hash_entry, stub_cache)));
3437     }
3438
3439   return entry;
3440 }
3441
3442 /* Create a ppc64 ELF linker hash table.  */
3443
3444 static struct bfd_link_hash_table *
3445 ppc64_elf_link_hash_table_create (bfd *abfd)
3446 {
3447   struct ppc_link_hash_table *htab;
3448   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3449
3450   htab = bfd_zmalloc (amt);
3451   if (htab == NULL)
3452     return NULL;
3453
3454   if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
3455     {
3456       free (htab);
3457       return NULL;
3458     }
3459
3460   /* Init the stub hash table too.  */
3461   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc))
3462     return NULL;
3463
3464   /* And the branch hash table.  */
3465   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc))
3466     return NULL;
3467
3468   /* Initializing two fields of the union is just cosmetic.  We really
3469      only care about glist, but when compiled on a 32-bit host the
3470      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3471      debugger inspection of these fields look nicer.  */
3472   htab->elf.init_refcount.refcount = 0;
3473   htab->elf.init_refcount.glist = NULL;
3474   htab->elf.init_offset.offset = 0;
3475   htab->elf.init_offset.glist = NULL;
3476
3477   return &htab->elf.root;
3478 }
3479
3480 /* Free the derived linker hash table.  */
3481
3482 static void
3483 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3484 {
3485   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3486
3487   bfd_hash_table_free (&ret->stub_hash_table);
3488   bfd_hash_table_free (&ret->branch_hash_table);
3489   _bfd_generic_link_hash_table_free (hash);
3490 }
3491
3492 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3493
3494 void
3495 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3496 {
3497   struct ppc_link_hash_table *htab;
3498
3499   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3500
3501 /* Always hook our dynamic sections into the first bfd, which is the
3502    linker created stub bfd.  This ensures that the GOT header is at
3503    the start of the output TOC section.  */
3504   htab = ppc_hash_table (info);
3505   htab->stub_bfd = abfd;
3506   htab->elf.dynobj = abfd;
3507 }
3508
3509 /* Build a name for an entry in the stub hash table.  */
3510
3511 static char *
3512 ppc_stub_name (const asection *input_section,
3513                const asection *sym_sec,
3514                const struct ppc_link_hash_entry *h,
3515                const Elf_Internal_Rela *rel)
3516 {
3517   char *stub_name;
3518   bfd_size_type len;
3519
3520   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3521      offsets from a sym as a branch target?  In fact, we could
3522      probably assume the addend is always zero.  */
3523   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3524
3525   if (h)
3526     {
3527       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3528       stub_name = bfd_malloc (len);
3529       if (stub_name != NULL)
3530         {
3531           sprintf (stub_name, "%08x.%s+%x",
3532                    input_section->id & 0xffffffff,
3533                    h->elf.root.root.string,
3534                    (int) rel->r_addend & 0xffffffff);
3535         }
3536     }
3537   else
3538     {
3539       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3540       stub_name = bfd_malloc (len);
3541       if (stub_name != NULL)
3542         {
3543           sprintf (stub_name, "%08x.%x:%x+%x",
3544                    input_section->id & 0xffffffff,
3545                    sym_sec->id & 0xffffffff,
3546                    (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3547                    (int) rel->r_addend & 0xffffffff);
3548         }
3549     }
3550   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3551     stub_name[len - 2] = 0;
3552   return stub_name;
3553 }
3554
3555 /* Look up an entry in the stub hash.  Stub entries are cached because
3556    creating the stub name takes a bit of time.  */
3557
3558 static struct ppc_stub_hash_entry *
3559 ppc_get_stub_entry (const asection *input_section,
3560                     const asection *sym_sec,
3561                     struct ppc_link_hash_entry *h,
3562                     const Elf_Internal_Rela *rel,
3563                     struct ppc_link_hash_table *htab)
3564 {
3565   struct ppc_stub_hash_entry *stub_entry;
3566   const asection *id_sec;
3567
3568   /* If this input section is part of a group of sections sharing one
3569      stub section, then use the id of the first section in the group.
3570      Stub names need to include a section id, as there may well be
3571      more than one stub used to reach say, printf, and we need to
3572      distinguish between them.  */
3573   id_sec = htab->stub_group[input_section->id].link_sec;
3574
3575   if (h != NULL && h->stub_cache != NULL
3576       && h->stub_cache->h == h
3577       && h->stub_cache->id_sec == id_sec)
3578     {
3579       stub_entry = h->stub_cache;
3580     }
3581   else
3582     {
3583       char *stub_name;
3584
3585       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3586       if (stub_name == NULL)
3587         return NULL;
3588
3589       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3590                                          stub_name, FALSE, FALSE);
3591       if (h != NULL)
3592         h->stub_cache = stub_entry;
3593
3594       free (stub_name);
3595     }
3596
3597   return stub_entry;
3598 }
3599
3600 /* Add a new stub entry to the stub hash.  Not all fields of the new
3601    stub entry are initialised.  */
3602
3603 static struct ppc_stub_hash_entry *
3604 ppc_add_stub (const char *stub_name,
3605               asection *section,
3606               struct ppc_link_hash_table *htab)
3607 {
3608   asection *link_sec;
3609   asection *stub_sec;
3610   struct ppc_stub_hash_entry *stub_entry;
3611
3612   link_sec = htab->stub_group[section->id].link_sec;
3613   stub_sec = htab->stub_group[section->id].stub_sec;
3614   if (stub_sec == NULL)
3615     {
3616       stub_sec = htab->stub_group[link_sec->id].stub_sec;
3617       if (stub_sec == NULL)
3618         {
3619           size_t namelen;
3620           bfd_size_type len;
3621           char *s_name;
3622
3623           namelen = strlen (link_sec->name);
3624           len = namelen + sizeof (STUB_SUFFIX);
3625           s_name = bfd_alloc (htab->stub_bfd, len);
3626           if (s_name == NULL)
3627             return NULL;
3628
3629           memcpy (s_name, link_sec->name, namelen);
3630           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3631           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3632           if (stub_sec == NULL)
3633             return NULL;
3634           htab->stub_group[link_sec->id].stub_sec = stub_sec;
3635         }
3636       htab->stub_group[section->id].stub_sec = stub_sec;
3637     }
3638
3639   /* Enter this entry into the linker stub hash table.  */
3640   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3641                                      TRUE, FALSE);
3642   if (stub_entry == NULL)
3643     {
3644       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3645                              section->owner, stub_name);
3646       return NULL;
3647     }
3648
3649   stub_entry->stub_sec = stub_sec;
3650   stub_entry->stub_offset = 0;
3651   stub_entry->id_sec = link_sec;
3652   return stub_entry;
3653 }
3654
3655 /* Create sections for linker generated code.  */
3656
3657 static bfd_boolean
3658 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3659 {
3660   struct ppc_link_hash_table *htab;
3661   flagword flags;
3662
3663   htab = ppc_hash_table (info);
3664
3665   /* Create .sfpr for code to save and restore fp regs.  */
3666   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3667            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3668   htab->sfpr = bfd_make_section_anyway (dynobj, ".sfpr");
3669   if (htab->sfpr == NULL
3670       || ! bfd_set_section_flags (dynobj, htab->sfpr, flags)
3671       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3672     return FALSE;
3673
3674   /* Create .glink for lazy dynamic linking support.  */
3675   htab->glink = bfd_make_section_anyway (dynobj, ".glink");
3676   if (htab->glink == NULL
3677       || ! bfd_set_section_flags (dynobj, htab->glink, flags)
3678       || ! bfd_set_section_alignment (dynobj, htab->glink, 2))
3679     return FALSE;
3680
3681   /* Create .branch_lt for plt_branch stubs.  */
3682   flags = (SEC_ALLOC | SEC_LOAD
3683            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3684   htab->brlt = bfd_make_section_anyway (dynobj, ".branch_lt");
3685   if (htab->brlt == NULL
3686       || ! bfd_set_section_flags (dynobj, htab->brlt, flags)
3687       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
3688     return FALSE;
3689
3690   if (info->shared || info->emitrelocations)
3691     {
3692       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3693                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3694       htab->relbrlt = bfd_make_section_anyway (dynobj, ".rela.branch_lt");
3695       if (!htab->relbrlt
3696           || ! bfd_set_section_flags (dynobj, htab->relbrlt, flags)
3697           || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3698         return FALSE;
3699     }
3700   return TRUE;
3701 }
3702
3703 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3704    not already done.  */
3705
3706 static bfd_boolean
3707 create_got_section (bfd *abfd, struct bfd_link_info *info)
3708 {
3709   asection *got, *relgot;
3710   flagword flags;
3711   struct ppc_link_hash_table *htab = ppc_hash_table (info);
3712
3713   if (!htab->got)
3714     {
3715       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
3716         return FALSE;
3717
3718       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
3719       if (!htab->got)
3720         abort ();
3721     }
3722
3723   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3724            | SEC_LINKER_CREATED);
3725
3726   got = bfd_make_section (abfd, ".got");
3727   if (!got
3728       || !bfd_set_section_flags (abfd, got, flags)
3729       || !bfd_set_section_alignment (abfd, got, 3))
3730     return FALSE;
3731
3732   relgot = bfd_make_section (abfd, ".rela.got");
3733   if (!relgot
3734       || ! bfd_set_section_flags (abfd, relgot, flags | SEC_READONLY)
3735       || ! bfd_set_section_alignment (abfd, relgot, 3))
3736     return FALSE;
3737
3738   ppc64_elf_tdata (abfd)->got = got;
3739   ppc64_elf_tdata (abfd)->relgot = relgot;
3740   return TRUE;
3741 }
3742
3743 /* Create the dynamic sections, and set up shortcuts.  */
3744
3745 static bfd_boolean
3746 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3747 {
3748   struct ppc_link_hash_table *htab;
3749
3750   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3751     return FALSE;
3752
3753   htab = ppc_hash_table (info);
3754   if (!htab->got)
3755     htab->got = bfd_get_section_by_name (dynobj, ".got");
3756   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
3757   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
3758   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
3759   if (!info->shared)
3760     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
3761
3762   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
3763       || (!info->shared && !htab->relbss))
3764     abort ();
3765
3766   return TRUE;
3767 }
3768
3769 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3770
3771 static void
3772 ppc64_elf_copy_indirect_symbol
3773   (const struct elf_backend_data *bed ATTRIBUTE_UNUSED,
3774    struct elf_link_hash_entry *dir,
3775    struct elf_link_hash_entry *ind)
3776 {
3777   struct ppc_link_hash_entry *edir, *eind;
3778
3779   edir = (struct ppc_link_hash_entry *) dir;
3780   eind = (struct ppc_link_hash_entry *) ind;
3781
3782   /* Copy over any dynamic relocs we may have on the indirect sym.  */
3783   if (eind->dyn_relocs != NULL)
3784     {
3785       if (edir->dyn_relocs != NULL)
3786         {
3787           struct ppc_dyn_relocs **pp;
3788           struct ppc_dyn_relocs *p;
3789
3790           if (eind->elf.root.type == bfd_link_hash_indirect)
3791             abort ();
3792
3793           /* Add reloc counts against the weak sym to the strong sym
3794              list.  Merge any entries against the same section.  */
3795           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3796             {
3797               struct ppc_dyn_relocs *q;
3798
3799               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3800                 if (q->sec == p->sec)
3801                   {
3802                     q->pc_count += p->pc_count;
3803                     q->count += p->count;
3804                     *pp = p->next;
3805                     break;
3806                   }
3807               if (q == NULL)
3808                 pp = &p->next;
3809             }
3810           *pp = edir->dyn_relocs;
3811         }
3812
3813       edir->dyn_relocs = eind->dyn_relocs;
3814       eind->dyn_relocs = NULL;
3815     }
3816
3817   edir->is_func |= eind->is_func;
3818   edir->is_func_descriptor |= eind->is_func_descriptor;
3819   edir->tls_mask |= eind->tls_mask;
3820
3821   /* If called to transfer flags for a weakdef during processing
3822      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
3823      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
3824   if (!(ELIMINATE_COPY_RELOCS
3825         && eind->elf.root.type != bfd_link_hash_indirect
3826         && edir->elf.dynamic_adjusted))
3827     edir->elf.non_got_ref |= eind->elf.non_got_ref;
3828
3829   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3830   edir->elf.ref_regular |= eind->elf.ref_regular;
3831   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3832   edir->elf.needs_plt |= eind->elf.needs_plt;
3833
3834   /* If we were called to copy over info for a weak sym, that's all.  */
3835   if (eind->elf.root.type != bfd_link_hash_indirect)
3836     return;
3837
3838   /* Copy over got entries that we may have already seen to the
3839      symbol which just became indirect.  */
3840   if (eind->elf.got.glist != NULL)
3841     {
3842       if (edir->elf.got.glist != NULL)
3843         {
3844           struct got_entry **entp;
3845           struct got_entry *ent;
3846
3847           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3848             {
3849               struct got_entry *dent;
3850
3851               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3852                 if (dent->addend == ent->addend
3853                     && dent->owner == ent->owner
3854                     && dent->tls_type == ent->tls_type)
3855                   {
3856                     dent->got.refcount += ent->got.refcount;
3857                     *entp = ent->next;
3858                     break;
3859                   }
3860               if (dent == NULL)
3861                 entp = &ent->next;
3862             }
3863           *entp = edir->elf.got.glist;
3864         }
3865
3866       edir->elf.got.glist = eind->elf.got.glist;
3867       eind->elf.got.glist = NULL;
3868     }
3869
3870   /* And plt entries.  */
3871   if (eind->elf.plt.plist != NULL)
3872     {
3873       if (edir->elf.plt.plist != NULL)
3874         {
3875           struct plt_entry **entp;
3876           struct plt_entry *ent;
3877
3878           for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; )
3879             {
3880               struct plt_entry *dent;
3881
3882               for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next)
3883                 if (dent->addend == ent->addend)
3884                   {
3885                     dent->plt.refcount += ent->plt.refcount;
3886                     *entp = ent->next;
3887                     break;
3888                   }
3889               if (dent == NULL)
3890                 entp = &ent->next;
3891             }
3892           *entp = edir->elf.plt.plist;
3893         }
3894
3895       edir->elf.plt.plist = eind->elf.plt.plist;
3896       eind->elf.plt.plist = NULL;
3897     }
3898
3899   if (edir->elf.dynindx == -1)
3900     {
3901       edir->elf.dynindx = eind->elf.dynindx;
3902       edir->elf.dynstr_index = eind->elf.dynstr_index;
3903       eind->elf.dynindx = -1;
3904       eind->elf.dynstr_index = 0;
3905     }
3906   else
3907     BFD_ASSERT (eind->elf.dynindx == -1);
3908 }
3909
3910 /* Find the function descriptor hash entry from the given function code
3911    hash entry FH.  Link the entries via their OH fields.  */
3912
3913 static struct ppc_link_hash_entry *
3914 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
3915 {
3916   struct ppc_link_hash_entry *fdh = fh->oh;
3917
3918   if (fdh == NULL)
3919     {
3920       const char *fd_name = fh->elf.root.root.string + 1;
3921
3922       fdh = (struct ppc_link_hash_entry *)
3923         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
3924       if (fdh != NULL)
3925         {
3926           fdh->is_func_descriptor = 1;
3927           fdh->oh = fh;
3928           fh->is_func = 1;
3929           fh->oh = fdh;
3930         }
3931     }
3932
3933   return fdh;
3934 }
3935
3936 /* Make a fake function descriptor sym for the code sym FH.  */
3937
3938 static struct ppc_link_hash_entry *
3939 make_fdh (struct bfd_link_info *info,
3940           struct ppc_link_hash_entry *fh)
3941 {
3942   bfd *abfd;
3943   asymbol *newsym;
3944   struct bfd_link_hash_entry *bh;
3945   struct ppc_link_hash_entry *fdh;
3946
3947   abfd = fh->elf.root.u.undef.abfd;
3948   newsym = bfd_make_empty_symbol (abfd);
3949   newsym->name = fh->elf.root.root.string + 1;
3950   newsym->section = bfd_und_section_ptr;
3951   newsym->value = 0;
3952   newsym->flags = BSF_WEAK;
3953
3954   bh = NULL;
3955   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
3956                                          newsym->flags, newsym->section,
3957                                          newsym->value, NULL, FALSE, FALSE,
3958                                          &bh))
3959     return NULL;
3960
3961   fdh = (struct ppc_link_hash_entry *) bh;
3962   fdh->elf.non_elf = 0;
3963   fdh->fake = 1;
3964   fdh->is_func_descriptor = 1;
3965   fdh->oh = fh;
3966   fh->is_func = 1;
3967   fh->oh = fdh;
3968   return fdh;
3969 }
3970
3971 /* Hacks to support old ABI code.
3972    When making function calls, old ABI code references function entry
3973    points (dot symbols), while new ABI code references the function
3974    descriptor symbol.  We need to make any combination of reference and
3975    definition work together, without breaking archive linking.
3976
3977    For a defined function "foo" and an undefined call to "bar":
3978    An old object defines "foo" and ".foo", references ".bar" (possibly
3979    "bar" too).
3980    A new object defines "foo" and references "bar".
3981
3982    A new object thus has no problem with its undefined symbols being
3983    satisfied by definitions in an old object.  On the other hand, the
3984    old object won't have ".bar" satisfied by a new object.  */
3985
3986 /* Fix function descriptor symbols defined in .opd sections to be
3987    function type.  */
3988
3989 static bfd_boolean
3990 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
3991                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
3992                            Elf_Internal_Sym *isym,
3993                            const char **name ATTRIBUTE_UNUSED,
3994                            flagword *flags ATTRIBUTE_UNUSED,
3995                            asection **sec,
3996                            bfd_vma *value ATTRIBUTE_UNUSED)
3997 {
3998   if (*sec != NULL
3999       && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4000     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4001   return TRUE;
4002 }
4003
4004 /* This function makes an old ABI object reference to ".bar" cause the
4005    inclusion of a new ABI object archive that defines "bar".
4006    NAME is a symbol defined in an archive.  Return a symbol in the hash
4007    table that might be satisfied by the archive symbols.  */
4008
4009 static struct elf_link_hash_entry *
4010 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4011                                  struct bfd_link_info *info,
4012                                  const char *name)
4013 {
4014   struct elf_link_hash_entry *h;
4015   char *dot_name;
4016   size_t len;
4017
4018   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4019   if (h != NULL
4020       /* Don't return this sym if it is a fake function descriptor
4021          created by add_symbol_adjust.  */
4022       && !(h->root.type == bfd_link_hash_undefweak
4023            && ((struct ppc_link_hash_entry *) h)->fake))
4024     return h;
4025
4026   if (name[0] == '.')
4027     return h;
4028
4029   len = strlen (name);
4030   dot_name = bfd_alloc (abfd, len + 2);
4031   if (dot_name == NULL)
4032     return (struct elf_link_hash_entry *) 0 - 1;
4033   dot_name[0] = '.';
4034   memcpy (dot_name + 1, name, len + 1);
4035   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4036   bfd_release (abfd, dot_name);
4037   return h;
4038 }
4039
4040 /* This function satisfies all old ABI object references to ".bar" if a
4041    new ABI object defines "bar".  Well, at least, undefined dot symbols
4042    are made weak.  This stops later archive searches from including an
4043    object if we already have a function descriptor definition.  It also
4044    prevents the linker complaining about undefined symbols.
4045    We also check and correct mismatched symbol visibility here.  The
4046    most restrictive visibility of the function descriptor and the
4047    function entry symbol is used.  */
4048
4049 struct add_symbol_adjust_data
4050 {
4051   struct bfd_link_info *info;
4052   bfd_boolean ok;
4053 };
4054
4055 static bfd_boolean
4056 add_symbol_adjust (struct elf_link_hash_entry *h, void *inf)
4057 {
4058   struct add_symbol_adjust_data *data;
4059   struct ppc_link_hash_table *htab;
4060   struct ppc_link_hash_entry *eh;
4061   struct ppc_link_hash_entry *fdh;
4062
4063   if (h->root.type == bfd_link_hash_indirect)
4064     return TRUE;
4065
4066   if (h->root.type == bfd_link_hash_warning)
4067     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4068
4069   if (h->root.root.string[0] != '.')
4070     return TRUE;
4071
4072   data = inf;
4073   htab = ppc_hash_table (data->info);
4074   eh = (struct ppc_link_hash_entry *) h;
4075   fdh = get_fdh (eh, htab);
4076   if (fdh == NULL
4077       && (eh->elf.root.type == bfd_link_hash_undefined
4078           || eh->elf.root.type == bfd_link_hash_undefweak)
4079       && eh->elf.ref_regular)
4080     {
4081       /* Make an undefweak function descriptor sym, which is enough to
4082          pull in an --as-needed shared lib, but won't cause link
4083          errors.  Archives are handled elsewhere.  */
4084       fdh = make_fdh (data->info, eh);
4085       if (fdh == NULL)
4086         data->ok = FALSE;
4087       else
4088         fdh->elf.ref_regular = 1;
4089     }
4090   else if (fdh != NULL)
4091     {
4092       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4093       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4094       if (entry_vis < descr_vis)
4095         fdh->elf.other += entry_vis - descr_vis;
4096       else if (entry_vis > descr_vis)
4097         eh->elf.other += descr_vis - entry_vis;
4098
4099       if (eh->elf.root.type == bfd_link_hash_undefined
4100           && (fdh->elf.root.type == bfd_link_hash_defined
4101               || fdh->elf.root.type == bfd_link_hash_defweak))
4102         {
4103           eh->elf.root.type = bfd_link_hash_undefweak;
4104           eh->was_undefined = 1;
4105           htab->twiddled_syms = 1;
4106         }
4107     }
4108
4109   return TRUE;
4110 }
4111
4112 static bfd_boolean
4113 ppc64_elf_check_directives (bfd *abfd ATTRIBUTE_UNUSED,
4114                             struct bfd_link_info *info)
4115 {
4116   struct ppc_link_hash_table *htab;
4117   struct add_symbol_adjust_data data;
4118
4119   htab = ppc_hash_table (info);
4120   if (!is_ppc64_elf_target (htab->elf.root.creator))
4121     return TRUE;
4122
4123   data.info = info;
4124   data.ok = TRUE;
4125   elf_link_hash_traverse (&htab->elf, add_symbol_adjust, &data);
4126
4127   /* We need to fix the undefs list for any syms we have twiddled to
4128      undef_weak.  */
4129   if (htab->twiddled_syms)
4130     {
4131       bfd_link_repair_undef_list (&htab->elf.root);
4132       htab->twiddled_syms = 0;
4133     }
4134   return data.ok;
4135 }
4136
4137 static bfd_boolean
4138 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4139                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4140 {
4141   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4142   char *local_got_tls_masks;
4143
4144   if (local_got_ents == NULL)
4145     {
4146       bfd_size_type size = symtab_hdr->sh_info;
4147
4148       size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4149       local_got_ents = bfd_zalloc (abfd, size);
4150       if (local_got_ents == NULL)
4151         return FALSE;
4152       elf_local_got_ents (abfd) = local_got_ents;
4153     }
4154
4155   if ((tls_type & TLS_EXPLICIT) == 0)
4156     {
4157       struct got_entry *ent;
4158
4159       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4160         if (ent->addend == r_addend
4161             && ent->owner == abfd
4162             && ent->tls_type == tls_type)
4163           break;
4164       if (ent == NULL)
4165         {
4166           bfd_size_type amt = sizeof (*ent);
4167           ent = bfd_alloc (abfd, amt);
4168           if (ent == NULL)
4169             return FALSE;
4170           ent->next = local_got_ents[r_symndx];
4171           ent->addend = r_addend;
4172           ent->owner = abfd;
4173           ent->tls_type = tls_type;
4174           ent->got.refcount = 0;
4175           local_got_ents[r_symndx] = ent;
4176         }
4177       ent->got.refcount += 1;
4178     }
4179
4180   local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4181   local_got_tls_masks[r_symndx] |= tls_type;
4182   return TRUE;
4183 }
4184
4185 static bfd_boolean
4186 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
4187 {
4188   struct plt_entry *ent;
4189
4190   for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4191     if (ent->addend == addend)
4192       break;
4193   if (ent == NULL)
4194     {
4195       bfd_size_type amt = sizeof (*ent);
4196       ent = bfd_alloc (abfd, amt);
4197       if (ent == NULL)
4198         return FALSE;
4199       ent->next = eh->elf.plt.plist;
4200       ent->addend = addend;
4201       ent->plt.refcount = 0;
4202       eh->elf.plt.plist = ent;
4203     }
4204   ent->plt.refcount += 1;
4205   eh->elf.needs_plt = 1;
4206   eh->is_func = 1;
4207   return TRUE;
4208 }
4209
4210 /* Look through the relocs for a section during the first phase, and
4211    calculate needed space in the global offset table, procedure
4212    linkage table, and dynamic reloc sections.  */
4213
4214 static bfd_boolean
4215 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4216                         asection *sec, const Elf_Internal_Rela *relocs)
4217 {
4218   struct ppc_link_hash_table *htab;
4219   Elf_Internal_Shdr *symtab_hdr;
4220   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4221   const Elf_Internal_Rela *rel;
4222   const Elf_Internal_Rela *rel_end;
4223   asection *sreloc;
4224   asection **opd_sym_map;
4225
4226   if (info->relocatable)
4227     return TRUE;
4228
4229   /* Don't do anything special with non-loaded, non-alloced sections.
4230      In particular, any relocs in such sections should not affect GOT
4231      and PLT reference counting (ie. we don't allow them to create GOT
4232      or PLT entries), there's no possibility or desire to optimize TLS
4233      relocs, and there's not much point in propagating relocs to shared
4234      libs that the dynamic linker won't relocate.  */
4235   if ((sec->flags & SEC_ALLOC) == 0)
4236     return TRUE;
4237
4238   htab = ppc_hash_table (info);
4239   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4240
4241   sym_hashes = elf_sym_hashes (abfd);
4242   sym_hashes_end = (sym_hashes
4243                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4244                     - symtab_hdr->sh_info);
4245
4246   sreloc = NULL;
4247   opd_sym_map = NULL;
4248   if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4249     {
4250       /* Garbage collection needs some extra help with .opd sections.
4251          We don't want to necessarily keep everything referenced by
4252          relocs in .opd, as that would keep all functions.  Instead,
4253          if we reference an .opd symbol (a function descriptor), we
4254          want to keep the function code symbol's section.  This is
4255          easy for global symbols, but for local syms we need to keep
4256          information about the associated function section.  Later, if
4257          edit_opd deletes entries, we'll use this array to adjust
4258          local syms in .opd.  */
4259       union opd_info {
4260         asection *func_section;
4261         long entry_adjust;
4262       };
4263       bfd_size_type amt;
4264
4265       amt = sec->size * sizeof (union opd_info) / 8;
4266       opd_sym_map = bfd_zalloc (abfd, amt);
4267       if (opd_sym_map == NULL)
4268         return FALSE;
4269       ppc64_elf_section_data (sec)->opd.func_sec = opd_sym_map;
4270     }
4271
4272   if (htab->sfpr == NULL
4273       && !create_linkage_sections (htab->elf.dynobj, info))
4274     return FALSE;
4275
4276   rel_end = relocs + sec->reloc_count;
4277   for (rel = relocs; rel < rel_end; rel++)
4278     {
4279       unsigned long r_symndx;
4280       struct elf_link_hash_entry *h;
4281       enum elf_ppc64_reloc_type r_type;
4282       int tls_type = 0;
4283
4284       r_symndx = ELF64_R_SYM (rel->r_info);
4285       if (r_symndx < symtab_hdr->sh_info)
4286         h = NULL;
4287       else
4288         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4289
4290       r_type = ELF64_R_TYPE (rel->r_info);
4291       switch (r_type)
4292         {
4293         case R_PPC64_GOT_TLSLD16:
4294         case R_PPC64_GOT_TLSLD16_LO:
4295         case R_PPC64_GOT_TLSLD16_HI:
4296         case R_PPC64_GOT_TLSLD16_HA:
4297           ppc64_tlsld_got (abfd)->refcount += 1;
4298           tls_type = TLS_TLS | TLS_LD;
4299           goto dogottls;
4300
4301         case R_PPC64_GOT_TLSGD16:
4302         case R_PPC64_GOT_TLSGD16_LO:
4303         case R_PPC64_GOT_TLSGD16_HI:
4304         case R_PPC64_GOT_TLSGD16_HA:
4305           tls_type = TLS_TLS | TLS_GD;
4306           goto dogottls;
4307
4308         case R_PPC64_GOT_TPREL16_DS:
4309         case R_PPC64_GOT_TPREL16_LO_DS:
4310         case R_PPC64_GOT_TPREL16_HI:
4311         case R_PPC64_GOT_TPREL16_HA:
4312           if (info->shared)
4313             info->flags |= DF_STATIC_TLS;
4314           tls_type = TLS_TLS | TLS_TPREL;
4315           goto dogottls;
4316
4317         case R_PPC64_GOT_DTPREL16_DS:
4318         case R_PPC64_GOT_DTPREL16_LO_DS:
4319         case R_PPC64_GOT_DTPREL16_HI:
4320         case R_PPC64_GOT_DTPREL16_HA:
4321           tls_type = TLS_TLS | TLS_DTPREL;
4322         dogottls:
4323           sec->has_tls_reloc = 1;
4324           /* Fall thru */
4325
4326         case R_PPC64_GOT16:
4327         case R_PPC64_GOT16_DS:
4328         case R_PPC64_GOT16_HA:
4329         case R_PPC64_GOT16_HI:
4330         case R_PPC64_GOT16_LO:
4331         case R_PPC64_GOT16_LO_DS:
4332           /* This symbol requires a global offset table entry.  */
4333           sec->has_toc_reloc = 1;
4334           if (ppc64_elf_tdata (abfd)->got == NULL
4335               && !create_got_section (abfd, info))
4336             return FALSE;
4337
4338           if (h != NULL)
4339             {
4340               struct ppc_link_hash_entry *eh;
4341               struct got_entry *ent;
4342
4343               eh = (struct ppc_link_hash_entry *) h;
4344               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4345                 if (ent->addend == rel->r_addend
4346                     && ent->owner == abfd
4347                     && ent->tls_type == tls_type)
4348                   break;
4349               if (ent == NULL)
4350                 {
4351                   bfd_size_type amt = sizeof (*ent);
4352                   ent = bfd_alloc (abfd, amt);
4353                   if (ent == NULL)
4354                     return FALSE;
4355                   ent->next = eh->elf.got.glist;
4356                   ent->addend = rel->r_addend;
4357                   ent->owner = abfd;
4358                   ent->tls_type = tls_type;
4359                   ent->got.refcount = 0;
4360                   eh->elf.got.glist = ent;
4361                 }
4362               ent->got.refcount += 1;
4363               eh->tls_mask |= tls_type;
4364             }
4365           else
4366             /* This is a global offset table entry for a local symbol.  */
4367             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4368                                         rel->r_addend, tls_type))
4369               return FALSE;
4370           break;
4371
4372         case R_PPC64_PLT16_HA:
4373         case R_PPC64_PLT16_HI:
4374         case R_PPC64_PLT16_LO:
4375         case R_PPC64_PLT32:
4376         case R_PPC64_PLT64:
4377           /* This symbol requires a procedure linkage table entry.  We
4378              actually build the entry in adjust_dynamic_symbol,
4379              because this might be a case of linking PIC code without
4380              linking in any dynamic objects, in which case we don't
4381              need to generate a procedure linkage table after all.  */
4382           if (h == NULL)
4383             {
4384               /* It does not make sense to have a procedure linkage
4385                  table entry for a local symbol.  */
4386               bfd_set_error (bfd_error_bad_value);
4387               return FALSE;
4388             }
4389           else
4390             if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4391                                   rel->r_addend))
4392               return FALSE;
4393           break;
4394
4395           /* The following relocations don't need to propagate the
4396              relocation if linking a shared object since they are
4397              section relative.  */
4398         case R_PPC64_SECTOFF:
4399         case R_PPC64_SECTOFF_LO:
4400         case R_PPC64_SECTOFF_HI:
4401         case R_PPC64_SECTOFF_HA:
4402         case R_PPC64_SECTOFF_DS:
4403         case R_PPC64_SECTOFF_LO_DS:
4404         case R_PPC64_DTPREL16:
4405         case R_PPC64_DTPREL16_LO:
4406         case R_PPC64_DTPREL16_HI:
4407         case R_PPC64_DTPREL16_HA:
4408         case R_PPC64_DTPREL16_DS:
4409         case R_PPC64_DTPREL16_LO_DS:
4410         case R_PPC64_DTPREL16_HIGHER:
4411         case R_PPC64_DTPREL16_HIGHERA:
4412         case R_PPC64_DTPREL16_HIGHEST:
4413         case R_PPC64_DTPREL16_HIGHESTA:
4414           break;
4415
4416           /* Nor do these.  */
4417         case R_PPC64_TOC16:
4418         case R_PPC64_TOC16_LO:
4419         case R_PPC64_TOC16_HI:
4420         case R_PPC64_TOC16_HA:
4421         case R_PPC64_TOC16_DS:
4422         case R_PPC64_TOC16_LO_DS:
4423           sec->has_toc_reloc = 1;
4424           break;
4425
4426           /* This relocation describes the C++ object vtable hierarchy.
4427              Reconstruct it for later use during GC.  */
4428         case R_PPC64_GNU_VTINHERIT:
4429           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4430             return FALSE;
4431           break;
4432
4433           /* This relocation describes which C++ vtable entries are actually
4434              used.  Record for later use during GC.  */
4435         case R_PPC64_GNU_VTENTRY:
4436           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4437             return FALSE;
4438           break;
4439
4440         case R_PPC64_REL14:
4441         case R_PPC64_REL14_BRTAKEN:
4442         case R_PPC64_REL14_BRNTAKEN:
4443           htab->has_14bit_branch = 1;
4444           /* Fall through.  */
4445
4446         case R_PPC64_REL24:
4447           if (h != NULL)
4448             {
4449               /* We may need a .plt entry if the function this reloc
4450                  refers to is in a shared lib.  */
4451               if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4452                                     rel->r_addend))
4453                 return FALSE;
4454               if (h == &htab->tls_get_addr->elf
4455                   || h == &htab->tls_get_addr_fd->elf)
4456                 sec->has_tls_reloc = 1;
4457               else if (htab->tls_get_addr == NULL
4458                        && !strncmp (h->root.root.string, ".__tls_get_addr", 15)
4459                        && (h->root.root.string[15] == 0
4460                            || h->root.root.string[15] == '@'))
4461                 {
4462                   htab->tls_get_addr = (struct ppc_link_hash_entry *) h;
4463                   sec->has_tls_reloc = 1;
4464                 }
4465               else if (htab->tls_get_addr_fd == NULL
4466                        && !strncmp (h->root.root.string, "__tls_get_addr", 14)
4467                        && (h->root.root.string[14] == 0
4468                            || h->root.root.string[14] == '@'))
4469                 {
4470                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) h;
4471                   sec->has_tls_reloc = 1;
4472                 }
4473             }
4474           break;
4475
4476         case R_PPC64_TPREL64:
4477           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4478           if (info->shared)
4479             info->flags |= DF_STATIC_TLS;
4480           goto dotlstoc;
4481
4482         case R_PPC64_DTPMOD64:
4483           if (rel + 1 < rel_end
4484               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4485               && rel[1].r_offset == rel->r_offset + 8)
4486             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4487           else
4488             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4489           goto dotlstoc;
4490
4491         case R_PPC64_DTPREL64:
4492           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4493           if (rel != relocs
4494               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4495               && rel[-1].r_offset == rel->r_offset - 8)
4496             /* This is the second reloc of a dtpmod, dtprel pair.
4497                Don't mark with TLS_DTPREL.  */
4498             goto dodyn;
4499
4500         dotlstoc:
4501           sec->has_tls_reloc = 1;
4502           if (h != NULL)
4503             {
4504               struct ppc_link_hash_entry *eh;
4505               eh = (struct ppc_link_hash_entry *) h;
4506               eh->tls_mask |= tls_type;
4507             }
4508           else
4509             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4510                                         rel->r_addend, tls_type))
4511               return FALSE;
4512
4513           if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4514             {
4515               /* One extra to simplify get_tls_mask.  */
4516               bfd_size_type amt = sec->size * sizeof (unsigned) / 8 + 1;
4517               ppc64_elf_section_data (sec)->t_symndx = bfd_zalloc (abfd, amt);
4518               if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4519                 return FALSE;
4520             }
4521           BFD_ASSERT (rel->r_offset % 8 == 0);
4522           ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8] = r_symndx;
4523
4524           /* Mark the second slot of a GD or LD entry.
4525              -1 to indicate GD and -2 to indicate LD.  */
4526           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4527             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -1;
4528           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4529             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -2;
4530           goto dodyn;
4531
4532         case R_PPC64_TPREL16:
4533         case R_PPC64_TPREL16_LO:
4534         case R_PPC64_TPREL16_HI:
4535         case R_PPC64_TPREL16_HA:
4536         case R_PPC64_TPREL16_DS:
4537         case R_PPC64_TPREL16_LO_DS:
4538         case R_PPC64_TPREL16_HIGHER:
4539         case R_PPC64_TPREL16_HIGHERA:
4540         case R_PPC64_TPREL16_HIGHEST:
4541         case R_PPC64_TPREL16_HIGHESTA:
4542           if (info->shared)
4543             {
4544               info->flags |= DF_STATIC_TLS;
4545               goto dodyn;
4546             }
4547           break;
4548
4549         case R_PPC64_ADDR64:
4550           if (opd_sym_map != NULL
4551               && rel + 1 < rel_end
4552               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
4553             {
4554               if (h != NULL)
4555                 {
4556                   if (h->root.root.string[0] == '.'
4557                       && h->root.root.string[1] != 0
4558                       && get_fdh ((struct ppc_link_hash_entry *) h, htab))
4559                     ;
4560                   else
4561                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
4562                 }
4563               else
4564                 {
4565                   asection *s;
4566
4567                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
4568                                                  r_symndx);
4569                   if (s == NULL)
4570                     return FALSE;
4571                   else if (s != sec)
4572                     opd_sym_map[rel->r_offset / 8] = s;
4573                 }
4574             }
4575           /* Fall through.  */
4576
4577         case R_PPC64_REL30:
4578         case R_PPC64_REL32:
4579         case R_PPC64_REL64:
4580         case R_PPC64_ADDR14:
4581         case R_PPC64_ADDR14_BRNTAKEN:
4582         case R_PPC64_ADDR14_BRTAKEN:
4583         case R_PPC64_ADDR16:
4584         case R_PPC64_ADDR16_DS:
4585         case R_PPC64_ADDR16_HA:
4586         case R_PPC64_ADDR16_HI:
4587         case R_PPC64_ADDR16_HIGHER:
4588         case R_PPC64_ADDR16_HIGHERA:
4589         case R_PPC64_ADDR16_HIGHEST:
4590         case R_PPC64_ADDR16_HIGHESTA:
4591         case R_PPC64_ADDR16_LO:
4592         case R_PPC64_ADDR16_LO_DS:
4593         case R_PPC64_ADDR24:
4594         case R_PPC64_ADDR32:
4595         case R_PPC64_UADDR16:
4596         case R_PPC64_UADDR32:
4597         case R_PPC64_UADDR64:
4598         case R_PPC64_TOC:
4599           if (h != NULL && !info->shared)
4600             /* We may need a copy reloc.  */
4601             h->non_got_ref = 1;
4602
4603           /* Don't propagate .opd relocs.  */
4604           if (NO_OPD_RELOCS && opd_sym_map != NULL)
4605             break;
4606
4607           /* If we are creating a shared library, and this is a reloc
4608              against a global symbol, or a non PC relative reloc
4609              against a local symbol, then we need to copy the reloc
4610              into the shared library.  However, if we are linking with
4611              -Bsymbolic, we do not need to copy a reloc against a
4612              global symbol which is defined in an object we are
4613              including in the link (i.e., DEF_REGULAR is set).  At
4614              this point we have not seen all the input files, so it is
4615              possible that DEF_REGULAR is not set now but will be set
4616              later (it is never cleared).  In case of a weak definition,
4617              DEF_REGULAR may be cleared later by a strong definition in
4618              a shared library.  We account for that possibility below by
4619              storing information in the dyn_relocs field of the hash
4620              table entry.  A similar situation occurs when creating
4621              shared libraries and symbol visibility changes render the
4622              symbol local.
4623
4624              If on the other hand, we are creating an executable, we
4625              may need to keep relocations for symbols satisfied by a
4626              dynamic library if we manage to avoid copy relocs for the
4627              symbol.  */
4628         dodyn:
4629           if ((info->shared
4630                && (MUST_BE_DYN_RELOC (r_type)
4631                    || (h != NULL
4632                        && (! info->symbolic
4633                            || h->root.type == bfd_link_hash_defweak
4634                            || !h->def_regular))))
4635               || (ELIMINATE_COPY_RELOCS
4636                   && !info->shared
4637                   && h != NULL
4638                   && (h->root.type == bfd_link_hash_defweak
4639                       || !h->def_regular)))
4640             {
4641               struct ppc_dyn_relocs *p;
4642               struct ppc_dyn_relocs **head;
4643
4644               /* We must copy these reloc types into the output file.
4645                  Create a reloc section in dynobj and make room for
4646                  this reloc.  */
4647               if (sreloc == NULL)
4648                 {
4649                   const char *name;
4650                   bfd *dynobj;
4651
4652                   name = (bfd_elf_string_from_elf_section
4653                           (abfd,
4654                            elf_elfheader (abfd)->e_shstrndx,
4655                            elf_section_data (sec)->rel_hdr.sh_name));
4656                   if (name == NULL)
4657                     return FALSE;
4658
4659                   if (strncmp (name, ".rela", 5) != 0
4660                       || strcmp (bfd_get_section_name (abfd, sec),
4661                                  name + 5) != 0)
4662                     {
4663                       (*_bfd_error_handler)
4664                         (_("%B: bad relocation section name `%s\'"),
4665                          abfd, name);
4666                       bfd_set_error (bfd_error_bad_value);
4667                     }
4668
4669                   dynobj = htab->elf.dynobj;
4670                   sreloc = bfd_get_section_by_name (dynobj, name);
4671                   if (sreloc == NULL)
4672                     {
4673                       flagword flags;
4674
4675                       sreloc = bfd_make_section (dynobj, name);
4676                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
4677                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4678                       if ((sec->flags & SEC_ALLOC) != 0)
4679                         flags |= SEC_ALLOC | SEC_LOAD;
4680                       if (sreloc == NULL
4681                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
4682                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
4683                         return FALSE;
4684                     }
4685                   elf_section_data (sec)->sreloc = sreloc;
4686                 }
4687
4688               /* If this is a global symbol, we count the number of
4689                  relocations we need for this symbol.  */
4690               if (h != NULL)
4691                 {
4692                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
4693                 }
4694               else
4695                 {
4696                   /* Track dynamic relocs needed for local syms too.
4697                      We really need local syms available to do this
4698                      easily.  Oh well.  */
4699
4700                   asection *s;
4701                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4702                                                  sec, r_symndx);
4703                   if (s == NULL)
4704                     return FALSE;
4705
4706                   head = ((struct ppc_dyn_relocs **)
4707                           &elf_section_data (s)->local_dynrel);
4708                 }
4709
4710               p = *head;
4711               if (p == NULL || p->sec != sec)
4712                 {
4713                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4714                   if (p == NULL)
4715                     return FALSE;
4716                   p->next = *head;
4717                   *head = p;
4718                   p->sec = sec;
4719                   p->count = 0;
4720                   p->pc_count = 0;
4721                 }
4722
4723               p->count += 1;
4724               if (!MUST_BE_DYN_RELOC (r_type))
4725                 p->pc_count += 1;
4726             }
4727           break;
4728
4729         default:
4730           break;
4731         }
4732     }
4733
4734   return TRUE;
4735 }
4736
4737 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
4738    of the code entry point, and its section.  */
4739
4740 static bfd_vma
4741 opd_entry_value (asection *opd_sec,
4742                  bfd_vma offset,
4743                  asection **code_sec,
4744                  bfd_vma *code_off)
4745 {
4746   bfd *opd_bfd = opd_sec->owner;
4747   Elf_Internal_Rela *relocs;
4748   Elf_Internal_Rela *lo, *hi, *look;
4749   bfd_vma val;
4750
4751   /* No relocs implies we are linking a --just-symbols object.  */
4752   if (opd_sec->reloc_count == 0)
4753     {
4754       bfd_vma val;
4755
4756       if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
4757         return (bfd_vma) -1;
4758
4759       if (code_sec != NULL)
4760         {
4761           asection *sec, *likely = NULL;
4762           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
4763             if (sec->vma <= val
4764                 && (sec->flags & SEC_LOAD) != 0
4765                 && (sec->flags & SEC_ALLOC) != 0)
4766               likely = sec;
4767           if (likely != NULL)
4768             {
4769               *code_sec = likely;
4770               if (code_off != NULL)
4771                 *code_off = val - likely->vma;
4772             }
4773         }
4774       return val;
4775     }
4776
4777   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
4778   if (relocs == NULL)
4779     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
4780
4781   /* Go find the opd reloc at the sym address.  */
4782   lo = relocs;
4783   BFD_ASSERT (lo != NULL);
4784   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
4785   val = (bfd_vma) -1;
4786   while (lo < hi)
4787     {
4788       look = lo + (hi - lo) / 2;
4789       if (look->r_offset < offset)
4790         lo = look + 1;
4791       else if (look->r_offset > offset)
4792         hi = look;
4793       else
4794         {
4795           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (opd_bfd)->symtab_hdr;
4796           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
4797               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
4798             {
4799               unsigned long symndx = ELF64_R_SYM (look->r_info);
4800               asection *sec;
4801
4802               if (symndx < symtab_hdr->sh_info)
4803                 {
4804                   Elf_Internal_Sym *sym;
4805
4806                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
4807                   if (sym == NULL)
4808                     {
4809                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
4810                                                   symtab_hdr->sh_info,
4811                                                   0, NULL, NULL, NULL);
4812                       if (sym == NULL)
4813                         break;
4814                       symtab_hdr->contents = (bfd_byte *) sym;
4815                     }
4816
4817                   sym += symndx;
4818                   val = sym->st_value;
4819                   sec = NULL;
4820                   if ((sym->st_shndx != SHN_UNDEF
4821                        && sym->st_shndx < SHN_LORESERVE)
4822                       || sym->st_shndx > SHN_HIRESERVE)
4823                     sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
4824                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
4825                 }
4826               else
4827                 {
4828                   struct elf_link_hash_entry **sym_hashes;
4829                   struct elf_link_hash_entry *rh;
4830
4831                   sym_hashes = elf_sym_hashes (opd_bfd);
4832                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
4833                   while (rh->root.type == bfd_link_hash_indirect
4834                          || rh->root.type == bfd_link_hash_warning)
4835                     rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
4836                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
4837                               || rh->root.type == bfd_link_hash_defweak);
4838                   val = rh->root.u.def.value;
4839                   sec = rh->root.u.def.section;
4840                 }
4841               val += look->r_addend;
4842               if (code_off != NULL)
4843                 *code_off = val;
4844               if (code_sec != NULL)
4845                 *code_sec = sec;
4846               if (sec != NULL && sec->output_section != NULL)
4847                 val += sec->output_section->vma + sec->output_offset;
4848             }
4849           break;
4850         }
4851     }
4852
4853   return val;
4854 }
4855
4856 /* Return the section that should be marked against GC for a given
4857    relocation.  */
4858
4859 static asection *
4860 ppc64_elf_gc_mark_hook (asection *sec,
4861                         struct bfd_link_info *info,
4862                         Elf_Internal_Rela *rel,
4863                         struct elf_link_hash_entry *h,
4864                         Elf_Internal_Sym *sym)
4865 {
4866   asection *rsec;
4867
4868   /* First mark all our entry sym sections.  */
4869   if (info->gc_sym_list != NULL)
4870     {
4871       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4872       struct bfd_sym_chain *sym = info->gc_sym_list;
4873
4874       info->gc_sym_list = NULL;
4875       do
4876         {
4877           struct ppc_link_hash_entry *eh;
4878
4879           eh = (struct ppc_link_hash_entry *)
4880             elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
4881           if (eh == NULL)
4882             continue;
4883           if (eh->elf.root.type != bfd_link_hash_defined
4884               && eh->elf.root.type != bfd_link_hash_defweak)
4885             continue;
4886
4887           if (eh->is_func_descriptor)
4888             rsec = eh->oh->elf.root.u.def.section;
4889           else if (get_opd_info (eh->elf.root.u.def.section) != NULL
4890                    && opd_entry_value (eh->elf.root.u.def.section,
4891                                        eh->elf.root.u.def.value,
4892                                        &rsec, NULL) != (bfd_vma) -1)
4893             ;
4894           else
4895             continue;
4896
4897           if (!rsec->gc_mark)
4898             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
4899
4900           rsec = eh->elf.root.u.def.section;
4901           if (!rsec->gc_mark)
4902             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
4903
4904           sym = sym->next;
4905         }
4906       while (sym != NULL);
4907     }
4908
4909   /* Syms return NULL if we're marking .opd, so we avoid marking all
4910      function sections, as all functions are referenced in .opd.  */
4911   rsec = NULL;
4912   if (get_opd_info (sec) != NULL)
4913     return rsec;
4914
4915   if (h != NULL)
4916     {
4917       enum elf_ppc64_reloc_type r_type;
4918       struct ppc_link_hash_entry *eh;
4919
4920       r_type = ELF64_R_TYPE (rel->r_info);
4921       switch (r_type)
4922         {
4923         case R_PPC64_GNU_VTINHERIT:
4924         case R_PPC64_GNU_VTENTRY:
4925           break;
4926
4927         default:
4928           switch (h->root.type)
4929             {
4930             case bfd_link_hash_defined:
4931             case bfd_link_hash_defweak:
4932               eh = (struct ppc_link_hash_entry *) h;
4933               if (eh->oh != NULL && eh->oh->is_func_descriptor)
4934                 eh = eh->oh;
4935
4936               /* Function descriptor syms cause the associated
4937                  function code sym section to be marked.  */
4938               if (eh->is_func_descriptor)
4939                 {
4940                   /* They also mark their opd section.  */
4941                   if (!eh->elf.root.u.def.section->gc_mark)
4942                     _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
4943                                       ppc64_elf_gc_mark_hook);
4944
4945                   rsec = eh->oh->elf.root.u.def.section;
4946                 }
4947               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
4948                        && opd_entry_value (eh->elf.root.u.def.section,
4949                                            eh->elf.root.u.def.value,
4950                                            &rsec, NULL) != (bfd_vma) -1)
4951                 {
4952                   if (!eh->elf.root.u.def.section->gc_mark)
4953                     _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
4954                                       ppc64_elf_gc_mark_hook);
4955                 }
4956               else
4957                 rsec = h->root.u.def.section;
4958               break;
4959
4960             case bfd_link_hash_common:
4961               rsec = h->root.u.c.p->section;
4962               break;
4963
4964             default:
4965               break;
4966             }
4967         }
4968     }
4969   else
4970     {
4971       asection **opd_sym_section;
4972
4973       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4974       opd_sym_section = get_opd_info (rsec);
4975       if (opd_sym_section != NULL)
4976         {
4977           if (!rsec->gc_mark)
4978             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
4979
4980           rsec = opd_sym_section[sym->st_value / 8];
4981         }
4982     }
4983
4984   return rsec;
4985 }
4986
4987 /* Update the .got, .plt. and dynamic reloc reference counts for the
4988    section being removed.  */
4989
4990 static bfd_boolean
4991 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
4992                          asection *sec, const Elf_Internal_Rela *relocs)
4993 {
4994   struct ppc_link_hash_table *htab;
4995   Elf_Internal_Shdr *symtab_hdr;
4996   struct elf_link_hash_entry **sym_hashes;
4997   struct got_entry **local_got_ents;
4998   const Elf_Internal_Rela *rel, *relend;
4999
5000   if ((sec->flags & SEC_ALLOC) == 0)
5001     return TRUE;
5002
5003   elf_section_data (sec)->local_dynrel = NULL;
5004
5005   htab = ppc_hash_table (info);
5006   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5007   sym_hashes = elf_sym_hashes (abfd);
5008   local_got_ents = elf_local_got_ents (abfd);
5009
5010   relend = relocs + sec->reloc_count;
5011   for (rel = relocs; rel < relend; rel++)
5012     {
5013       unsigned long r_symndx;
5014       enum elf_ppc64_reloc_type r_type;
5015       struct elf_link_hash_entry *h = NULL;
5016       char tls_type = 0;
5017
5018       r_symndx = ELF64_R_SYM (rel->r_info);
5019       r_type = ELF64_R_TYPE (rel->r_info);
5020       if (r_symndx >= symtab_hdr->sh_info)
5021         {
5022           struct ppc_link_hash_entry *eh;
5023           struct ppc_dyn_relocs **pp;
5024           struct ppc_dyn_relocs *p;
5025
5026           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5027           while (h->root.type == bfd_link_hash_indirect
5028                  || h->root.type == bfd_link_hash_warning)
5029             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5030           eh = (struct ppc_link_hash_entry *) h;
5031
5032           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5033             if (p->sec == sec)
5034               {
5035                 /* Everything must go for SEC.  */
5036                 *pp = p->next;
5037                 break;
5038               }
5039         }
5040
5041       switch (r_type)
5042         {
5043         case R_PPC64_GOT_TLSLD16:
5044         case R_PPC64_GOT_TLSLD16_LO:
5045         case R_PPC64_GOT_TLSLD16_HI:
5046         case R_PPC64_GOT_TLSLD16_HA:
5047           ppc64_tlsld_got (abfd)->refcount -= 1;
5048           tls_type = TLS_TLS | TLS_LD;
5049           goto dogot;
5050
5051         case R_PPC64_GOT_TLSGD16:
5052         case R_PPC64_GOT_TLSGD16_LO:
5053         case R_PPC64_GOT_TLSGD16_HI:
5054         case R_PPC64_GOT_TLSGD16_HA:
5055           tls_type = TLS_TLS | TLS_GD;
5056           goto dogot;
5057
5058         case R_PPC64_GOT_TPREL16_DS:
5059         case R_PPC64_GOT_TPREL16_LO_DS:
5060         case R_PPC64_GOT_TPREL16_HI:
5061         case R_PPC64_GOT_TPREL16_HA:
5062           tls_type = TLS_TLS | TLS_TPREL;
5063           goto dogot;
5064
5065         case R_PPC64_GOT_DTPREL16_DS:
5066         case R_PPC64_GOT_DTPREL16_LO_DS:
5067         case R_PPC64_GOT_DTPREL16_HI:
5068         case R_PPC64_GOT_DTPREL16_HA:
5069           tls_type = TLS_TLS | TLS_DTPREL;
5070           goto dogot;
5071
5072         case R_PPC64_GOT16:
5073         case R_PPC64_GOT16_DS:
5074         case R_PPC64_GOT16_HA:
5075         case R_PPC64_GOT16_HI:
5076         case R_PPC64_GOT16_LO:
5077         case R_PPC64_GOT16_LO_DS:
5078         dogot:
5079           {
5080             struct got_entry *ent;
5081
5082             if (h != NULL)
5083               ent = h->got.glist;
5084             else
5085               ent = local_got_ents[r_symndx];
5086
5087             for (; ent != NULL; ent = ent->next)
5088               if (ent->addend == rel->r_addend
5089                   && ent->owner == abfd
5090                   && ent->tls_type == tls_type)
5091                 break;
5092             if (ent == NULL)
5093               abort ();
5094             if (ent->got.refcount > 0)
5095               ent->got.refcount -= 1;
5096           }
5097           break;
5098
5099         case R_PPC64_PLT16_HA:
5100         case R_PPC64_PLT16_HI:
5101         case R_PPC64_PLT16_LO:
5102         case R_PPC64_PLT32:
5103         case R_PPC64_PLT64:
5104         case R_PPC64_REL14:
5105         case R_PPC64_REL14_BRNTAKEN:
5106         case R_PPC64_REL14_BRTAKEN:
5107         case R_PPC64_REL24:
5108           if (h != NULL)
5109             {
5110               struct plt_entry *ent;
5111
5112               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5113                 if (ent->addend == rel->r_addend)
5114                   break;
5115               if (ent == NULL)
5116                 abort ();
5117               if (ent->plt.refcount > 0)
5118                 ent->plt.refcount -= 1;
5119             }
5120           break;
5121
5122         default:
5123           break;
5124         }
5125     }
5126   return TRUE;
5127 }
5128
5129 /* The maximum size of .sfpr.  */
5130 #define SFPR_MAX (218*4)
5131
5132 struct sfpr_def_parms
5133 {
5134   const char name[12];
5135   unsigned char lo, hi;
5136   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5137   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5138 };
5139
5140 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5141
5142 static unsigned int
5143 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5144 {
5145   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5146   unsigned int i;
5147   size_t len = strlen (parm->name);
5148   bfd_boolean writing = FALSE;
5149   char sym[16];
5150
5151   memcpy (sym, parm->name, len);
5152   sym[len + 2] = 0;
5153
5154   for (i = parm->lo; i <= parm->hi; i++)
5155     {
5156       struct elf_link_hash_entry *h;
5157
5158       sym[len + 0] = i / 10 + '0';
5159       sym[len + 1] = i % 10 + '0';
5160       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5161       if (h != NULL
5162           && !h->def_regular)
5163         {
5164           h->root.type = bfd_link_hash_defined;
5165           h->root.u.def.section = htab->sfpr;
5166           h->root.u.def.value = htab->sfpr->size;
5167           h->type = STT_FUNC;
5168           h->def_regular = 1;
5169           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5170           writing = TRUE;
5171           if (htab->sfpr->contents == NULL)
5172             {
5173               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5174               if (htab->sfpr->contents == NULL)
5175                 return FALSE;
5176             }
5177         }
5178       if (writing)
5179         {
5180           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5181           if (i != parm->hi)
5182             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5183           else
5184             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5185           htab->sfpr->size = p - htab->sfpr->contents;
5186         }
5187     }
5188
5189   return TRUE;
5190 }
5191
5192 static bfd_byte *
5193 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5194 {
5195   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5196   return p + 4;
5197 }
5198
5199 static bfd_byte *
5200 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5201 {
5202   p = savegpr0 (abfd, p, r);
5203   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5204   p = p + 4;
5205   bfd_put_32 (abfd, BLR, p);
5206   return p + 4;
5207 }
5208
5209 static bfd_byte *
5210 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5211 {
5212   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5213   return p + 4;
5214 }
5215
5216 static bfd_byte *
5217 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5218 {
5219   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5220   p = p + 4;
5221   p = restgpr0 (abfd, p, r);
5222   bfd_put_32 (abfd, MTLR_R0, p);
5223   p = p + 4;
5224   if (r == 29)
5225     {
5226       p = restgpr0 (abfd, p, 30);
5227       p = restgpr0 (abfd, p, 31);
5228     }
5229   bfd_put_32 (abfd, BLR, p);
5230   return p + 4;
5231 }
5232
5233 static bfd_byte *
5234 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5235 {
5236   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5237   return p + 4;
5238 }
5239
5240 static bfd_byte *
5241 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5242 {
5243   p = savegpr1 (abfd, p, r);
5244   bfd_put_32 (abfd, BLR, p);
5245   return p + 4;
5246 }
5247
5248 static bfd_byte *
5249 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5250 {
5251   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5252   return p + 4;
5253 }
5254
5255 static bfd_byte *
5256 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5257 {
5258   p = restgpr1 (abfd, p, r);
5259   bfd_put_32 (abfd, BLR, p);
5260   return p + 4;
5261 }
5262
5263 static bfd_byte *
5264 savefpr (bfd *abfd, bfd_byte *p, int r)
5265 {
5266   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5267   return p + 4;
5268 }
5269
5270 static bfd_byte *
5271 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5272 {
5273   p = savefpr (abfd, p, r);
5274   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5275   p = p + 4;
5276   bfd_put_32 (abfd, BLR, p);
5277   return p + 4;
5278 }
5279
5280 static bfd_byte *
5281 restfpr (bfd *abfd, bfd_byte *p, int r)
5282 {
5283   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5284   return p + 4;
5285 }
5286
5287 static bfd_byte *
5288 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5289 {
5290   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5291   p = p + 4;
5292   p = restfpr (abfd, p, r);
5293   bfd_put_32 (abfd, MTLR_R0, p);
5294   p = p + 4;
5295   if (r == 29)
5296     {
5297       p = restfpr (abfd, p, 30);
5298       p = restfpr (abfd, p, 31);
5299     }
5300   bfd_put_32 (abfd, BLR, p);
5301   return p + 4;
5302 }
5303
5304 static bfd_byte *
5305 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5306 {
5307   p = savefpr (abfd, p, r);
5308   bfd_put_32 (abfd, BLR, p);
5309   return p + 4;
5310 }
5311
5312 static bfd_byte *
5313 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5314 {
5315   p = restfpr (abfd, p, r);
5316   bfd_put_32 (abfd, BLR, p);
5317   return p + 4;
5318 }
5319
5320 static bfd_byte *
5321 savevr (bfd *abfd, bfd_byte *p, int r)
5322 {
5323   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5324   p = p + 4;
5325   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5326   return p + 4;
5327 }
5328
5329 static bfd_byte *
5330 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5331 {
5332   p = savevr (abfd, p, r);
5333   bfd_put_32 (abfd, BLR, p);
5334   return p + 4;
5335 }
5336
5337 static bfd_byte *
5338 restvr (bfd *abfd, bfd_byte *p, int r)
5339 {
5340   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5341   p = p + 4;
5342   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5343   return p + 4;
5344 }
5345
5346 static bfd_byte *
5347 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5348 {
5349   p = restvr (abfd, p, r);
5350   bfd_put_32 (abfd, BLR, p);
5351   return p + 4;
5352 }
5353
5354 /* Called via elf_link_hash_traverse to transfer dynamic linking
5355    information on function code symbol entries to their corresponding
5356    function descriptor symbol entries.  */
5357
5358 static bfd_boolean
5359 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5360 {
5361   struct bfd_link_info *info;
5362   struct ppc_link_hash_table *htab;
5363   struct plt_entry *ent;
5364   struct ppc_link_hash_entry *fh;
5365   struct ppc_link_hash_entry *fdh;
5366   bfd_boolean force_local;
5367
5368   fh = (struct ppc_link_hash_entry *) h;
5369   if (fh->elf.root.type == bfd_link_hash_indirect)
5370     return TRUE;
5371
5372   if (fh->elf.root.type == bfd_link_hash_warning)
5373     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5374
5375   info = inf;
5376   htab = ppc_hash_table (info);
5377
5378   /* Resolve undefined references to dot-symbols as the value
5379      in the function descriptor, if we have one in a regular object.
5380      This is to satisfy cases like ".quad .foo".  Calls to functions
5381      in dynamic objects are handled elsewhere.  */
5382   if (fh->elf.root.type == bfd_link_hash_undefweak
5383       && fh->was_undefined
5384       && (fh->oh->elf.root.type == bfd_link_hash_defined
5385           || fh->oh->elf.root.type == bfd_link_hash_defweak)
5386       && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5387       && opd_entry_value (fh->oh->elf.root.u.def.section,
5388                           fh->oh->elf.root.u.def.value,
5389                           &fh->elf.root.u.def.section,
5390                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
5391     {
5392       fh->elf.root.type = fh->oh->elf.root.type;
5393       fh->elf.forced_local = 1;
5394     }
5395
5396   /* If this is a function code symbol, transfer dynamic linking
5397      information to the function descriptor symbol.  */
5398   if (!fh->is_func)
5399     return TRUE;
5400
5401   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
5402     if (ent->plt.refcount > 0)
5403       break;
5404   if (ent == NULL
5405       || fh->elf.root.root.string[0] != '.'
5406       || fh->elf.root.root.string[1] == '\0')
5407     return TRUE;
5408
5409   /* Find the corresponding function descriptor symbol.  Create it
5410      as undefined if necessary.  */
5411
5412   fdh = get_fdh (fh, htab);
5413   if (fdh != NULL)
5414     while (fdh->elf.root.type == bfd_link_hash_indirect
5415            || fdh->elf.root.type == bfd_link_hash_warning)
5416       fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5417
5418   if (fdh == NULL
5419       && info->shared
5420       && (fh->elf.root.type == bfd_link_hash_undefined
5421           || fh->elf.root.type == bfd_link_hash_undefweak))
5422     {
5423       fdh = make_fdh (info, fh);
5424       if (fdh == NULL)
5425         return FALSE;
5426     }
5427
5428   /* Fake function descriptors are made undefweak.  If the function
5429      code symbol is strong undefined, make the fake sym the same.  */
5430
5431   if (fdh != NULL
5432       && fdh->fake
5433       && fdh->elf.root.type == bfd_link_hash_undefweak
5434       && fh->elf.root.type == bfd_link_hash_undefined)
5435     {
5436       fdh->elf.root.type = bfd_link_hash_undefined;
5437       bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
5438     }
5439
5440   if (fdh != NULL
5441       && !fdh->elf.forced_local
5442       && (info->shared
5443           || fdh->elf.def_dynamic
5444           || fdh->elf.ref_dynamic
5445           || (fdh->elf.root.type == bfd_link_hash_undefweak
5446               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5447     {
5448       if (fdh->elf.dynindx == -1)
5449         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5450           return FALSE;
5451       fdh->elf.ref_regular |= fh->elf.ref_regular;
5452       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5453       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5454       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
5455       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
5456         {
5457           struct plt_entry **ep = &fdh->elf.plt.plist;
5458           while (*ep != NULL)
5459             ep = &(*ep)->next;
5460           *ep = fh->elf.plt.plist;
5461           fh->elf.plt.plist = NULL;
5462           fdh->elf.needs_plt = 1;
5463         }
5464       fdh->is_func_descriptor = 1;
5465       fdh->oh = fh;
5466       fh->oh = fdh;
5467     }
5468
5469   /* Now that the info is on the function descriptor, clear the
5470      function code sym info.  Any function code syms for which we
5471      don't have a definition in a regular file, we force local.
5472      This prevents a shared library from exporting syms that have
5473      been imported from another library.  Function code syms that
5474      are really in the library we must leave global to prevent the
5475      linker dragging in a definition from a static library.  */
5476   force_local
5477     = (info->shared
5478        && (!fh->elf.def_regular
5479            || fdh == NULL
5480            || !fdh->elf.def_regular
5481            || fdh->elf.forced_local));
5482   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5483
5484   return TRUE;
5485 }
5486
5487 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
5488    this hook to a) provide some gcc support functions, and b) transfer
5489    dynamic linking information gathered so far on function code symbol
5490    entries, to their corresponding function descriptor symbol entries.  */
5491
5492 static bfd_boolean
5493 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5494                             struct bfd_link_info *info)
5495 {
5496   struct ppc_link_hash_table *htab;
5497   unsigned int i;
5498   const struct sfpr_def_parms funcs[] =
5499     {
5500       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5501       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5502       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5503       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5504       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5505       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5506       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5507       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5508       { "._savef", 14, 31, savefpr, savefpr1_tail },
5509       { "._restf", 14, 31, restfpr, restfpr1_tail },
5510       { "_savevr_", 20, 31, savevr, savevr_tail },
5511       { "_restvr_", 20, 31, restvr, restvr_tail }
5512     };
5513
5514   htab = ppc_hash_table (info);
5515   if (htab->sfpr == NULL)
5516     /* We don't have any relocs.  */
5517     return TRUE;
5518
5519   /* Provide any missing _save* and _rest* functions.  */
5520   htab->sfpr->size = 0;
5521   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5522     if (!sfpr_define (info, &funcs[i]))
5523       return FALSE;
5524
5525   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5526
5527   if (htab->sfpr->size == 0)
5528     _bfd_strip_section_from_output (info, htab->sfpr);
5529
5530   return TRUE;
5531 }
5532
5533 /* Adjust a symbol defined by a dynamic object and referenced by a
5534    regular object.  The current definition is in some section of the
5535    dynamic object, but we're not including those sections.  We have to
5536    change the definition to something the rest of the link can
5537    understand.  */
5538
5539 static bfd_boolean
5540 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5541                                  struct elf_link_hash_entry *h)
5542 {
5543   struct ppc_link_hash_table *htab;
5544   asection *s;
5545   unsigned int power_of_two;
5546
5547   htab = ppc_hash_table (info);
5548
5549   /* Deal with function syms.  */
5550   if (h->type == STT_FUNC
5551       || h->needs_plt)
5552     {
5553       /* Clear procedure linkage table information for any symbol that
5554          won't need a .plt entry.  */
5555       struct plt_entry *ent;
5556       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5557         if (ent->plt.refcount > 0)
5558           break;
5559       if (ent == NULL
5560           || SYMBOL_CALLS_LOCAL (info, h)
5561           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5562               && h->root.type == bfd_link_hash_undefweak))
5563         {
5564           h->plt.plist = NULL;
5565           h->needs_plt = 0;
5566         }
5567     }
5568   else
5569     h->plt.plist = NULL;
5570
5571   /* If this is a weak symbol, and there is a real definition, the
5572      processor independent code will have arranged for us to see the
5573      real definition first, and we can just use the same value.  */
5574   if (h->u.weakdef != NULL)
5575     {
5576       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5577                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5578       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5579       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5580       if (ELIMINATE_COPY_RELOCS)
5581         h->non_got_ref = h->u.weakdef->non_got_ref;
5582       return TRUE;
5583     }
5584
5585   /* If we are creating a shared library, we must presume that the
5586      only references to the symbol are via the global offset table.
5587      For such cases we need not do anything here; the relocations will
5588      be handled correctly by relocate_section.  */
5589   if (info->shared)
5590     return TRUE;
5591
5592   /* If there are no references to this symbol that do not use the
5593      GOT, we don't need to generate a copy reloc.  */
5594   if (!h->non_got_ref)
5595     return TRUE;
5596
5597   if (ELIMINATE_COPY_RELOCS)
5598     {
5599       struct ppc_link_hash_entry * eh;
5600       struct ppc_dyn_relocs *p;
5601
5602       eh = (struct ppc_link_hash_entry *) h;
5603       for (p = eh->dyn_relocs; p != NULL; p = p->next)
5604         {
5605           s = p->sec->output_section;
5606           if (s != NULL && (s->flags & SEC_READONLY) != 0)
5607             break;
5608         }
5609
5610       /* If we didn't find any dynamic relocs in read-only sections, then
5611          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
5612       if (p == NULL)
5613         {
5614           h->non_got_ref = 0;
5615           return TRUE;
5616         }
5617     }
5618
5619   if (h->plt.plist != NULL)
5620     {
5621       /* We should never get here, but unfortunately there are versions
5622          of gcc out there that improperly (for this ABI) put initialized
5623          function pointers, vtable refs and suchlike in read-only
5624          sections.  Allow them to proceed, but warn that this might
5625          break at runtime.  */
5626       (*_bfd_error_handler)
5627         (_("copy reloc against `%s' requires lazy plt linking; "
5628            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
5629          h->root.root.string);
5630     }
5631
5632   /* This is a reference to a symbol defined by a dynamic object which
5633      is not a function.  */
5634
5635   /* We must allocate the symbol in our .dynbss section, which will
5636      become part of the .bss section of the executable.  There will be
5637      an entry for this symbol in the .dynsym section.  The dynamic
5638      object will contain position independent code, so all references
5639      from the dynamic object to this symbol will go through the global
5640      offset table.  The dynamic linker will use the .dynsym entry to
5641      determine the address it must put in the global offset table, so
5642      both the dynamic object and the regular object will refer to the
5643      same memory location for the variable.  */
5644
5645   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
5646      to copy the initial value out of the dynamic object and into the
5647      runtime process image.  We need to remember the offset into the
5648      .rela.bss section we are going to use.  */
5649   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5650     {
5651       htab->relbss->size += sizeof (Elf64_External_Rela);
5652       h->needs_copy = 1;
5653     }
5654
5655   /* We need to figure out the alignment required for this symbol.  I
5656      have no idea how ELF linkers handle this.  */
5657   power_of_two = bfd_log2 (h->size);
5658   if (power_of_two > 4)
5659     power_of_two = 4;
5660
5661   /* Apply the required alignment.  */
5662   s = htab->dynbss;
5663   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5664   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
5665     {
5666       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
5667         return FALSE;
5668     }
5669
5670   /* Define the symbol as being at this point in the section.  */
5671   h->root.u.def.section = s;
5672   h->root.u.def.value = s->size;
5673
5674   /* Increment the section size to make room for the symbol.  */
5675   s->size += h->size;
5676
5677   return TRUE;
5678 }
5679
5680 /* If given a function descriptor symbol, hide both the function code
5681    sym and the descriptor.  */
5682 static void
5683 ppc64_elf_hide_symbol (struct bfd_link_info *info,
5684                        struct elf_link_hash_entry *h,
5685                        bfd_boolean force_local)
5686 {
5687   struct ppc_link_hash_entry *eh;
5688   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
5689
5690   eh = (struct ppc_link_hash_entry *) h;
5691   if (eh->is_func_descriptor)
5692     {
5693       struct ppc_link_hash_entry *fh = eh->oh;
5694
5695       if (fh == NULL)
5696         {
5697           const char *p, *q;
5698           struct ppc_link_hash_table *htab;
5699           char save;
5700
5701           /* We aren't supposed to use alloca in BFD because on
5702              systems which do not have alloca the version in libiberty
5703              calls xmalloc, which might cause the program to crash
5704              when it runs out of memory.  This function doesn't have a
5705              return status, so there's no way to gracefully return an
5706              error.  So cheat.  We know that string[-1] can be safely
5707              accessed;  It's either a string in an ELF string table,
5708              or allocated in an objalloc structure.  */
5709
5710           p = eh->elf.root.root.string - 1;
5711           save = *p;
5712           *(char *) p = '.';
5713           htab = ppc_hash_table (info);
5714           fh = (struct ppc_link_hash_entry *)
5715             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5716           *(char *) p = save;
5717
5718           /* Unfortunately, if it so happens that the string we were
5719              looking for was allocated immediately before this string,
5720              then we overwrote the string terminator.  That's the only
5721              reason the lookup should fail.  */
5722           if (fh == NULL)
5723             {
5724               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
5725               while (q >= eh->elf.root.root.string && *q == *p)
5726                 --q, --p;
5727               if (q < eh->elf.root.root.string && *p == '.')
5728                 fh = (struct ppc_link_hash_entry *)
5729                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5730             }
5731           if (fh != NULL)
5732             {
5733               eh->oh = fh;
5734               fh->oh = eh;
5735             }
5736         }
5737       if (fh != NULL)
5738         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5739     }
5740 }
5741
5742 static bfd_boolean
5743 get_sym_h (struct elf_link_hash_entry **hp,
5744            Elf_Internal_Sym **symp,
5745            asection **symsecp,
5746            char **tls_maskp,
5747            Elf_Internal_Sym **locsymsp,
5748            unsigned long r_symndx,
5749            bfd *ibfd)
5750 {
5751   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5752
5753   if (r_symndx >= symtab_hdr->sh_info)
5754     {
5755       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
5756       struct elf_link_hash_entry *h;
5757
5758       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5759       while (h->root.type == bfd_link_hash_indirect
5760              || h->root.type == bfd_link_hash_warning)
5761         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5762
5763       if (hp != NULL)
5764         *hp = h;
5765
5766       if (symp != NULL)
5767         *symp = NULL;
5768
5769       if (symsecp != NULL)
5770         {
5771           asection *symsec = NULL;
5772           if (h->root.type == bfd_link_hash_defined
5773               || h->root.type == bfd_link_hash_defweak)
5774             symsec = h->root.u.def.section;
5775           *symsecp = symsec;
5776         }
5777
5778       if (tls_maskp != NULL)
5779         {
5780           struct ppc_link_hash_entry *eh;
5781
5782           eh = (struct ppc_link_hash_entry *) h;
5783           *tls_maskp = &eh->tls_mask;
5784         }
5785     }
5786   else
5787     {
5788       Elf_Internal_Sym *sym;
5789       Elf_Internal_Sym *locsyms = *locsymsp;
5790
5791       if (locsyms == NULL)
5792         {
5793           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
5794           if (locsyms == NULL)
5795             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
5796                                             symtab_hdr->sh_info,
5797                                             0, NULL, NULL, NULL);
5798           if (locsyms == NULL)
5799             return FALSE;
5800           *locsymsp = locsyms;
5801         }
5802       sym = locsyms + r_symndx;
5803
5804       if (hp != NULL)
5805         *hp = NULL;
5806
5807       if (symp != NULL)
5808         *symp = sym;
5809
5810       if (symsecp != NULL)
5811         {
5812           asection *symsec = NULL;
5813           if ((sym->st_shndx != SHN_UNDEF
5814                && sym->st_shndx < SHN_LORESERVE)
5815               || sym->st_shndx > SHN_HIRESERVE)
5816             symsec = bfd_section_from_elf_index (ibfd, sym->st_shndx);
5817           *symsecp = symsec;
5818         }
5819
5820       if (tls_maskp != NULL)
5821         {
5822           struct got_entry **lgot_ents;
5823           char *tls_mask;
5824
5825           tls_mask = NULL;
5826           lgot_ents = elf_local_got_ents (ibfd);
5827           if (lgot_ents != NULL)
5828             {
5829               char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
5830               tls_mask = &lgot_masks[r_symndx];
5831             }
5832           *tls_maskp = tls_mask;
5833         }
5834     }
5835   return TRUE;
5836 }
5837
5838 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
5839    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
5840    type suitable for optimization, and 1 otherwise.  */
5841
5842 static int
5843 get_tls_mask (char **tls_maskp, unsigned long *toc_symndx,
5844               Elf_Internal_Sym **locsymsp,
5845               const Elf_Internal_Rela *rel, bfd *ibfd)
5846 {
5847   unsigned long r_symndx;
5848   int next_r;
5849   struct elf_link_hash_entry *h;
5850   Elf_Internal_Sym *sym;
5851   asection *sec;
5852   bfd_vma off;
5853
5854   r_symndx = ELF64_R_SYM (rel->r_info);
5855   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
5856     return 0;
5857
5858   if ((*tls_maskp != NULL && **tls_maskp != 0)
5859       || sec == NULL
5860       || ppc64_elf_section_data (sec)->t_symndx == NULL)
5861     return 1;
5862
5863   /* Look inside a TOC section too.  */
5864   if (h != NULL)
5865     {
5866       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5867       off = h->root.u.def.value;
5868     }
5869   else
5870     off = sym->st_value;
5871   off += rel->r_addend;
5872   BFD_ASSERT (off % 8 == 0);
5873   r_symndx = ppc64_elf_section_data (sec)->t_symndx[off / 8];
5874   next_r = ppc64_elf_section_data (sec)->t_symndx[off / 8 + 1];
5875   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
5876     return 0;
5877   if (toc_symndx != NULL)
5878     *toc_symndx = r_symndx;
5879   if ((h == NULL
5880        || ((h->root.type == bfd_link_hash_defined
5881             || h->root.type == bfd_link_hash_defweak)
5882            && !h->def_dynamic))
5883       && (next_r == -1 || next_r == -2))
5884     return 1 - next_r;
5885   return 1;
5886 }
5887
5888 /* Adjust all global syms defined in opd sections.  In gcc generated
5889    code for the old ABI, these will already have been done.  */
5890
5891 static bfd_boolean
5892 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
5893 {
5894   struct ppc_link_hash_entry *eh;
5895   asection *sym_sec;
5896   long *opd_adjust;
5897
5898   if (h->root.type == bfd_link_hash_indirect)
5899     return TRUE;
5900
5901   if (h->root.type == bfd_link_hash_warning)
5902     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5903
5904   if (h->root.type != bfd_link_hash_defined
5905       && h->root.type != bfd_link_hash_defweak)
5906     return TRUE;
5907
5908   eh = (struct ppc_link_hash_entry *) h;
5909   if (eh->adjust_done)
5910     return TRUE;
5911
5912   sym_sec = eh->elf.root.u.def.section;
5913   opd_adjust = get_opd_info (sym_sec);
5914   if (opd_adjust != NULL)
5915     {
5916       long adjust = opd_adjust[eh->elf.root.u.def.value / 8];
5917       if (adjust == -1)
5918         {
5919           /* This entry has been deleted.  */
5920           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
5921           if (dsec == NULL)
5922             {
5923               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
5924                 if (elf_discarded_section (dsec))
5925                   {
5926                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
5927                     break;
5928                   }
5929             }
5930           eh->elf.root.u.def.value = 0;
5931           eh->elf.root.u.def.section = dsec;
5932         }
5933       else
5934         eh->elf.root.u.def.value += adjust;
5935       eh->adjust_done = 1;
5936     }
5937   return TRUE;
5938 }
5939
5940 /* Remove unused Official Procedure Descriptor entries.  Currently we
5941    only remove those associated with functions in discarded link-once
5942    sections, or weakly defined functions that have been overridden.  It
5943    would be possible to remove many more entries for statically linked
5944    applications.  */
5945
5946 bfd_boolean
5947 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
5948                     bfd_boolean non_overlapping)
5949 {
5950   bfd *ibfd;
5951   bfd_boolean some_edited = FALSE;
5952   asection *need_pad = NULL;
5953
5954   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5955     {
5956       asection *sec;
5957       Elf_Internal_Rela *relstart, *rel, *relend;
5958       Elf_Internal_Shdr *symtab_hdr;
5959       Elf_Internal_Sym *local_syms;
5960       struct elf_link_hash_entry **sym_hashes;
5961       bfd_vma offset;
5962       bfd_size_type amt;
5963       long *opd_adjust;
5964       bfd_boolean need_edit, add_aux_fields;
5965       bfd_size_type cnt_16b = 0;
5966
5967       sec = bfd_get_section_by_name (ibfd, ".opd");
5968       if (sec == NULL)
5969         continue;
5970
5971       amt = sec->size * sizeof (long) / 8;
5972       opd_adjust = get_opd_info (sec);
5973       if (opd_adjust == NULL)
5974         {
5975           /* check_relocs hasn't been called.  Must be a ld -r link
5976              or --just-symbols object.   */
5977           opd_adjust = bfd_zalloc (obfd, amt);
5978           ppc64_elf_section_data (sec)->opd.adjust = opd_adjust;
5979         }
5980       memset (opd_adjust, 0, amt);
5981
5982       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
5983         continue;
5984
5985       if (sec->output_section == bfd_abs_section_ptr)
5986         continue;
5987
5988       /* Look through the section relocs.  */
5989       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
5990         continue;
5991
5992       local_syms = NULL;
5993       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5994       sym_hashes = elf_sym_hashes (ibfd);
5995
5996       /* Read the relocations.  */
5997       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
5998                                             info->keep_memory);
5999       if (relstart == NULL)
6000         return FALSE;
6001
6002       /* First run through the relocs to check they are sane, and to
6003          determine whether we need to edit this opd section.  */
6004       need_edit = FALSE;
6005       need_pad = sec;
6006       offset = 0;
6007       relend = relstart + sec->reloc_count;
6008       for (rel = relstart; rel < relend; )
6009         {
6010           enum elf_ppc64_reloc_type r_type;
6011           unsigned long r_symndx;
6012           asection *sym_sec;
6013           struct elf_link_hash_entry *h;
6014           Elf_Internal_Sym *sym;
6015
6016           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6017              only interested in the reloc pointing to a function entry
6018              point.  */
6019           if (rel->r_offset != offset
6020               || rel + 1 >= relend
6021               || (rel + 1)->r_offset != offset + 8)
6022             {
6023               /* If someone messes with .opd alignment then after a
6024                  "ld -r" we might have padding in the middle of .opd.
6025                  Also, there's nothing to prevent someone putting
6026                  something silly in .opd with the assembler.  No .opd
6027                  optimization for them!  */
6028             broken_opd:
6029               (*_bfd_error_handler)
6030                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6031               need_edit = FALSE;
6032               break;
6033             }
6034
6035           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6036               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6037             {
6038               (*_bfd_error_handler)
6039                 (_("%B: unexpected reloc type %u in .opd section"),
6040                  ibfd, r_type);
6041               need_edit = FALSE;
6042               break;
6043             }
6044
6045           r_symndx = ELF64_R_SYM (rel->r_info);
6046           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6047                           r_symndx, ibfd))
6048             goto error_ret;
6049
6050           if (sym_sec == NULL || sym_sec->owner == NULL)
6051             {
6052               const char *sym_name;
6053               if (h != NULL)
6054                 sym_name = h->root.root.string;
6055               else
6056                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym);
6057
6058               (*_bfd_error_handler)
6059                 (_("%B: undefined sym `%s' in .opd section"),
6060                  ibfd, sym_name);
6061               need_edit = FALSE;
6062               break;
6063             }
6064
6065           /* opd entries are always for functions defined in the
6066              current input bfd.  If the symbol isn't defined in the
6067              input bfd, then we won't be using the function in this
6068              bfd;  It must be defined in a linkonce section in another
6069              bfd, or is weak.  It's also possible that we are
6070              discarding the function due to a linker script /DISCARD/,
6071              which we test for via the output_section.  */
6072           if (sym_sec->owner != ibfd
6073               || sym_sec->output_section == bfd_abs_section_ptr)
6074             need_edit = TRUE;
6075
6076           rel += 2;
6077           if (rel == relend
6078               || (rel + 1 == relend && rel->r_offset == offset + 16))
6079             {
6080               if (sec->size == offset + 24)
6081                 {
6082                   need_pad = NULL;
6083                   break;
6084                 }
6085               if (rel == relend && sec->size == offset + 16)
6086                 {
6087                   cnt_16b++;
6088                   break;
6089                 }
6090               goto broken_opd;
6091             }
6092
6093           if (rel->r_offset == offset + 24)
6094             offset += 24;
6095           else if (rel->r_offset != offset + 16)
6096             goto broken_opd;
6097           else if (rel + 1 < relend
6098                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6099                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6100             {
6101               offset += 16;
6102               cnt_16b++;
6103             }
6104           else if (rel + 2 < relend
6105                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6106                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6107             {
6108               offset += 24;
6109               rel += 1;
6110             }
6111           else
6112             goto broken_opd;
6113         }
6114
6115       add_aux_fields = non_overlapping && cnt_16b > 0;
6116
6117       if (need_edit || add_aux_fields)
6118         {
6119           Elf_Internal_Rela *write_rel;
6120           bfd_byte *rptr, *wptr;
6121           bfd_byte *new_contents = NULL;
6122           bfd_boolean skip;
6123           long opd_ent_size;
6124
6125           /* This seems a waste of time as input .opd sections are all
6126              zeros as generated by gcc, but I suppose there's no reason
6127              this will always be so.  We might start putting something in
6128              the third word of .opd entries.  */
6129           if ((sec->flags & SEC_IN_MEMORY) == 0)
6130             {
6131               bfd_byte *loc;
6132               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6133                 {
6134                   if (loc != NULL)
6135                     free (loc);
6136                 error_ret:
6137                   if (local_syms != NULL
6138                       && symtab_hdr->contents != (unsigned char *) local_syms)
6139                     free (local_syms);
6140                   if (elf_section_data (sec)->relocs != relstart)
6141                     free (relstart);
6142                   return FALSE;
6143                 }
6144               sec->contents = loc;
6145               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6146             }
6147
6148           elf_section_data (sec)->relocs = relstart;
6149
6150           wptr = sec->contents;
6151           rptr = sec->contents;
6152           new_contents = sec->contents;
6153
6154           if (add_aux_fields)
6155             {
6156               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6157               if (new_contents == NULL)
6158                 return FALSE;
6159               need_pad = FALSE;
6160               wptr = new_contents;
6161             }
6162
6163           write_rel = relstart;
6164           skip = FALSE;
6165           offset = 0;
6166           opd_ent_size = 0;
6167           for (rel = relstart; rel < relend; rel++)
6168             {
6169               unsigned long r_symndx;
6170               asection *sym_sec;
6171               struct elf_link_hash_entry *h;
6172               Elf_Internal_Sym *sym;
6173
6174               r_symndx = ELF64_R_SYM (rel->r_info);
6175               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6176                               r_symndx, ibfd))
6177                 goto error_ret;
6178
6179               if (rel->r_offset == offset)
6180                 {
6181                   struct ppc_link_hash_entry *fdh = NULL;
6182
6183                   /* See if the .opd entry is full 24 byte or
6184                      16 byte (with fd_aux entry overlapped with next
6185                      fd_func).  */
6186                   opd_ent_size = 24;
6187                   if ((rel + 2 == relend && sec->size == offset + 16)
6188                       || (rel + 3 < relend
6189                           && rel[2].r_offset == offset + 16
6190                           && rel[3].r_offset == offset + 24
6191                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6192                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6193                     opd_ent_size = 16;
6194
6195                   if (h != NULL
6196                       && h->root.root.string[0] == '.')
6197                     fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6198                                    ppc_hash_table (info));
6199
6200                   skip = (sym_sec->owner != ibfd
6201                           || sym_sec->output_section == bfd_abs_section_ptr);
6202                   if (skip)
6203                     {
6204                       if (fdh != NULL && sym_sec->owner == ibfd)
6205                         {
6206                           /* Arrange for the function descriptor sym
6207                              to be dropped.  */
6208                           fdh->elf.root.u.def.value = 0;
6209                           fdh->elf.root.u.def.section = sym_sec;
6210                         }
6211                       opd_adjust[rel->r_offset / 8] = -1;
6212                     }
6213                   else
6214                     {
6215                       /* We'll be keeping this opd entry.  */
6216
6217                       if (fdh != NULL)
6218                         {
6219                           /* Redefine the function descriptor symbol to
6220                              this location in the opd section.  It is
6221                              necessary to update the value here rather
6222                              than using an array of adjustments as we do
6223                              for local symbols, because various places
6224                              in the generic ELF code use the value
6225                              stored in u.def.value.  */
6226                           fdh->elf.root.u.def.value = wptr - new_contents;
6227                           fdh->adjust_done = 1;
6228                         }
6229
6230                       /* Local syms are a bit tricky.  We could
6231                          tweak them as they can be cached, but
6232                          we'd need to look through the local syms
6233                          for the function descriptor sym which we
6234                          don't have at the moment.  So keep an
6235                          array of adjustments.  */
6236                       opd_adjust[rel->r_offset / 8]
6237                         = (wptr - new_contents) - (rptr - sec->contents);
6238
6239                       if (wptr != rptr)
6240                         memcpy (wptr, rptr, opd_ent_size);
6241                       wptr += opd_ent_size;
6242                       if (add_aux_fields && opd_ent_size == 16)
6243                         {
6244                           memset (wptr, '\0', 8);
6245                           wptr += 8;
6246                         }
6247                     }
6248                   rptr += opd_ent_size;
6249                   offset += opd_ent_size;
6250                 }
6251
6252               if (skip)
6253                 {
6254                   BFD_ASSERT (MUST_BE_DYN_RELOC (ELF64_R_TYPE (rel->r_info)));
6255                   if (info->shared)
6256                     {
6257                       /* We won't be needing dynamic relocs here.  */
6258                       struct ppc_dyn_relocs **pp;
6259                       struct ppc_dyn_relocs *p;
6260
6261                       if (h != NULL)
6262                         pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6263                       else if (sym_sec != NULL)
6264                         pp = ((struct ppc_dyn_relocs **)
6265                               &elf_section_data (sym_sec)->local_dynrel);
6266                       else
6267                         pp = ((struct ppc_dyn_relocs **)
6268                               &elf_section_data (sec)->local_dynrel);
6269                       while ((p = *pp) != NULL)
6270                         {
6271                           if (p->sec == sec)
6272                             {
6273                               p->count -= 1;
6274                               if (p->count == 0)
6275                                 *pp = p->next;
6276                               break;
6277                             }
6278                           pp = &p->next;
6279                         }
6280                     }
6281                 }
6282               else
6283                 {
6284                   /* We need to adjust any reloc offsets to point to the
6285                      new opd entries.  While we're at it, we may as well
6286                      remove redundant relocs.  */
6287                   rel->r_offset += opd_adjust[(offset - opd_ent_size) / 8];
6288                   if (write_rel != rel)
6289                     memcpy (write_rel, rel, sizeof (*rel));
6290                   ++write_rel;
6291                 }
6292             }
6293
6294           sec->size = wptr - new_contents;
6295           sec->reloc_count = write_rel - relstart;
6296           if (add_aux_fields)
6297             {
6298               free (sec->contents);
6299               sec->contents = new_contents;
6300             }
6301
6302           /* Fudge the size too, as this is used later in
6303              elf_bfd_final_link if we are emitting relocs.  */
6304           elf_section_data (sec)->rel_hdr.sh_size
6305             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6306           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
6307           some_edited = TRUE;
6308         }
6309       else if (elf_section_data (sec)->relocs != relstart)
6310         free (relstart);
6311
6312       if (local_syms != NULL
6313           && symtab_hdr->contents != (unsigned char *) local_syms)
6314         {
6315           if (!info->keep_memory)
6316             free (local_syms);
6317           else
6318             symtab_hdr->contents = (unsigned char *) local_syms;
6319         }
6320     }
6321
6322   if (some_edited)
6323     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6324
6325   /* If we are doing a final link and the last .opd entry is just 16 byte
6326      long, add a 8 byte padding after it.  */
6327   if (need_pad != NULL && !info->relocatable)
6328     {
6329       bfd_byte *p;
6330
6331       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6332         {
6333           BFD_ASSERT (need_pad->size > 0);
6334
6335           p = bfd_malloc (need_pad->size + 8);
6336           if (p == NULL)
6337             return FALSE;
6338
6339           if (! bfd_get_section_contents (need_pad->owner, need_pad,
6340                                           p, 0, need_pad->size))
6341             return FALSE;
6342
6343           need_pad->contents = p;
6344           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6345         }
6346       else
6347         {
6348           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6349           if (p == NULL)
6350             return FALSE;
6351
6352           need_pad->contents = p;
6353         }
6354
6355       memset (need_pad->contents + need_pad->size, 0, 8);
6356       need_pad->size += 8;
6357     }
6358
6359   return TRUE;
6360 }
6361
6362 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
6363
6364 asection *
6365 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
6366 {
6367   struct ppc_link_hash_table *htab;
6368
6369   htab = ppc_hash_table (info);
6370   if (htab->tls_get_addr != NULL)
6371     {
6372       struct ppc_link_hash_entry *h = htab->tls_get_addr;
6373
6374       while (h->elf.root.type == bfd_link_hash_indirect
6375              || h->elf.root.type == bfd_link_hash_warning)
6376         h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6377
6378       htab->tls_get_addr = h;
6379
6380       if (htab->tls_get_addr_fd == NULL
6381           && h->oh != NULL
6382           && h->oh->is_func_descriptor)
6383         htab->tls_get_addr_fd = h->oh;
6384     }
6385
6386   if (htab->tls_get_addr_fd != NULL)
6387     {
6388       struct ppc_link_hash_entry *h = htab->tls_get_addr_fd;
6389
6390       while (h->elf.root.type == bfd_link_hash_indirect
6391              || h->elf.root.type == bfd_link_hash_warning)
6392         h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6393
6394       htab->tls_get_addr_fd = h;
6395     }
6396
6397   return _bfd_elf_tls_setup (obfd, info);
6398 }
6399
6400 /* Run through all the TLS relocs looking for optimization
6401    opportunities.  The linker has been hacked (see ppc64elf.em) to do
6402    a preliminary section layout so that we know the TLS segment
6403    offsets.  We can't optimize earlier because some optimizations need
6404    to know the tp offset, and we need to optimize before allocating
6405    dynamic relocations.  */
6406
6407 bfd_boolean
6408 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6409 {
6410   bfd *ibfd;
6411   asection *sec;
6412   struct ppc_link_hash_table *htab;
6413
6414   if (info->relocatable || info->shared)
6415     return TRUE;
6416
6417   htab = ppc_hash_table (info);
6418   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6419     {
6420       Elf_Internal_Sym *locsyms = NULL;
6421
6422       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6423         if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
6424           {
6425             Elf_Internal_Rela *relstart, *rel, *relend;
6426             int expecting_tls_get_addr;
6427
6428             /* Read the relocations.  */
6429             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6430                                                   info->keep_memory);
6431             if (relstart == NULL)
6432               return FALSE;
6433
6434             expecting_tls_get_addr = 0;
6435             relend = relstart + sec->reloc_count;
6436             for (rel = relstart; rel < relend; rel++)
6437               {
6438                 enum elf_ppc64_reloc_type r_type;
6439                 unsigned long r_symndx;
6440                 struct elf_link_hash_entry *h;
6441                 Elf_Internal_Sym *sym;
6442                 asection *sym_sec;
6443                 char *tls_mask;
6444                 char tls_set, tls_clear, tls_type = 0;
6445                 bfd_vma value;
6446                 bfd_boolean ok_tprel, is_local;
6447
6448                 r_symndx = ELF64_R_SYM (rel->r_info);
6449                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
6450                                 r_symndx, ibfd))
6451                   {
6452                   err_free_rel:
6453                     if (elf_section_data (sec)->relocs != relstart)
6454                       free (relstart);
6455                     if (locsyms != NULL
6456                         && (elf_tdata (ibfd)->symtab_hdr.contents
6457                             != (unsigned char *) locsyms))
6458                       free (locsyms);
6459                     return FALSE;
6460                   }
6461
6462                 if (h != NULL)
6463                   {
6464                     if (h->root.type != bfd_link_hash_defined
6465                         && h->root.type != bfd_link_hash_defweak)
6466                       continue;
6467                     value = h->root.u.def.value;
6468                   }
6469                 else
6470                   /* Symbols referenced by TLS relocs must be of type
6471                      STT_TLS.  So no need for .opd local sym adjust.  */
6472                   value = sym->st_value;
6473
6474                 ok_tprel = FALSE;
6475                 is_local = FALSE;
6476                 if (h == NULL
6477                     || !h->def_dynamic)
6478                   {
6479                     is_local = TRUE;
6480                     value += sym_sec->output_offset;
6481                     value += sym_sec->output_section->vma;
6482                     value -= htab->elf.tls_sec->vma;
6483                     ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
6484                                 < (bfd_vma) 1 << 32);
6485                   }
6486
6487                 r_type = ELF64_R_TYPE (rel->r_info);
6488                 switch (r_type)
6489                   {
6490                   case R_PPC64_GOT_TLSLD16:
6491                   case R_PPC64_GOT_TLSLD16_LO:
6492                   case R_PPC64_GOT_TLSLD16_HI:
6493                   case R_PPC64_GOT_TLSLD16_HA:
6494                     /* These relocs should never be against a symbol
6495                        defined in a shared lib.  Leave them alone if
6496                        that turns out to be the case.  */
6497                     ppc64_tlsld_got (ibfd)->refcount -= 1;
6498                     if (!is_local)
6499                       continue;
6500
6501                     /* LD -> LE */
6502                     tls_set = 0;
6503                     tls_clear = TLS_LD;
6504                     tls_type = TLS_TLS | TLS_LD;
6505                     expecting_tls_get_addr = 1;
6506                     break;
6507
6508                   case R_PPC64_GOT_TLSGD16:
6509                   case R_PPC64_GOT_TLSGD16_LO:
6510                   case R_PPC64_GOT_TLSGD16_HI:
6511                   case R_PPC64_GOT_TLSGD16_HA:
6512                     if (ok_tprel)
6513                       /* GD -> LE */
6514                       tls_set = 0;
6515                     else
6516                       /* GD -> IE */
6517                       tls_set = TLS_TLS | TLS_TPRELGD;
6518                     tls_clear = TLS_GD;
6519                     tls_type = TLS_TLS | TLS_GD;
6520                     expecting_tls_get_addr = 1;
6521                     break;
6522
6523                   case R_PPC64_GOT_TPREL16_DS:
6524                   case R_PPC64_GOT_TPREL16_LO_DS:
6525                   case R_PPC64_GOT_TPREL16_HI:
6526                   case R_PPC64_GOT_TPREL16_HA:
6527                     expecting_tls_get_addr = 0;
6528                     if (ok_tprel)
6529                       {
6530                         /* IE -> LE */
6531                         tls_set = 0;
6532                         tls_clear = TLS_TPREL;
6533                         tls_type = TLS_TLS | TLS_TPREL;
6534                         break;
6535                       }
6536                     else
6537                       continue;
6538
6539                   case R_PPC64_REL14:
6540                   case R_PPC64_REL14_BRTAKEN:
6541                   case R_PPC64_REL14_BRNTAKEN:
6542                   case R_PPC64_REL24:
6543                     if (h != NULL
6544                         && (h == &htab->tls_get_addr->elf
6545                             || h == &htab->tls_get_addr_fd->elf))
6546                       {
6547                         if (!expecting_tls_get_addr
6548                             && rel != relstart
6549                             && ((ELF64_R_TYPE (rel[-1].r_info)
6550                                  == R_PPC64_TOC16)
6551                                 || (ELF64_R_TYPE (rel[-1].r_info)
6552                                     == R_PPC64_TOC16_LO)))
6553                           {
6554                             /* Check for toc tls entries.  */
6555                             char *toc_tls;
6556                             int retval;
6557
6558                             retval = get_tls_mask (&toc_tls, NULL, &locsyms,
6559                                                    rel - 1, ibfd);
6560                             if (retval == 0)
6561                               goto err_free_rel;
6562                             if (toc_tls != NULL)
6563                               expecting_tls_get_addr = retval > 1;
6564                           }
6565
6566                         if (expecting_tls_get_addr)
6567                           {
6568                             struct plt_entry *ent;
6569                             for (ent = h->plt.plist; ent; ent = ent->next)
6570                               if (ent->addend == 0)
6571                                 {
6572                                   if (ent->plt.refcount > 0)
6573                                     ent->plt.refcount -= 1;
6574                                   break;
6575                                 }
6576                           }
6577                       }
6578                     expecting_tls_get_addr = 0;
6579                     continue;
6580
6581                   case R_PPC64_TPREL64:
6582                     expecting_tls_get_addr = 0;
6583                     if (ok_tprel)
6584                       {
6585                         /* IE -> LE */
6586                         tls_set = TLS_EXPLICIT;
6587                         tls_clear = TLS_TPREL;
6588                         break;
6589                       }
6590                     else
6591                       continue;
6592
6593                   case R_PPC64_DTPMOD64:
6594                     expecting_tls_get_addr = 0;
6595                     if (rel + 1 < relend
6596                         && (rel[1].r_info
6597                             == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
6598                         && rel[1].r_offset == rel->r_offset + 8)
6599                       {
6600                         if (ok_tprel)
6601                           /* GD -> LE */
6602                           tls_set = TLS_EXPLICIT | TLS_GD;
6603                         else
6604                           /* GD -> IE */
6605                           tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
6606                         tls_clear = TLS_GD;
6607                       }
6608                     else
6609                       {
6610                         if (!is_local)
6611                           continue;
6612
6613                         /* LD -> LE */
6614                         tls_set = TLS_EXPLICIT;
6615                         tls_clear = TLS_LD;
6616                       }
6617                     break;
6618
6619                   default:
6620                     expecting_tls_get_addr = 0;
6621                     continue;
6622                   }
6623
6624                 if ((tls_set & TLS_EXPLICIT) == 0)
6625                   {
6626                     struct got_entry *ent;
6627
6628                     /* Adjust got entry for this reloc.  */
6629                     if (h != NULL)
6630                       ent = h->got.glist;
6631                     else
6632                       ent = elf_local_got_ents (ibfd)[r_symndx];
6633
6634                     for (; ent != NULL; ent = ent->next)
6635                       if (ent->addend == rel->r_addend
6636                           && ent->owner == ibfd
6637                           && ent->tls_type == tls_type)
6638                         break;
6639                     if (ent == NULL)
6640                       abort ();
6641
6642                     if (tls_set == 0)
6643                       {
6644                         /* We managed to get rid of a got entry.  */
6645                         if (ent->got.refcount > 0)
6646                           ent->got.refcount -= 1;
6647                       }
6648                   }
6649                 else if (h != NULL)
6650                   {
6651                     struct ppc_link_hash_entry * eh;
6652                     struct ppc_dyn_relocs **pp;
6653                     struct ppc_dyn_relocs *p;
6654
6655                     /* Adjust dynamic relocs.  */
6656                     eh = (struct ppc_link_hash_entry *) h;
6657                     for (pp = &eh->dyn_relocs;
6658                          (p = *pp) != NULL;
6659                          pp = &p->next)
6660                       if (p->sec == sec)
6661                         {
6662                           /* If we got rid of a DTPMOD/DTPREL reloc
6663                              pair then we'll lose one or two dyn
6664                              relocs.  */
6665                           if (tls_set == (TLS_EXPLICIT | TLS_GD))
6666                             p->count -= 1;
6667                           p->count -= 1;
6668                           if (p->count == 0)
6669                             *pp = p->next;
6670                           break;
6671                         }
6672                   }
6673
6674                 *tls_mask |= tls_set;
6675                 *tls_mask &= ~tls_clear;
6676               }
6677
6678             if (elf_section_data (sec)->relocs != relstart)
6679               free (relstart);
6680           }
6681
6682       if (locsyms != NULL
6683           && (elf_tdata (ibfd)->symtab_hdr.contents
6684               != (unsigned char *) locsyms))
6685         {
6686           if (!info->keep_memory)
6687             free (locsyms);
6688           else
6689             elf_tdata (ibfd)->symtab_hdr.contents = (unsigned char *) locsyms;
6690         }
6691     }
6692   return TRUE;
6693 }
6694
6695 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
6696    the values of any global symbols in a toc section that has been
6697    edited.  Globals in toc sections should be a rarity, so this function
6698    sets a flag if any are found in toc sections other than the one just
6699    edited, so that futher hash table traversals can be avoided.  */
6700
6701 struct adjust_toc_info
6702 {
6703   asection *toc;
6704   unsigned long *skip;
6705   bfd_boolean global_toc_syms;
6706 };
6707
6708 static bfd_boolean
6709 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
6710 {
6711   struct ppc_link_hash_entry *eh;
6712   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
6713
6714   if (h->root.type == bfd_link_hash_indirect)
6715     return TRUE;
6716
6717   if (h->root.type == bfd_link_hash_warning)
6718     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6719
6720   if (h->root.type != bfd_link_hash_defined
6721       && h->root.type != bfd_link_hash_defweak)
6722     return TRUE;
6723
6724   eh = (struct ppc_link_hash_entry *) h;
6725   if (eh->adjust_done)
6726     return TRUE;
6727
6728   if (eh->elf.root.u.def.section == toc_inf->toc)
6729     {
6730       unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
6731       if (skip != (unsigned long) -1)
6732         eh->elf.root.u.def.value -= skip;
6733       else
6734         {
6735           (*_bfd_error_handler)
6736             (_("%s defined in removed toc entry"), eh->elf.root.root.string);
6737           eh->elf.root.u.def.section = &bfd_abs_section;
6738           eh->elf.root.u.def.value = 0;
6739         }
6740       eh->adjust_done = 1;
6741     }
6742   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
6743     toc_inf->global_toc_syms = TRUE;
6744
6745   return TRUE;
6746 }
6747
6748 /* Examine all relocs referencing .toc sections in order to remove
6749    unused .toc entries.  */
6750
6751 bfd_boolean
6752 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6753 {
6754   bfd *ibfd;
6755   struct adjust_toc_info toc_inf;
6756
6757   toc_inf.global_toc_syms = TRUE;
6758   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6759     {
6760       asection *toc, *sec;
6761       Elf_Internal_Shdr *symtab_hdr;
6762       Elf_Internal_Sym *local_syms;
6763       struct elf_link_hash_entry **sym_hashes;
6764       Elf_Internal_Rela *relstart, *rel, *wrel;
6765       unsigned long *skip, *drop;
6766       unsigned char *used;
6767       unsigned char *keep, last, some_unused;
6768
6769       toc = bfd_get_section_by_name (ibfd, ".toc");
6770       if (toc == NULL
6771           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
6772           || elf_discarded_section (toc))
6773         continue;
6774
6775       local_syms = NULL;
6776       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6777       sym_hashes = elf_sym_hashes (ibfd);
6778
6779       /* Look at sections dropped from the final link.  */
6780       skip = NULL;
6781       relstart = NULL;
6782       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6783         {
6784           if (sec->reloc_count == 0
6785               || !elf_discarded_section (sec)
6786               || get_opd_info (sec)
6787               || (sec->flags & SEC_ALLOC) == 0
6788               || (sec->flags & SEC_DEBUGGING) != 0)
6789             continue;
6790
6791           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
6792           if (relstart == NULL)
6793             goto error_ret;
6794
6795           /* Run through the relocs to see which toc entries might be
6796              unused.  */
6797           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
6798             {
6799               enum elf_ppc64_reloc_type r_type;
6800               unsigned long r_symndx;
6801               asection *sym_sec;
6802               struct elf_link_hash_entry *h;
6803               Elf_Internal_Sym *sym;
6804               bfd_vma val;
6805
6806               r_type = ELF64_R_TYPE (rel->r_info);
6807               switch (r_type)
6808                 {
6809                 default:
6810                   continue;
6811
6812                 case R_PPC64_TOC16:
6813                 case R_PPC64_TOC16_LO:
6814                 case R_PPC64_TOC16_HI:
6815                 case R_PPC64_TOC16_HA:
6816                 case R_PPC64_TOC16_DS:
6817                 case R_PPC64_TOC16_LO_DS:
6818                   break;
6819                 }
6820
6821               r_symndx = ELF64_R_SYM (rel->r_info);
6822               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6823                               r_symndx, ibfd))
6824                 goto error_ret;
6825
6826               if (sym_sec != toc)
6827                 continue;
6828
6829               if (h != NULL)
6830                 val = h->root.u.def.value;
6831               else
6832                 val = sym->st_value;
6833               val += rel->r_addend;
6834
6835               if (val >= toc->size)
6836                 continue;
6837
6838               /* Anything in the toc ought to be aligned to 8 bytes.
6839                  If not, don't mark as unused.  */
6840               if (val & 7)
6841                 continue;
6842
6843               if (skip == NULL)
6844                 {
6845                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
6846                   if (skip == NULL)
6847                     goto error_ret;
6848                 }
6849
6850               skip[val >> 3] = 1;
6851             }
6852
6853           if (elf_section_data (sec)->relocs != relstart)
6854             free (relstart);
6855         }
6856
6857       if (skip == NULL)
6858         continue;
6859
6860       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
6861       if (used == NULL)
6862         {
6863         error_ret:
6864           if (local_syms != NULL
6865               && symtab_hdr->contents != (unsigned char *) local_syms)
6866             free (local_syms);
6867           if (sec != NULL
6868               && relstart != NULL
6869               && elf_section_data (sec)->relocs != relstart)
6870             free (relstart);
6871           if (skip != NULL)
6872             free (skip);
6873           return FALSE;
6874         }
6875
6876       /* Now check all kept sections that might reference the toc.  */
6877       for (sec = ibfd->sections;
6878            sec != NULL;
6879            /* Check the toc itself last.  */
6880            sec = (sec == toc ? NULL
6881                   : sec->next == toc && sec->next->next ? sec->next->next
6882                   : sec->next == NULL ? toc
6883                   : sec->next))
6884         {
6885           int repeat;
6886
6887           if (sec->reloc_count == 0
6888               || elf_discarded_section (sec)
6889               || get_opd_info (sec)
6890               || (sec->flags & SEC_ALLOC) == 0
6891               || (sec->flags & SEC_DEBUGGING) != 0)
6892             continue;
6893
6894           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
6895           if (relstart == NULL)
6896             goto error_ret;
6897
6898           /* Mark toc entries referenced as used.  */
6899           repeat = 0;
6900           do
6901             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
6902               {
6903                 enum elf_ppc64_reloc_type r_type;
6904                 unsigned long r_symndx;
6905                 asection *sym_sec;
6906                 struct elf_link_hash_entry *h;
6907                 Elf_Internal_Sym *sym;
6908                 bfd_vma val;
6909
6910                 r_type = ELF64_R_TYPE (rel->r_info);
6911                 switch (r_type)
6912                   {
6913                   case R_PPC64_TOC16:
6914                   case R_PPC64_TOC16_LO:
6915                   case R_PPC64_TOC16_HI:
6916                   case R_PPC64_TOC16_HA:
6917                   case R_PPC64_TOC16_DS:
6918                   case R_PPC64_TOC16_LO_DS:
6919                     /* In case we're taking addresses of toc entries.  */
6920                   case R_PPC64_ADDR64:
6921                     break;
6922
6923                   default:
6924                     continue;
6925                   }
6926
6927                 r_symndx = ELF64_R_SYM (rel->r_info);
6928                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6929                                 r_symndx, ibfd))
6930                   {
6931                     free (used);
6932                     goto error_ret;
6933                   }
6934
6935                 if (sym_sec != toc)
6936                   continue;
6937
6938                 if (h != NULL)
6939                   val = h->root.u.def.value;
6940                 else
6941                   val = sym->st_value;
6942                 val += rel->r_addend;
6943
6944                 if (val >= toc->size)
6945                   continue;
6946
6947                 /* For the toc section, we only mark as used if
6948                    this entry itself isn't unused.  */
6949                 if (sec == toc
6950                     && !used[val >> 3]
6951                     && (used[rel->r_offset >> 3]
6952                         || !skip[rel->r_offset >> 3]))
6953                   /* Do all the relocs again, to catch reference
6954                      chains.  */
6955                   repeat = 1;
6956
6957                 used[val >> 3] = 1;
6958               }
6959           while (repeat);
6960         }
6961
6962       /* Merge the used and skip arrays.  Assume that TOC
6963          doublewords not appearing as either used or unused belong
6964          to to an entry more than one doubleword in size.  */
6965       for (drop = skip, keep = used, last = 0, some_unused = 0;
6966            drop < skip + (toc->size + 7) / 8;
6967            ++drop, ++keep)
6968         {
6969           if (*keep)
6970             {
6971               *drop = 0;
6972               last = 0;
6973             }
6974           else if (*drop)
6975             {
6976               some_unused = 1;
6977               last = 1;
6978             }
6979           else
6980             *drop = last;
6981         }
6982
6983       free (used);
6984
6985       if (some_unused)
6986         {
6987           bfd_byte *contents, *src;
6988           unsigned long off;
6989
6990           /* Shuffle the toc contents, and at the same time convert the
6991              skip array from booleans into offsets.  */
6992           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
6993             goto error_ret;
6994
6995           elf_section_data (toc)->this_hdr.contents = contents;
6996
6997           for (src = contents, off = 0, drop = skip;
6998                src < contents + toc->size;
6999                src += 8, ++drop)
7000             {
7001               if (*drop)
7002                 {
7003                   *drop = (unsigned long) -1;
7004                   off += 8;
7005                 }
7006               else if (off != 0)
7007                 {
7008                   *drop = off;
7009                   memcpy (src - off, src, 8);
7010                 }
7011             }
7012           toc->rawsize = toc->size;
7013           toc->size = src - contents - off;
7014
7015           /* Read toc relocs.  */
7016           relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL, TRUE);
7017           if (relstart == NULL)
7018             goto error_ret;
7019
7020           /* Remove unused toc relocs, and adjust those we keep.  */
7021           wrel = relstart;
7022           for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7023             if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7024               {
7025                 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7026                 wrel->r_info = rel->r_info;
7027                 wrel->r_addend = rel->r_addend;
7028                 ++wrel;
7029               }
7030           toc->reloc_count = wrel - relstart;
7031           elf_section_data (toc)->rel_hdr.sh_size
7032             = toc->reloc_count * elf_section_data (toc)->rel_hdr.sh_entsize;
7033           BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7034
7035           /* Adjust addends for relocs against the toc section sym.  */
7036           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7037             {
7038               if (sec->reloc_count == 0
7039                   || elf_discarded_section (sec))
7040                 continue;
7041
7042               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7043                                                     TRUE);
7044               if (relstart == NULL)
7045                 goto error_ret;
7046
7047               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7048                 {
7049                   enum elf_ppc64_reloc_type r_type;
7050                   unsigned long r_symndx;
7051                   asection *sym_sec;
7052                   struct elf_link_hash_entry *h;
7053                   Elf_Internal_Sym *sym;
7054
7055                   r_type = ELF64_R_TYPE (rel->r_info);
7056                   switch (r_type)
7057                     {
7058                     default:
7059                       continue;
7060
7061                     case R_PPC64_TOC16:
7062                     case R_PPC64_TOC16_LO:
7063                     case R_PPC64_TOC16_HI:
7064                     case R_PPC64_TOC16_HA:
7065                     case R_PPC64_TOC16_DS:
7066                     case R_PPC64_TOC16_LO_DS:
7067                     case R_PPC64_ADDR64:
7068                       break;
7069                     }
7070
7071                   r_symndx = ELF64_R_SYM (rel->r_info);
7072                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7073                                   r_symndx, ibfd))
7074                     goto error_ret;
7075
7076                   if (sym_sec != toc || h != NULL || sym->st_value != 0)
7077                     continue;
7078
7079                   rel->r_addend -= skip[rel->r_addend >> 3];
7080                 }
7081             }
7082
7083           /* We shouldn't have local or global symbols defined in the TOC,
7084              but handle them anyway.  */
7085           if (local_syms != NULL)
7086             {
7087               Elf_Internal_Sym *sym;
7088
7089               for (sym = local_syms;
7090                    sym < local_syms + symtab_hdr->sh_info;
7091                    ++sym)
7092                 if (sym->st_shndx != SHN_UNDEF
7093                     && (sym->st_shndx < SHN_LORESERVE
7094                         || sym->st_shndx > SHN_HIRESERVE)
7095                     && sym->st_value != 0
7096                     && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7097                   {
7098                     if (skip[sym->st_value >> 3] != (unsigned long) -1)
7099                       sym->st_value -= skip[sym->st_value >> 3];
7100                     else
7101                       {
7102                         (*_bfd_error_handler)
7103                           (_("%s defined in removed toc entry"),
7104                            bfd_elf_sym_name (ibfd, symtab_hdr, sym));
7105                         sym->st_value = 0;
7106                         sym->st_shndx = SHN_ABS;
7107                       }
7108                     symtab_hdr->contents = (unsigned char *) local_syms;
7109                   }
7110             }
7111
7112           /* Finally, adjust any global syms defined in the toc.  */
7113           if (toc_inf.global_toc_syms)
7114             {
7115               toc_inf.toc = toc;
7116               toc_inf.skip = skip;
7117               toc_inf.global_toc_syms = FALSE;
7118               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7119                                       &toc_inf);
7120             }
7121         }
7122
7123       if (local_syms != NULL
7124           && symtab_hdr->contents != (unsigned char *) local_syms)
7125         {
7126           if (!info->keep_memory)
7127             free (local_syms);
7128           else
7129             symtab_hdr->contents = (unsigned char *) local_syms;
7130         }
7131       free (skip);
7132     }
7133
7134   return TRUE;
7135 }
7136
7137 /* Allocate space in .plt, .got and associated reloc sections for
7138    dynamic relocs.  */
7139
7140 static bfd_boolean
7141 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7142 {
7143   struct bfd_link_info *info;
7144   struct ppc_link_hash_table *htab;
7145   asection *s;
7146   struct ppc_link_hash_entry *eh;
7147   struct ppc_dyn_relocs *p;
7148   struct got_entry *gent;
7149
7150   if (h->root.type == bfd_link_hash_indirect)
7151     return TRUE;
7152
7153   if (h->root.type == bfd_link_hash_warning)
7154     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7155
7156   info = (struct bfd_link_info *) inf;
7157   htab = ppc_hash_table (info);
7158
7159   if (htab->elf.dynamic_sections_created
7160       && h->dynindx != -1
7161       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7162     {
7163       struct plt_entry *pent;
7164       bfd_boolean doneone = FALSE;
7165       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7166         if (pent->plt.refcount > 0)
7167           {
7168             /* If this is the first .plt entry, make room for the special
7169                first entry.  */
7170             s = htab->plt;
7171             if (s->size == 0)
7172               s->size += PLT_INITIAL_ENTRY_SIZE;
7173
7174             pent->plt.offset = s->size;
7175
7176             /* Make room for this entry.  */
7177             s->size += PLT_ENTRY_SIZE;
7178
7179             /* Make room for the .glink code.  */
7180             s = htab->glink;
7181             if (s->size == 0)
7182               s->size += GLINK_CALL_STUB_SIZE;
7183             /* We need bigger stubs past index 32767.  */
7184             if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
7185               s->size += 4;
7186             s->size += 2*4;
7187
7188             /* We also need to make an entry in the .rela.plt section.  */
7189             s = htab->relplt;
7190             s->size += sizeof (Elf64_External_Rela);
7191             doneone = TRUE;
7192           }
7193         else
7194           pent->plt.offset = (bfd_vma) -1;
7195       if (!doneone)
7196         {
7197           h->plt.plist = NULL;
7198           h->needs_plt = 0;
7199         }
7200     }
7201   else
7202     {
7203       h->plt.plist = NULL;
7204       h->needs_plt = 0;
7205     }
7206
7207   eh = (struct ppc_link_hash_entry *) h;
7208   /* Run through the TLS GD got entries first if we're changing them
7209      to TPREL.  */
7210   if ((eh->tls_mask & TLS_TPRELGD) != 0)
7211     for (gent = h->got.glist; gent != NULL; gent = gent->next)
7212       if (gent->got.refcount > 0
7213           && (gent->tls_type & TLS_GD) != 0)
7214         {
7215           /* This was a GD entry that has been converted to TPREL.  If
7216              there happens to be a TPREL entry we can use that one.  */
7217           struct got_entry *ent;
7218           for (ent = h->got.glist; ent != NULL; ent = ent->next)
7219             if (ent->got.refcount > 0
7220                 && (ent->tls_type & TLS_TPREL) != 0
7221                 && ent->addend == gent->addend
7222                 && ent->owner == gent->owner)
7223               {
7224                 gent->got.refcount = 0;
7225                 break;
7226               }
7227
7228           /* If not, then we'll be using our own TPREL entry.  */
7229           if (gent->got.refcount != 0)
7230             gent->tls_type = TLS_TLS | TLS_TPREL;
7231         }
7232
7233   for (gent = h->got.glist; gent != NULL; gent = gent->next)
7234     if (gent->got.refcount > 0)
7235       {
7236         bfd_boolean dyn;
7237
7238         /* Make sure this symbol is output as a dynamic symbol.
7239            Undefined weak syms won't yet be marked as dynamic,
7240            nor will all TLS symbols.  */
7241         if (h->dynindx == -1
7242             && !h->forced_local)
7243           {
7244             if (! bfd_elf_link_record_dynamic_symbol (info, h))
7245               return FALSE;
7246           }
7247
7248         if ((gent->tls_type & TLS_LD) != 0
7249             && !h->def_dynamic)
7250           {
7251             gent->got.offset = ppc64_tlsld_got (gent->owner)->offset;
7252             continue;
7253           }
7254
7255         s = ppc64_elf_tdata (gent->owner)->got;
7256         gent->got.offset = s->size;
7257         s->size
7258           += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
7259         dyn = htab->elf.dynamic_sections_created;
7260         if ((info->shared
7261              || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
7262             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7263                 || h->root.type != bfd_link_hash_undefweak))
7264           ppc64_elf_tdata (gent->owner)->relgot->size
7265             += (gent->tls_type & eh->tls_mask & TLS_GD
7266                 ? 2 * sizeof (Elf64_External_Rela)
7267                 : sizeof (Elf64_External_Rela));
7268       }
7269     else
7270       gent->got.offset = (bfd_vma) -1;
7271
7272   if (eh->dyn_relocs == NULL)
7273     return TRUE;
7274
7275   /* In the shared -Bsymbolic case, discard space allocated for
7276      dynamic pc-relative relocs against symbols which turn out to be
7277      defined in regular objects.  For the normal shared case, discard
7278      space for relocs that have become local due to symbol visibility
7279      changes.  */
7280
7281   if (info->shared)
7282     {
7283       /* Relocs that use pc_count are those that appear on a call insn,
7284          or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
7285          generated via assembly.  We want calls to protected symbols to
7286          resolve directly to the function rather than going via the plt.
7287          If people want function pointer comparisons to work as expected
7288          then they should avoid writing weird assembly.  */
7289       if (SYMBOL_CALLS_LOCAL (info, h))
7290         {
7291           struct ppc_dyn_relocs **pp;
7292
7293           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
7294             {
7295               p->count -= p->pc_count;
7296               p->pc_count = 0;
7297               if (p->count == 0)
7298                 *pp = p->next;
7299               else
7300                 pp = &p->next;
7301             }
7302         }
7303
7304       /* Also discard relocs on undefined weak syms with non-default
7305          visibility.  */
7306       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7307           && h->root.type == bfd_link_hash_undefweak)
7308         eh->dyn_relocs = NULL;
7309     }
7310   else if (ELIMINATE_COPY_RELOCS)
7311     {
7312       /* For the non-shared case, discard space for relocs against
7313          symbols which turn out to need copy relocs or are not
7314          dynamic.  */
7315
7316       if (!h->non_got_ref
7317           && h->def_dynamic
7318           && !h->def_regular)
7319         {
7320           /* Make sure this symbol is output as a dynamic symbol.
7321              Undefined weak syms won't yet be marked as dynamic.  */
7322           if (h->dynindx == -1
7323               && !h->forced_local)
7324             {
7325               if (! bfd_elf_link_record_dynamic_symbol (info, h))
7326                 return FALSE;
7327             }
7328
7329           /* If that succeeded, we know we'll be keeping all the
7330              relocs.  */
7331           if (h->dynindx != -1)
7332             goto keep;
7333         }
7334
7335       eh->dyn_relocs = NULL;
7336
7337     keep: ;
7338     }
7339
7340   /* Finally, allocate space.  */
7341   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7342     {
7343       asection *sreloc = elf_section_data (p->sec)->sreloc;
7344       sreloc->size += p->count * sizeof (Elf64_External_Rela);
7345     }
7346
7347   return TRUE;
7348 }
7349
7350 /* Find any dynamic relocs that apply to read-only sections.  */
7351
7352 static bfd_boolean
7353 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7354 {
7355   struct ppc_link_hash_entry *eh;
7356   struct ppc_dyn_relocs *p;
7357
7358   if (h->root.type == bfd_link_hash_warning)
7359     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7360
7361   eh = (struct ppc_link_hash_entry *) h;
7362   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7363     {
7364       asection *s = p->sec->output_section;
7365
7366       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7367         {
7368           struct bfd_link_info *info = inf;
7369
7370           info->flags |= DF_TEXTREL;
7371
7372           /* Not an error, just cut short the traversal.  */
7373           return FALSE;
7374         }
7375     }
7376   return TRUE;
7377 }
7378
7379 /* Set the sizes of the dynamic sections.  */
7380
7381 static bfd_boolean
7382 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
7383                                  struct bfd_link_info *info)
7384 {
7385   struct ppc_link_hash_table *htab;
7386   bfd *dynobj;
7387   asection *s;
7388   bfd_boolean relocs;
7389   bfd *ibfd;
7390
7391   htab = ppc_hash_table (info);
7392   dynobj = htab->elf.dynobj;
7393   if (dynobj == NULL)
7394     abort ();
7395
7396   if (htab->elf.dynamic_sections_created)
7397     {
7398       /* Set the contents of the .interp section to the interpreter.  */
7399       if (info->executable)
7400         {
7401           s = bfd_get_section_by_name (dynobj, ".interp");
7402           if (s == NULL)
7403             abort ();
7404           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
7405           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
7406         }
7407     }
7408
7409   /* Set up .got offsets for local syms, and space for local dynamic
7410      relocs.  */
7411   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7412     {
7413       struct got_entry **lgot_ents;
7414       struct got_entry **end_lgot_ents;
7415       char *lgot_masks;
7416       bfd_size_type locsymcount;
7417       Elf_Internal_Shdr *symtab_hdr;
7418       asection *srel;
7419
7420       if (!is_ppc64_elf_target (ibfd->xvec))
7421         continue;
7422
7423       if (ppc64_tlsld_got (ibfd)->refcount > 0)
7424         {
7425           s = ppc64_elf_tdata (ibfd)->got;
7426           ppc64_tlsld_got (ibfd)->offset = s->size;
7427           s->size += 16;
7428           if (info->shared)
7429             {
7430               srel = ppc64_elf_tdata (ibfd)->relgot;
7431               srel->size += sizeof (Elf64_External_Rela);
7432             }
7433         }
7434       else
7435         ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
7436
7437       for (s = ibfd->sections; s != NULL; s = s->next)
7438         {
7439           struct ppc_dyn_relocs *p;
7440
7441           for (p = *((struct ppc_dyn_relocs **)
7442                      &elf_section_data (s)->local_dynrel);
7443                p != NULL;
7444                p = p->next)
7445             {
7446               if (!bfd_is_abs_section (p->sec)
7447                   && bfd_is_abs_section (p->sec->output_section))
7448                 {
7449                   /* Input section has been discarded, either because
7450                      it is a copy of a linkonce section or due to
7451                      linker script /DISCARD/, so we'll be discarding
7452                      the relocs too.  */
7453                 }
7454               else if (p->count != 0)
7455                 {
7456                   srel = elf_section_data (p->sec)->sreloc;
7457                   srel->size += p->count * sizeof (Elf64_External_Rela);
7458                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
7459                     info->flags |= DF_TEXTREL;
7460                 }
7461             }
7462         }
7463
7464       lgot_ents = elf_local_got_ents (ibfd);
7465       if (!lgot_ents)
7466         continue;
7467
7468       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7469       locsymcount = symtab_hdr->sh_info;
7470       end_lgot_ents = lgot_ents + locsymcount;
7471       lgot_masks = (char *) end_lgot_ents;
7472       s = ppc64_elf_tdata (ibfd)->got;
7473       srel = ppc64_elf_tdata (ibfd)->relgot;
7474       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
7475         {
7476           struct got_entry *ent;
7477
7478           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
7479             if (ent->got.refcount > 0)
7480               {
7481                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
7482                   {
7483                     if (ppc64_tlsld_got (ibfd)->offset == (bfd_vma) -1)
7484                       {
7485                         ppc64_tlsld_got (ibfd)->offset = s->size;
7486                         s->size += 16;
7487                         if (info->shared)
7488                           srel->size += sizeof (Elf64_External_Rela);
7489                       }
7490                     ent->got.offset = ppc64_tlsld_got (ibfd)->offset;
7491                   }
7492                 else
7493                   {
7494                     ent->got.offset = s->size;
7495                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
7496                       {
7497                         s->size += 16;
7498                         if (info->shared)
7499                           srel->size += 2 * sizeof (Elf64_External_Rela);
7500                       }
7501                     else
7502                       {
7503                         s->size += 8;
7504                         if (info->shared)
7505                           srel->size += sizeof (Elf64_External_Rela);
7506                       }
7507                   }
7508               }
7509             else
7510               ent->got.offset = (bfd_vma) -1;
7511         }
7512     }
7513
7514   /* Allocate global sym .plt and .got entries, and space for global
7515      sym dynamic relocs.  */
7516   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
7517
7518   /* We now have determined the sizes of the various dynamic sections.
7519      Allocate memory for them.  */
7520   relocs = FALSE;
7521   for (s = dynobj->sections; s != NULL; s = s->next)
7522     {
7523       if ((s->flags & SEC_LINKER_CREATED) == 0)
7524         continue;
7525
7526       if (s == htab->brlt || s == htab->relbrlt)
7527         /* These haven't been allocated yet;  don't strip.  */
7528         continue;
7529       else if (s == htab->got
7530                || s == htab->plt
7531                || s == htab->glink)
7532         {
7533           /* Strip this section if we don't need it; see the
7534              comment below.  */
7535         }
7536       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
7537         {
7538           if (s->size == 0)
7539             {
7540               /* If we don't need this section, strip it from the
7541                  output file.  This is mostly to handle .rela.bss and
7542                  .rela.plt.  We must create both sections in
7543                  create_dynamic_sections, because they must be created
7544                  before the linker maps input sections to output
7545                  sections.  The linker does that before
7546                  adjust_dynamic_symbol is called, and it is that
7547                  function which decides whether anything needs to go
7548                  into these sections.  */
7549             }
7550           else
7551             {
7552               if (s != htab->relplt)
7553                 relocs = TRUE;
7554
7555               /* We use the reloc_count field as a counter if we need
7556                  to copy relocs into the output file.  */
7557               s->reloc_count = 0;
7558             }
7559         }
7560       else
7561         {
7562           /* It's not one of our sections, so don't allocate space.  */
7563           continue;
7564         }
7565
7566       if (s->size == 0)
7567         {
7568           _bfd_strip_section_from_output (info, s);
7569           continue;
7570         }
7571
7572       /* .plt is in the bss section.  We don't initialise it.  */
7573       if (s == htab->plt)
7574         continue;
7575
7576       /* Allocate memory for the section contents.  We use bfd_zalloc
7577          here in case unused entries are not reclaimed before the
7578          section's contents are written out.  This should not happen,
7579          but this way if it does we get a R_PPC64_NONE reloc in .rela
7580          sections instead of garbage.
7581          We also rely on the section contents being zero when writing
7582          the GOT.  */
7583       s->contents = bfd_zalloc (dynobj, s->size);
7584       if (s->contents == NULL)
7585         return FALSE;
7586     }
7587
7588   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7589     {
7590       if (!is_ppc64_elf_target (ibfd->xvec))
7591         continue;
7592
7593       s = ppc64_elf_tdata (ibfd)->got;
7594       if (s != NULL && s != htab->got)
7595         {
7596           if (s->size == 0)
7597             _bfd_strip_section_from_output (info, s);
7598           else
7599             {
7600               s->contents = bfd_zalloc (ibfd, s->size);
7601               if (s->contents == NULL)
7602                 return FALSE;
7603             }
7604         }
7605       s = ppc64_elf_tdata (ibfd)->relgot;
7606       if (s != NULL)
7607         {
7608           if (s->size == 0)
7609             _bfd_strip_section_from_output (info, s);
7610           else
7611             {
7612               s->contents = bfd_zalloc (ibfd, s->size);
7613               if (s->contents == NULL)
7614                 return FALSE;
7615               relocs = TRUE;
7616               s->reloc_count = 0;
7617             }
7618         }
7619     }
7620
7621   if (htab->elf.dynamic_sections_created)
7622     {
7623       /* Add some entries to the .dynamic section.  We fill in the
7624          values later, in ppc64_elf_finish_dynamic_sections, but we
7625          must add the entries now so that we get the correct size for
7626          the .dynamic section.  The DT_DEBUG entry is filled in by the
7627          dynamic linker and used by the debugger.  */
7628 #define add_dynamic_entry(TAG, VAL) \
7629   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
7630
7631       if (info->executable)
7632         {
7633           if (!add_dynamic_entry (DT_DEBUG, 0))
7634             return FALSE;
7635         }
7636
7637       if (htab->plt != NULL && htab->plt->size != 0)
7638         {
7639           if (!add_dynamic_entry (DT_PLTGOT, 0)
7640               || !add_dynamic_entry (DT_PLTRELSZ, 0)
7641               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
7642               || !add_dynamic_entry (DT_JMPREL, 0)
7643               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
7644             return FALSE;
7645         }
7646
7647       if (NO_OPD_RELOCS)
7648         {
7649           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
7650               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
7651             return FALSE;
7652         }
7653
7654       if (relocs)
7655         {
7656           if (!add_dynamic_entry (DT_RELA, 0)
7657               || !add_dynamic_entry (DT_RELASZ, 0)
7658               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
7659             return FALSE;
7660
7661           /* If any dynamic relocs apply to a read-only section,
7662              then we need a DT_TEXTREL entry.  */
7663           if ((info->flags & DF_TEXTREL) == 0)
7664             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
7665
7666           if ((info->flags & DF_TEXTREL) != 0)
7667             {
7668               if (!add_dynamic_entry (DT_TEXTREL, 0))
7669                 return FALSE;
7670             }
7671         }
7672     }
7673 #undef add_dynamic_entry
7674
7675   return TRUE;
7676 }
7677
7678 /* Determine the type of stub needed, if any, for a call.  */
7679
7680 static inline enum ppc_stub_type
7681 ppc_type_of_stub (asection *input_sec,
7682                   const Elf_Internal_Rela *rel,
7683                   struct ppc_link_hash_entry **hash,
7684                   bfd_vma destination)
7685 {
7686   struct ppc_link_hash_entry *h = *hash;
7687   bfd_vma location;
7688   bfd_vma branch_offset;
7689   bfd_vma max_branch_offset;
7690   enum elf_ppc64_reloc_type r_type;
7691
7692   if (h != NULL)
7693     {
7694       if (h->oh != NULL
7695           && h->oh->is_func_descriptor)
7696         h = h->oh;
7697
7698       if (h->elf.dynindx != -1)
7699         {
7700           struct plt_entry *ent;
7701
7702           for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
7703             if (ent->addend == rel->r_addend
7704                 && ent->plt.offset != (bfd_vma) -1)
7705               {
7706                 *hash = h;
7707                 return ppc_stub_plt_call;
7708               }
7709         }
7710
7711       if (!(h->elf.root.type == bfd_link_hash_defined
7712             || h->elf.root.type == bfd_link_hash_defweak)
7713           || h->elf.root.u.def.section->output_section == NULL)
7714         return ppc_stub_none;
7715     }
7716
7717   /* Determine where the call point is.  */
7718   location = (input_sec->output_offset
7719               + input_sec->output_section->vma
7720               + rel->r_offset);
7721
7722   branch_offset = destination - location;
7723   r_type = ELF64_R_TYPE (rel->r_info);
7724
7725   /* Determine if a long branch stub is needed.  */
7726   max_branch_offset = 1 << 25;
7727   if (r_type != R_PPC64_REL24)
7728     max_branch_offset = 1 << 15;
7729
7730   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
7731     /* We need a stub.  Figure out whether a long_branch or plt_branch
7732        is needed later.  */
7733     return ppc_stub_long_branch;
7734
7735   return ppc_stub_none;
7736 }
7737
7738 /* Build a .plt call stub.  */
7739
7740 static inline bfd_byte *
7741 build_plt_stub (bfd *obfd, bfd_byte *p, int offset)
7742 {
7743 #define PPC_LO(v) ((v) & 0xffff)
7744 #define PPC_HI(v) (((v) >> 16) & 0xffff)
7745 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
7746
7747   bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
7748   bfd_put_32 (obfd, STD_R2_40R1, p),                    p += 4;
7749   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
7750   if (PPC_HA (offset + 8) != PPC_HA (offset))
7751     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
7752   offset += 8;
7753   bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p),   p += 4;
7754   if (PPC_HA (offset + 8) != PPC_HA (offset))
7755     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
7756   offset += 8;
7757   bfd_put_32 (obfd, MTCTR_R11, p),                      p += 4;
7758   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
7759   bfd_put_32 (obfd, BCTR, p),                           p += 4;
7760   return p;
7761 }
7762
7763 static bfd_boolean
7764 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
7765 {
7766   struct ppc_stub_hash_entry *stub_entry;
7767   struct ppc_branch_hash_entry *br_entry;
7768   struct bfd_link_info *info;
7769   struct ppc_link_hash_table *htab;
7770   bfd_byte *loc;
7771   bfd_byte *p;
7772   unsigned int indx;
7773   struct plt_entry *ent;
7774   bfd_vma dest, off;
7775   int size;
7776
7777   /* Massage our args to the form they really have.  */
7778   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
7779   info = in_arg;
7780
7781   htab = ppc_hash_table (info);
7782
7783   /* Make a note of the offset within the stubs for this entry.  */
7784   stub_entry->stub_offset = stub_entry->stub_sec->size;
7785   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
7786
7787   htab->stub_count[stub_entry->stub_type - 1] += 1;
7788   switch (stub_entry->stub_type)
7789     {
7790     case ppc_stub_long_branch:
7791     case ppc_stub_long_branch_r2off:
7792       /* Branches are relative.  This is where we are going to.  */
7793       off = dest = (stub_entry->target_value
7794                     + stub_entry->target_section->output_offset
7795                     + stub_entry->target_section->output_section->vma);
7796
7797       /* And this is where we are coming from.  */
7798       off -= (stub_entry->stub_offset
7799               + stub_entry->stub_sec->output_offset
7800               + stub_entry->stub_sec->output_section->vma);
7801
7802       if (stub_entry->stub_type != ppc_stub_long_branch_r2off)
7803         size = 4;
7804       else
7805         {
7806           bfd_vma r2off;
7807
7808           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
7809                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
7810           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
7811           loc += 4;
7812           bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
7813           loc += 4;
7814           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
7815           loc += 4;
7816           off -= 12;
7817           size = 16;
7818         }
7819       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
7820
7821       BFD_ASSERT (off + (1 << 25) < (bfd_vma) (1 << 26));
7822
7823       if (info->emitrelocations)
7824         {
7825           Elf_Internal_Rela *relocs, *r;
7826           struct bfd_elf_section_data *elfsec_data;
7827
7828           elfsec_data = elf_section_data (stub_entry->stub_sec);
7829           relocs = elfsec_data->relocs;
7830           if (relocs == NULL)
7831             {
7832               bfd_size_type relsize;
7833               relsize = stub_entry->stub_sec->reloc_count * sizeof (*relocs);
7834               relocs = bfd_alloc (htab->stub_bfd, relsize);
7835               if (relocs == NULL)
7836                 return FALSE;
7837               elfsec_data->relocs = relocs;
7838               elfsec_data->rel_hdr.sh_size = relsize;
7839               elfsec_data->rel_hdr.sh_entsize = 24;
7840               stub_entry->stub_sec->reloc_count = 0;
7841             }
7842           r = relocs + stub_entry->stub_sec->reloc_count;
7843           stub_entry->stub_sec->reloc_count += 1;
7844           r->r_offset = loc - stub_entry->stub_sec->contents;
7845           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
7846           r->r_addend = dest;
7847           if (stub_entry->h != NULL)
7848             {
7849               struct elf_link_hash_entry **hashes;
7850               unsigned long symndx;
7851               struct ppc_link_hash_entry *h;
7852
7853               hashes = elf_sym_hashes (htab->stub_bfd);
7854               if (hashes == NULL)
7855                 {
7856                   bfd_size_type hsize;
7857
7858                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
7859                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
7860                   if (hashes == NULL)
7861                     return FALSE;
7862                   elf_sym_hashes (htab->stub_bfd) = hashes;
7863                   htab->stub_globals = 1;
7864                 }
7865               symndx = htab->stub_globals++;
7866               h = stub_entry->h;
7867               hashes[symndx] = &h->elf;
7868               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
7869               if (h->oh != NULL && h->oh->is_func)
7870                 h = h->oh;
7871               if (h->elf.root.u.def.section != stub_entry->target_section)
7872                 /* H is an opd symbol.  The addend must be zero.  */
7873                 r->r_addend = 0;
7874               else
7875                 {
7876                   off = (h->elf.root.u.def.value
7877                          + h->elf.root.u.def.section->output_offset
7878                          + h->elf.root.u.def.section->output_section->vma);
7879                   r->r_addend -= off;
7880                 }
7881             }
7882         }
7883       break;
7884
7885     case ppc_stub_plt_branch:
7886     case ppc_stub_plt_branch_r2off:
7887       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
7888                                          stub_entry->root.string + 9,
7889                                          FALSE, FALSE);
7890       if (br_entry == NULL)
7891         {
7892           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
7893                                  stub_entry->root.string + 9);
7894           htab->stub_error = TRUE;
7895           return FALSE;
7896         }
7897
7898       off = (stub_entry->target_value
7899              + stub_entry->target_section->output_offset
7900              + stub_entry->target_section->output_section->vma);
7901
7902       bfd_put_64 (htab->brlt->owner, off,
7903                   htab->brlt->contents + br_entry->offset);
7904
7905       if (htab->relbrlt != NULL)
7906         {
7907           /* Create a reloc for the branch lookup table entry.  */
7908           Elf_Internal_Rela rela;
7909           bfd_byte *rl;
7910
7911           rela.r_offset = (br_entry->offset
7912                            + htab->brlt->output_offset
7913                            + htab->brlt->output_section->vma);
7914           rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
7915           rela.r_addend = off;
7916
7917           rl = htab->relbrlt->contents;
7918           rl += htab->relbrlt->reloc_count++ * sizeof (Elf64_External_Rela);
7919           bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
7920         }
7921
7922       off = (br_entry->offset
7923              + htab->brlt->output_offset
7924              + htab->brlt->output_section->vma
7925              - elf_gp (htab->brlt->output_section->owner)
7926              - htab->stub_group[stub_entry->id_sec->id].toc_off);
7927
7928       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
7929         {
7930           (*_bfd_error_handler)
7931             (_("linkage table error against `%s'"),
7932              stub_entry->root.string);
7933           bfd_set_error (bfd_error_bad_value);
7934           htab->stub_error = TRUE;
7935           return FALSE;
7936         }
7937
7938       indx = off;
7939       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
7940         {
7941           bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
7942           loc += 4;
7943           bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
7944           size = 16;
7945         }
7946       else
7947         {
7948           bfd_vma r2off;
7949
7950           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
7951                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
7952           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
7953           loc += 4;
7954           bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
7955           loc += 4;
7956           bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
7957           loc += 4;
7958           bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
7959           loc += 4;
7960           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
7961           size = 28;
7962         }
7963       loc += 4;
7964       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
7965       loc += 4;
7966       bfd_put_32 (htab->stub_bfd, BCTR, loc);
7967       break;
7968
7969     case ppc_stub_plt_call:
7970       /* Do the best we can for shared libraries built without
7971          exporting ".foo" for each "foo".  This can happen when symbol
7972          versioning scripts strip all bar a subset of symbols.  */
7973       if (stub_entry->h->oh != NULL
7974           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
7975           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
7976         {
7977           /* Point the symbol at the stub.  There may be multiple stubs,
7978              we don't really care;  The main thing is to make this sym
7979              defined somewhere.  Maybe defining the symbol in the stub
7980              section is a silly idea.  If we didn't do this, htab->top_id
7981              could disappear.  */
7982           stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
7983           stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
7984           stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
7985         }
7986
7987       /* Now build the stub.  */
7988       off = (bfd_vma) -1;
7989       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
7990         if (ent->addend == stub_entry->addend)
7991           {
7992             off = ent->plt.offset;
7993             break;
7994           }
7995       if (off >= (bfd_vma) -2)
7996         abort ();
7997
7998       off &= ~ (bfd_vma) 1;
7999       off += (htab->plt->output_offset
8000               + htab->plt->output_section->vma
8001               - elf_gp (htab->plt->output_section->owner)
8002               - htab->stub_group[stub_entry->id_sec->id].toc_off);
8003
8004       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8005         {
8006           (*_bfd_error_handler)
8007             (_("linkage table error against `%s'"),
8008              stub_entry->h->elf.root.root.string);
8009           bfd_set_error (bfd_error_bad_value);
8010           htab->stub_error = TRUE;
8011           return FALSE;
8012         }
8013
8014       p = build_plt_stub (htab->stub_bfd, loc, off);
8015       size = p - loc;
8016       break;
8017
8018     default:
8019       BFD_FAIL ();
8020       return FALSE;
8021     }
8022
8023   stub_entry->stub_sec->size += size;
8024
8025   if (htab->emit_stub_syms)
8026     {
8027       struct elf_link_hash_entry *h;
8028       size_t len1, len2;
8029       char *name;
8030       const char *const stub_str[] = { "long_branch",
8031                                        "long_branch_r2off",
8032                                        "plt_branch",
8033                                        "plt_branch_r2off",
8034                                        "plt_call" };
8035
8036       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
8037       len2 = strlen (stub_entry->root.string);
8038       name = bfd_malloc (len1 + len2 + 2);
8039       if (name == NULL)
8040         return FALSE;
8041       memcpy (name, stub_entry->root.string, 9);
8042       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
8043       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
8044       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
8045       if (h == NULL)
8046         return FALSE;
8047       if (h->root.type == bfd_link_hash_new)
8048         {
8049           h->root.type = bfd_link_hash_defined;
8050           h->root.u.def.section = stub_entry->stub_sec;
8051           h->root.u.def.value = stub_entry->stub_offset;
8052           h->ref_regular = 1;
8053           h->def_regular = 1;
8054           h->ref_regular_nonweak = 1;
8055           h->forced_local = 1;
8056           h->non_elf = 0;
8057         }
8058     }
8059
8060   return TRUE;
8061 }
8062
8063 /* As above, but don't actually build the stub.  Just bump offset so
8064    we know stub section sizes, and select plt_branch stubs where
8065    long_branch stubs won't do.  */
8066
8067 static bfd_boolean
8068 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8069 {
8070   struct ppc_stub_hash_entry *stub_entry;
8071   struct bfd_link_info *info;
8072   struct ppc_link_hash_table *htab;
8073   bfd_vma off;
8074   int size;
8075
8076   /* Massage our args to the form they really have.  */
8077   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8078   info = in_arg;
8079
8080   htab = ppc_hash_table (info);
8081
8082   if (stub_entry->stub_type == ppc_stub_plt_call)
8083     {
8084       struct plt_entry *ent;
8085       off = (bfd_vma) -1;
8086       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8087         if (ent->addend == stub_entry->addend)
8088           {
8089             off = ent->plt.offset & ~(bfd_vma) 1;
8090             break;
8091           }
8092       if (off >= (bfd_vma) -2)
8093         abort ();
8094       off += (htab->plt->output_offset
8095               + htab->plt->output_section->vma
8096               - elf_gp (htab->plt->output_section->owner)
8097               - htab->stub_group[stub_entry->id_sec->id].toc_off);
8098
8099       size = PLT_CALL_STUB_SIZE;
8100       if (PPC_HA (off + 16) != PPC_HA (off))
8101         size += 4;
8102     }
8103   else
8104     {
8105       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
8106          variants.  */
8107       off = (stub_entry->target_value
8108              + stub_entry->target_section->output_offset
8109              + stub_entry->target_section->output_section->vma);
8110       off -= (stub_entry->stub_sec->size
8111               + stub_entry->stub_sec->output_offset
8112               + stub_entry->stub_sec->output_section->vma);
8113
8114       /* Reset the stub type from the plt variant in case we now
8115          can reach with a shorter stub.  */
8116       if (stub_entry->stub_type >= ppc_stub_plt_branch)
8117         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
8118
8119       size = 4;
8120       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8121         {
8122           off -= 12;
8123           size = 16;
8124         }
8125
8126       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
8127       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8128         {
8129           struct ppc_branch_hash_entry *br_entry;
8130
8131           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8132                                              stub_entry->root.string + 9,
8133                                              TRUE, FALSE);
8134           if (br_entry == NULL)
8135             {
8136               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
8137                                      stub_entry->root.string + 9);
8138               htab->stub_error = TRUE;
8139               return FALSE;
8140             }
8141
8142           if (br_entry->iter != htab->stub_iteration)
8143             {
8144               br_entry->iter = htab->stub_iteration;
8145               br_entry->offset = htab->brlt->size;
8146               htab->brlt->size += 8;
8147
8148               if (htab->relbrlt != NULL)
8149                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
8150             }
8151
8152           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
8153           size = 16;
8154           if (stub_entry->stub_type != ppc_stub_plt_branch)
8155             size = 28;
8156         }
8157
8158       if (info->emitrelocations
8159           && (stub_entry->stub_type == ppc_stub_long_branch
8160               || stub_entry->stub_type == ppc_stub_long_branch_r2off))
8161         stub_entry->stub_sec->reloc_count += 1;
8162     }
8163
8164   stub_entry->stub_sec->size += size;
8165   return TRUE;
8166 }
8167
8168 /* Set up various things so that we can make a list of input sections
8169    for each output section included in the link.  Returns -1 on error,
8170    0 when no stubs will be needed, and 1 on success.  */
8171
8172 int
8173 ppc64_elf_setup_section_lists (bfd *output_bfd,
8174                                struct bfd_link_info *info,
8175                                int no_multi_toc)
8176 {
8177   bfd *input_bfd;
8178   int top_id, top_index, id;
8179   asection *section;
8180   asection **input_list;
8181   bfd_size_type amt;
8182   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8183
8184   htab->no_multi_toc = no_multi_toc;
8185
8186   if (htab->brlt == NULL)
8187     return 0;
8188
8189   /* Find the top input section id.  */
8190   for (input_bfd = info->input_bfds, top_id = 3;
8191        input_bfd != NULL;
8192        input_bfd = input_bfd->link_next)
8193     {
8194       for (section = input_bfd->sections;
8195            section != NULL;
8196            section = section->next)
8197         {
8198           if (top_id < section->id)
8199             top_id = section->id;
8200         }
8201     }
8202
8203   htab->top_id = top_id;
8204   amt = sizeof (struct map_stub) * (top_id + 1);
8205   htab->stub_group = bfd_zmalloc (amt);
8206   if (htab->stub_group == NULL)
8207     return -1;
8208
8209   /* Set toc_off for com, und, abs and ind sections.  */
8210   for (id = 0; id < 3; id++)
8211     htab->stub_group[id].toc_off = TOC_BASE_OFF;
8212
8213   elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
8214
8215   /* We can't use output_bfd->section_count here to find the top output
8216      section index as some sections may have been removed, and
8217      _bfd_strip_section_from_output doesn't renumber the indices.  */
8218   for (section = output_bfd->sections, top_index = 0;
8219        section != NULL;
8220        section = section->next)
8221     {
8222       if (top_index < section->index)
8223         top_index = section->index;
8224     }
8225
8226   htab->top_index = top_index;
8227   amt = sizeof (asection *) * (top_index + 1);
8228   input_list = bfd_zmalloc (amt);
8229   htab->input_list = input_list;
8230   if (input_list == NULL)
8231     return -1;
8232
8233   return 1;
8234 }
8235
8236 /* The linker repeatedly calls this function for each TOC input section
8237    and linker generated GOT section.  Group input bfds such that the toc
8238    within a group is less than 64k in size.  Will break with cute linker
8239    scripts that play games with dot in the output toc section.  */
8240
8241 void
8242 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
8243 {
8244   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8245
8246   if (!htab->no_multi_toc)
8247     {
8248       bfd_vma addr = isec->output_offset + isec->output_section->vma;
8249       bfd_vma off = addr - htab->toc_curr;
8250
8251       if (off + isec->size > 0x10000)
8252         htab->toc_curr = addr;
8253
8254       elf_gp (isec->owner) = (htab->toc_curr
8255                               - elf_gp (isec->output_section->owner)
8256                               + TOC_BASE_OFF);
8257     }
8258 }
8259
8260 /* Called after the last call to the above function.  */
8261
8262 void
8263 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
8264 {
8265   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8266
8267   htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
8268
8269   /* toc_curr tracks the TOC offset used for code sections below in
8270      ppc64_elf_next_input_section.  Start off at 0x8000.  */
8271   htab->toc_curr = TOC_BASE_OFF;
8272 }
8273
8274 /* No toc references were found in ISEC.  If the code in ISEC makes no
8275    calls, then there's no need to use toc adjusting stubs when branching
8276    into ISEC.  Actually, indirect calls from ISEC are OK as they will
8277    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
8278    needed, and 2 if a cyclical call-graph was found but no other reason
8279    for a stub was detected.  If called from the top level, a return of
8280    2 means the same as a return of 0.  */
8281
8282 static int
8283 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
8284 {
8285   Elf_Internal_Rela *relstart, *rel;
8286   Elf_Internal_Sym *local_syms;
8287   int ret;
8288   struct ppc_link_hash_table *htab;
8289
8290   /* We know none of our code bearing sections will need toc stubs.  */
8291   if ((isec->flags & SEC_LINKER_CREATED) != 0)
8292     return 0;
8293
8294   if (isec->size == 0)
8295     return 0;
8296
8297   if (isec->output_section == NULL)
8298     return 0;
8299
8300   /* Hack for linux kernel.  .fixup contains branches, but only back to
8301      the function that hit an exception.  */
8302   if (strcmp (isec->name, ".fixup") == 0)
8303     return 0;
8304
8305   if (isec->reloc_count == 0)
8306     return 0;
8307
8308   relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
8309                                         info->keep_memory);
8310   if (relstart == NULL)
8311     return -1;
8312
8313   /* Look for branches to outside of this section.  */
8314   local_syms = NULL;
8315   ret = 0;
8316   htab = ppc_hash_table (info);
8317   for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
8318     {
8319       enum elf_ppc64_reloc_type r_type;
8320       unsigned long r_symndx;
8321       struct elf_link_hash_entry *h;
8322       Elf_Internal_Sym *sym;
8323       asection *sym_sec;
8324       long *opd_adjust;
8325       bfd_vma sym_value;
8326       bfd_vma dest;
8327
8328       r_type = ELF64_R_TYPE (rel->r_info);
8329       if (r_type != R_PPC64_REL24
8330           && r_type != R_PPC64_REL14
8331           && r_type != R_PPC64_REL14_BRTAKEN
8332           && r_type != R_PPC64_REL14_BRNTAKEN)
8333         continue;
8334
8335       r_symndx = ELF64_R_SYM (rel->r_info);
8336       if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
8337                       isec->owner))
8338         {
8339           ret = -1;
8340           break;
8341         }
8342
8343       /* Ignore branches to undefined syms.  */
8344       if (sym_sec == NULL)
8345         continue;
8346
8347       /* Calls to dynamic lib functions go through a plt call stub
8348          that uses r2.  Assume branches to other sections not included
8349          in the link need stubs too, to cover -R and absolute syms.  */
8350       if (sym_sec->output_section == NULL)
8351         {
8352           ret = 1;
8353           break;
8354         }
8355
8356       if (h == NULL)
8357         sym_value = sym->st_value;
8358       else
8359         {
8360           if (h->root.type != bfd_link_hash_defined
8361               && h->root.type != bfd_link_hash_defweak)
8362             abort ();
8363           sym_value = h->root.u.def.value;
8364         }
8365       sym_value += rel->r_addend;
8366
8367       /* If this branch reloc uses an opd sym, find the code section.  */
8368       opd_adjust = get_opd_info (sym_sec);
8369       if (opd_adjust != NULL)
8370         {
8371
8372           if (h == NULL)
8373             {
8374               long adjust;
8375
8376               adjust = opd_adjust[sym->st_value / 8];
8377               if (adjust == -1)
8378                 /* Assume deleted functions won't ever be called.  */
8379                 continue;
8380               sym_value += adjust;
8381             }
8382
8383           dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
8384           if (dest == (bfd_vma) -1)
8385             continue;
8386         }
8387       else
8388         dest = (sym_value
8389                 + sym_sec->output_offset
8390                 + sym_sec->output_section->vma);
8391
8392       /* Ignore branch to self.  */
8393       if (sym_sec == isec)
8394         continue;
8395
8396       /* If the called function uses the toc, we need a stub.  */
8397       if (sym_sec->has_toc_reloc
8398           || sym_sec->makes_toc_func_call)
8399         {
8400           ret = 1;
8401           break;
8402         }
8403
8404       /* Assume any branch that needs a long branch stub might in fact
8405          need a plt_branch stub.  A plt_branch stub uses r2.  */
8406       else if (dest - (isec->output_offset
8407                        + isec->output_section->vma
8408                        + rel->r_offset) + (1 << 25) >= (2 << 25))
8409         {
8410           ret = 1;
8411           break;
8412         }
8413
8414       /* If calling back to a section in the process of being tested, we
8415          can't say for sure that no toc adjusting stubs are needed, so
8416          don't return zero.  */
8417       else if (sym_sec->call_check_in_progress)
8418         ret = 2;
8419
8420       /* Branches to another section that itself doesn't have any TOC
8421          references are OK.  Recursively call ourselves to check.  */
8422       else if (sym_sec->id <= htab->top_id
8423                && htab->stub_group[sym_sec->id].toc_off == 0)
8424         {
8425           int recur;
8426
8427           /* Mark current section as indeterminate, so that other
8428              sections that call back to current won't be marked as
8429              known.  */
8430           isec->call_check_in_progress = 1;
8431           recur = toc_adjusting_stub_needed (info, sym_sec);
8432           isec->call_check_in_progress = 0;
8433
8434           if (recur < 0)
8435             {
8436               /* An error.  Exit.  */
8437               ret = -1;
8438               break;
8439             }
8440           else if (recur <= 1)
8441             {
8442               /* Known result.  Mark as checked and set section flag.  */
8443               htab->stub_group[sym_sec->id].toc_off = 1;
8444               if (recur != 0)
8445                 {
8446                   sym_sec->makes_toc_func_call = 1;
8447                   ret = 1;
8448                   break;
8449                 }
8450             }
8451           else
8452             {
8453               /* Unknown result.  Continue checking.  */
8454               ret = 2;
8455             }
8456         }
8457     }
8458
8459   if (local_syms != NULL
8460       && (elf_tdata (isec->owner)->symtab_hdr.contents
8461           != (unsigned char *) local_syms))
8462     free (local_syms);
8463   if (elf_section_data (isec)->relocs != relstart)
8464     free (relstart);
8465
8466   return ret;
8467 }
8468
8469 /* The linker repeatedly calls this function for each input section,
8470    in the order that input sections are linked into output sections.
8471    Build lists of input sections to determine groupings between which
8472    we may insert linker stubs.  */
8473
8474 bfd_boolean
8475 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
8476 {
8477   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8478
8479   if ((isec->output_section->flags & SEC_CODE) != 0
8480       && isec->output_section->index <= htab->top_index)
8481     {
8482       asection **list = htab->input_list + isec->output_section->index;
8483       /* Steal the link_sec pointer for our list.  */
8484 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
8485       /* This happens to make the list in reverse order,
8486          which is what we want.  */
8487       PREV_SEC (isec) = *list;
8488       *list = isec;
8489     }
8490
8491   if (htab->multi_toc_needed)
8492     {
8493       /* If a code section has a function that uses the TOC then we need
8494          to use the right TOC (obviously).  Also, make sure that .opd gets
8495          the correct TOC value for R_PPC64_TOC relocs that don't have or
8496          can't find their function symbol (shouldn't ever happen now).  */
8497       if (isec->has_toc_reloc || (isec->flags & SEC_CODE) == 0)
8498         {
8499           if (elf_gp (isec->owner) != 0)
8500             htab->toc_curr = elf_gp (isec->owner);
8501         }
8502       else if (htab->stub_group[isec->id].toc_off == 0)
8503         {
8504           int ret = toc_adjusting_stub_needed (info, isec);
8505           if (ret < 0)
8506             return FALSE;
8507           else
8508             isec->makes_toc_func_call = ret & 1;
8509         }
8510     }
8511
8512   /* Functions that don't use the TOC can belong in any TOC group.
8513      Use the last TOC base.  This happens to make _init and _fini
8514      pasting work.  */
8515   htab->stub_group[isec->id].toc_off = htab->toc_curr;
8516   return TRUE;
8517 }
8518
8519 /* See whether we can group stub sections together.  Grouping stub
8520    sections may result in fewer stubs.  More importantly, we need to
8521    put all .init* and .fini* stubs at the beginning of the .init or
8522    .fini output sections respectively, because glibc splits the
8523    _init and _fini functions into multiple parts.  Putting a stub in
8524    the middle of a function is not a good idea.  */
8525
8526 static void
8527 group_sections (struct ppc_link_hash_table *htab,
8528                 bfd_size_type stub_group_size,
8529                 bfd_boolean stubs_always_before_branch)
8530 {
8531   asection **list = htab->input_list + htab->top_index;
8532   do
8533     {
8534       asection *tail = *list;
8535       while (tail != NULL)
8536         {
8537           asection *curr;
8538           asection *prev;
8539           bfd_size_type total;
8540           bfd_boolean big_sec;
8541           bfd_vma curr_toc;
8542
8543           curr = tail;
8544           total = tail->size;
8545           big_sec = total >= stub_group_size;
8546           curr_toc = htab->stub_group[tail->id].toc_off;
8547
8548           while ((prev = PREV_SEC (curr)) != NULL
8549                  && ((total += curr->output_offset - prev->output_offset)
8550                      < stub_group_size)
8551                  && htab->stub_group[prev->id].toc_off == curr_toc)
8552             curr = prev;
8553
8554           /* OK, the size from the start of CURR to the end is less
8555              than stub_group_size and thus can be handled by one stub
8556              section.  (or the tail section is itself larger than
8557              stub_group_size, in which case we may be toast.)  We
8558              should really be keeping track of the total size of stubs
8559              added here, as stubs contribute to the final output
8560              section size.  That's a little tricky, and this way will
8561              only break if stubs added make the total size more than
8562              2^25, ie. for the default stub_group_size, if stubs total
8563              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
8564           do
8565             {
8566               prev = PREV_SEC (tail);
8567               /* Set up this stub group.  */
8568               htab->stub_group[tail->id].link_sec = curr;
8569             }
8570           while (tail != curr && (tail = prev) != NULL);
8571
8572           /* But wait, there's more!  Input sections up to stub_group_size
8573              bytes before the stub section can be handled by it too.
8574              Don't do this if we have a really large section after the
8575              stubs, as adding more stubs increases the chance that
8576              branches may not reach into the stub section.  */
8577           if (!stubs_always_before_branch && !big_sec)
8578             {
8579               total = 0;
8580               while (prev != NULL
8581                      && ((total += tail->output_offset - prev->output_offset)
8582                          < stub_group_size)
8583                      && htab->stub_group[prev->id].toc_off == curr_toc)
8584                 {
8585                   tail = prev;
8586                   prev = PREV_SEC (tail);
8587                   htab->stub_group[tail->id].link_sec = curr;
8588                 }
8589             }
8590           tail = prev;
8591         }
8592     }
8593   while (list-- != htab->input_list);
8594   free (htab->input_list);
8595 #undef PREV_SEC
8596 }
8597
8598 /* Determine and set the size of the stub section for a final link.
8599
8600    The basic idea here is to examine all the relocations looking for
8601    PC-relative calls to a target that is unreachable with a "bl"
8602    instruction.  */
8603
8604 bfd_boolean
8605 ppc64_elf_size_stubs (bfd *output_bfd,
8606                       struct bfd_link_info *info,
8607                       bfd_signed_vma group_size,
8608                       asection *(*add_stub_section) (const char *, asection *),
8609                       void (*layout_sections_again) (void))
8610 {
8611   bfd_size_type stub_group_size;
8612   bfd_boolean stubs_always_before_branch;
8613   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8614
8615   /* Stash our params away.  */
8616   htab->add_stub_section = add_stub_section;
8617   htab->layout_sections_again = layout_sections_again;
8618   stubs_always_before_branch = group_size < 0;
8619   if (group_size < 0)
8620     stub_group_size = -group_size;
8621   else
8622     stub_group_size = group_size;
8623   if (stub_group_size == 1)
8624     {
8625       /* Default values.  */
8626       if (stubs_always_before_branch)
8627         {
8628           stub_group_size = 0x1e00000;
8629           if (htab->has_14bit_branch)
8630             stub_group_size = 0x7800;
8631         }
8632       else
8633         {
8634           stub_group_size = 0x1c00000;
8635           if (htab->has_14bit_branch)
8636             stub_group_size = 0x7000;
8637         }
8638     }
8639
8640   group_sections (htab, stub_group_size, stubs_always_before_branch);
8641
8642   while (1)
8643     {
8644       bfd *input_bfd;
8645       unsigned int bfd_indx;
8646       asection *stub_sec;
8647       bfd_boolean stub_changed;
8648
8649       htab->stub_iteration += 1;
8650       stub_changed = FALSE;
8651
8652       for (input_bfd = info->input_bfds, bfd_indx = 0;
8653            input_bfd != NULL;
8654            input_bfd = input_bfd->link_next, bfd_indx++)
8655         {
8656           Elf_Internal_Shdr *symtab_hdr;
8657           asection *section;
8658           Elf_Internal_Sym *local_syms = NULL;
8659
8660           /* We'll need the symbol table in a second.  */
8661           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
8662           if (symtab_hdr->sh_info == 0)
8663             continue;
8664
8665           /* Walk over each section attached to the input bfd.  */
8666           for (section = input_bfd->sections;
8667                section != NULL;
8668                section = section->next)
8669             {
8670               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
8671
8672               /* If there aren't any relocs, then there's nothing more
8673                  to do.  */
8674               if ((section->flags & SEC_RELOC) == 0
8675                   || section->reloc_count == 0)
8676                 continue;
8677
8678               /* If this section is a link-once section that will be
8679                  discarded, then don't create any stubs.  */
8680               if (section->output_section == NULL
8681                   || section->output_section->owner != output_bfd)
8682                 continue;
8683
8684               /* Get the relocs.  */
8685               internal_relocs
8686                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
8687                                              info->keep_memory);
8688               if (internal_relocs == NULL)
8689                 goto error_ret_free_local;
8690
8691               /* Now examine each relocation.  */
8692               irela = internal_relocs;
8693               irelaend = irela + section->reloc_count;
8694               for (; irela < irelaend; irela++)
8695                 {
8696                   enum elf_ppc64_reloc_type r_type;
8697                   unsigned int r_indx;
8698                   enum ppc_stub_type stub_type;
8699                   struct ppc_stub_hash_entry *stub_entry;
8700                   asection *sym_sec, *code_sec;
8701                   bfd_vma sym_value;
8702                   bfd_vma destination;
8703                   bfd_boolean ok_dest;
8704                   struct ppc_link_hash_entry *hash;
8705                   struct ppc_link_hash_entry *fdh;
8706                   struct elf_link_hash_entry *h;
8707                   Elf_Internal_Sym *sym;
8708                   char *stub_name;
8709                   const asection *id_sec;
8710                   long *opd_adjust;
8711
8712                   r_type = ELF64_R_TYPE (irela->r_info);
8713                   r_indx = ELF64_R_SYM (irela->r_info);
8714
8715                   if (r_type >= R_PPC64_max)
8716                     {
8717                       bfd_set_error (bfd_error_bad_value);
8718                       goto error_ret_free_internal;
8719                     }
8720
8721                   /* Only look for stubs on branch instructions.  */
8722                   if (r_type != R_PPC64_REL24
8723                       && r_type != R_PPC64_REL14
8724                       && r_type != R_PPC64_REL14_BRTAKEN
8725                       && r_type != R_PPC64_REL14_BRNTAKEN)
8726                     continue;
8727
8728                   /* Now determine the call target, its name, value,
8729                      section.  */
8730                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8731                                   r_indx, input_bfd))
8732                     goto error_ret_free_internal;
8733                   hash = (struct ppc_link_hash_entry *) h;
8734
8735                   ok_dest = FALSE;
8736                   fdh = NULL;
8737                   if (hash == NULL)
8738                     {
8739                       sym_value = sym->st_value;
8740                       ok_dest = TRUE;
8741                     }
8742                   else
8743                     {
8744                       sym_value = 0;
8745                       /* Recognise an old ABI func code entry sym, and
8746                          use the func descriptor sym instead.  */
8747                       if (hash->elf.root.type == bfd_link_hash_undefweak
8748                           && hash->elf.root.root.string[0] == '.'
8749                           && (fdh = get_fdh (hash, htab)) != NULL)
8750                         {
8751                           if (fdh->elf.root.type == bfd_link_hash_defined
8752                               || fdh->elf.root.type == bfd_link_hash_defweak)
8753                             {
8754                               sym_sec = fdh->elf.root.u.def.section;
8755                               sym_value = fdh->elf.root.u.def.value;
8756                               if (sym_sec->output_section != NULL)
8757                                 ok_dest = TRUE;
8758                             }
8759                           else
8760                             fdh = NULL;
8761                         }
8762                       else if (hash->elf.root.type == bfd_link_hash_defined
8763                                || hash->elf.root.type == bfd_link_hash_defweak)
8764                         {
8765                           sym_value = hash->elf.root.u.def.value;
8766                           if (sym_sec->output_section != NULL)
8767                             ok_dest = TRUE;
8768                         }
8769                       else if (hash->elf.root.type == bfd_link_hash_undefweak)
8770                         ;
8771                       else if (hash->elf.root.type == bfd_link_hash_undefined)
8772                         ;
8773                       else
8774                         {
8775                           bfd_set_error (bfd_error_bad_value);
8776                           goto error_ret_free_internal;
8777                         }
8778                     }
8779
8780                   destination = 0;
8781                   if (ok_dest)
8782                     {
8783                       sym_value += irela->r_addend;
8784                       destination = (sym_value
8785                                      + sym_sec->output_offset
8786                                      + sym_sec->output_section->vma);
8787                     }
8788
8789                   code_sec = sym_sec;
8790                   opd_adjust = get_opd_info (sym_sec);
8791                   if (opd_adjust != NULL)
8792                     {
8793                       bfd_vma dest;
8794
8795                       if (hash == NULL)
8796                         {
8797                           long adjust = opd_adjust[sym_value / 8];
8798                           if (adjust == -1)
8799                             continue;
8800                           sym_value += adjust;
8801                         }
8802                       dest = opd_entry_value (sym_sec, sym_value,
8803                                               &code_sec, &sym_value);
8804                       if (dest != (bfd_vma) -1)
8805                         {
8806                           destination = dest;
8807                           if (fdh != NULL)
8808                             {
8809                               /* Fixup old ABI sym to point at code
8810                                  entry.  */
8811                               hash->elf.root.type = bfd_link_hash_defweak;
8812                               hash->elf.root.u.def.section = code_sec;
8813                               hash->elf.root.u.def.value = sym_value;
8814                             }
8815                         }
8816                     }
8817
8818                   /* Determine what (if any) linker stub is needed.  */
8819                   stub_type = ppc_type_of_stub (section, irela, &hash,
8820                                                 destination);
8821
8822                   if (stub_type != ppc_stub_plt_call)
8823                     {
8824                       /* Check whether we need a TOC adjusting stub.
8825                          Since the linker pastes together pieces from
8826                          different object files when creating the
8827                          _init and _fini functions, it may be that a
8828                          call to what looks like a local sym is in
8829                          fact a call needing a TOC adjustment.  */
8830                       if (code_sec != NULL
8831                           && code_sec->output_section != NULL
8832                           && (htab->stub_group[code_sec->id].toc_off
8833                               != htab->stub_group[section->id].toc_off)
8834                           && (code_sec->has_toc_reloc
8835                               || code_sec->makes_toc_func_call))
8836                         stub_type = ppc_stub_long_branch_r2off;
8837                     }
8838
8839                   if (stub_type == ppc_stub_none)
8840                     continue;
8841
8842                   /* __tls_get_addr calls might be eliminated.  */
8843                   if (stub_type != ppc_stub_plt_call
8844                       && hash != NULL
8845                       && (hash == htab->tls_get_addr
8846                           || hash == htab->tls_get_addr_fd)
8847                       && section->has_tls_reloc
8848                       && irela != internal_relocs)
8849                     {
8850                       /* Get tls info.  */
8851                       char *tls_mask;
8852
8853                       if (!get_tls_mask (&tls_mask, NULL, &local_syms,
8854                                          irela - 1, input_bfd))
8855                         goto error_ret_free_internal;
8856                       if (*tls_mask != 0)
8857                         continue;
8858                     }
8859
8860                   /* Support for grouping stub sections.  */
8861                   id_sec = htab->stub_group[section->id].link_sec;
8862
8863                   /* Get the name of this stub.  */
8864                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
8865                   if (!stub_name)
8866                     goto error_ret_free_internal;
8867
8868                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
8869                                                      stub_name, FALSE, FALSE);
8870                   if (stub_entry != NULL)
8871                     {
8872                       /* The proper stub has already been created.  */
8873                       free (stub_name);
8874                       continue;
8875                     }
8876
8877                   stub_entry = ppc_add_stub (stub_name, section, htab);
8878                   if (stub_entry == NULL)
8879                     {
8880                       free (stub_name);
8881                     error_ret_free_internal:
8882                       if (elf_section_data (section)->relocs == NULL)
8883                         free (internal_relocs);
8884                     error_ret_free_local:
8885                       if (local_syms != NULL
8886                           && (symtab_hdr->contents
8887                               != (unsigned char *) local_syms))
8888                         free (local_syms);
8889                       return FALSE;
8890                     }
8891
8892                   stub_entry->stub_type = stub_type;
8893                   stub_entry->target_value = sym_value;
8894                   stub_entry->target_section = code_sec;
8895                   stub_entry->h = hash;
8896                   stub_entry->addend = irela->r_addend;
8897
8898                   if (stub_entry->h != NULL)
8899                     htab->stub_globals += 1;
8900
8901                   stub_changed = TRUE;
8902                 }
8903
8904               /* We're done with the internal relocs, free them.  */
8905               if (elf_section_data (section)->relocs != internal_relocs)
8906                 free (internal_relocs);
8907             }
8908
8909           if (local_syms != NULL
8910               && symtab_hdr->contents != (unsigned char *) local_syms)
8911             {
8912               if (!info->keep_memory)
8913                 free (local_syms);
8914               else
8915                 symtab_hdr->contents = (unsigned char *) local_syms;
8916             }
8917         }
8918
8919       if (!stub_changed)
8920         break;
8921
8922       /* OK, we've added some stubs.  Find out the new size of the
8923          stub sections.  */
8924       for (stub_sec = htab->stub_bfd->sections;
8925            stub_sec != NULL;
8926            stub_sec = stub_sec->next)
8927         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
8928           {
8929             stub_sec->size = 0;
8930             stub_sec->reloc_count = 0;
8931           }
8932
8933       htab->brlt->size = 0;
8934       if (htab->relbrlt != NULL)
8935         htab->relbrlt->size = 0;
8936
8937       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
8938
8939       /* Ask the linker to do its stuff.  */
8940       (*htab->layout_sections_again) ();
8941     }
8942
8943   /* It would be nice to strip .branch_lt from the output if the
8944      section is empty, but it's too late.  If we strip sections here,
8945      the dynamic symbol table is corrupted since the section symbol
8946      for the stripped section isn't written.  */
8947
8948   return TRUE;
8949 }
8950
8951 /* Called after we have determined section placement.  If sections
8952    move, we'll be called again.  Provide a value for TOCstart.  */
8953
8954 bfd_vma
8955 ppc64_elf_toc (bfd *obfd)
8956 {
8957   asection *s;
8958   bfd_vma TOCstart;
8959
8960   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
8961      order.  The TOC starts where the first of these sections starts.  */
8962   s = bfd_get_section_by_name (obfd, ".got");
8963   if (s == NULL)
8964     s = bfd_get_section_by_name (obfd, ".toc");
8965   if (s == NULL)
8966     s = bfd_get_section_by_name (obfd, ".tocbss");
8967   if (s == NULL)
8968     s = bfd_get_section_by_name (obfd, ".plt");
8969   if (s == NULL)
8970     {
8971       /* This may happen for
8972          o  references to TOC base (SYM@toc / TOC[tc0]) without a
8973          .toc directive
8974          o  bad linker script
8975          o --gc-sections and empty TOC sections
8976
8977          FIXME: Warn user?  */
8978
8979       /* Look for a likely section.  We probably won't even be
8980          using TOCstart.  */
8981       for (s = obfd->sections; s != NULL; s = s->next)
8982         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
8983             == (SEC_ALLOC | SEC_SMALL_DATA))
8984           break;
8985       if (s == NULL)
8986         for (s = obfd->sections; s != NULL; s = s->next)
8987           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
8988               == (SEC_ALLOC | SEC_SMALL_DATA))
8989             break;
8990       if (s == NULL)
8991         for (s = obfd->sections; s != NULL; s = s->next)
8992           if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
8993             break;
8994       if (s == NULL)
8995         for (s = obfd->sections; s != NULL; s = s->next)
8996           if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
8997             break;
8998     }
8999
9000   TOCstart = 0;
9001   if (s != NULL)
9002     TOCstart = s->output_section->vma + s->output_offset;
9003
9004   return TOCstart;
9005 }
9006
9007 /* Build all the stubs associated with the current output file.
9008    The stubs are kept in a hash table attached to the main linker
9009    hash table.  This function is called via gldelf64ppc_finish.  */
9010
9011 bfd_boolean
9012 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
9013                        struct bfd_link_info *info,
9014                        char **stats)
9015 {
9016   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9017   asection *stub_sec;
9018   bfd_byte *p;
9019   int stub_sec_count = 0;
9020
9021   htab->emit_stub_syms = emit_stub_syms;
9022
9023   /* Allocate memory to hold the linker stubs.  */
9024   for (stub_sec = htab->stub_bfd->sections;
9025        stub_sec != NULL;
9026        stub_sec = stub_sec->next)
9027     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9028         && stub_sec->size != 0)
9029       {
9030         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
9031         if (stub_sec->contents == NULL)
9032           return FALSE;
9033         /* We want to check that built size is the same as calculated
9034            size.  rawsize is a convenient location to use.  */
9035         stub_sec->rawsize = stub_sec->size;
9036         stub_sec->size = 0;
9037       }
9038
9039   if (htab->plt != NULL)
9040     {
9041       unsigned int indx;
9042       bfd_vma plt0;
9043
9044       /* Build the .glink plt call stub.  */
9045       plt0 = (htab->plt->output_section->vma
9046               + htab->plt->output_offset
9047               - (htab->glink->output_section->vma
9048                  + htab->glink->output_offset
9049                  + GLINK_CALL_STUB_SIZE));
9050       if (plt0 + 0x80008000 > 0xffffffff)
9051         {
9052           (*_bfd_error_handler) (_(".glink and .plt too far apart"));
9053           bfd_set_error (bfd_error_bad_value);
9054           return FALSE;
9055         }
9056
9057       if (htab->emit_stub_syms)
9058         {
9059           struct elf_link_hash_entry *h;
9060           h = elf_link_hash_lookup (&htab->elf, "__glink", TRUE, FALSE, FALSE);
9061           if (h == NULL)
9062             return FALSE;
9063           if (h->root.type == bfd_link_hash_new)
9064             {
9065               h->root.type = bfd_link_hash_defined;
9066               h->root.u.def.section = htab->glink;
9067               h->root.u.def.value = 0;
9068               h->ref_regular = 1;
9069               h->def_regular = 1;
9070               h->ref_regular_nonweak = 1;
9071               h->forced_local = 1;
9072               h->non_elf = 0;
9073             }
9074         }
9075       p = htab->glink->contents;
9076       bfd_put_32 (htab->glink->owner, MFCTR_R12, p);
9077       p += 4;
9078       bfd_put_32 (htab->glink->owner, SLDI_R11_R0_3, p);
9079       p += 4;
9080       bfd_put_32 (htab->glink->owner, ADDIC_R2_R0_32K, p);
9081       p += 4;
9082       bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
9083       p += 4;
9084       bfd_put_32 (htab->glink->owner, SRADI_R2_R2_63, p);
9085       p += 4;
9086       bfd_put_32 (htab->glink->owner, SLDI_R11_R0_2, p);
9087       p += 4;
9088       bfd_put_32 (htab->glink->owner, AND_R2_R2_R11, p);
9089       p += 4;
9090       bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
9091       p += 4;
9092       bfd_put_32 (htab->glink->owner, ADD_R12_R12_R2, p);
9093       p += 4;
9094       bfd_put_32 (htab->glink->owner, ADDIS_R12_R12 | PPC_HA (plt0), p);
9095       p += 4;
9096       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | PPC_LO (plt0), p);
9097       p += 4;
9098       bfd_put_32 (htab->glink->owner, ADDI_R12_R12 | PPC_LO (plt0), p);
9099       p += 4;
9100       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
9101       p += 4;
9102       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
9103       p += 4;
9104       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
9105       p += 4;
9106       bfd_put_32 (htab->glink->owner, BCTR, p);
9107       p += 4;
9108
9109       /* Build the .glink lazy link call stubs.  */
9110       indx = 0;
9111       while (p < htab->glink->contents + htab->glink->size)
9112         {
9113           if (indx < 0x8000)
9114             {
9115               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
9116               p += 4;
9117             }
9118           else
9119             {
9120               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
9121               p += 4;
9122               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
9123               p += 4;
9124             }
9125           bfd_put_32 (htab->glink->owner,
9126                       B_DOT | ((htab->glink->contents - p) & 0x3fffffc), p);
9127           indx++;
9128           p += 4;
9129         }
9130       htab->glink->rawsize = p - htab->glink->contents;
9131     }
9132
9133   if (htab->brlt->size != 0)
9134     {
9135       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
9136                                          htab->brlt->size);
9137       if (htab->brlt->contents == NULL)
9138         return FALSE;
9139     }
9140   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
9141     {
9142       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
9143                                             htab->relbrlt->size);
9144       if (htab->relbrlt->contents == NULL)
9145         return FALSE;
9146     }
9147
9148   /* Build the stubs as directed by the stub hash table.  */
9149   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
9150
9151   for (stub_sec = htab->stub_bfd->sections;
9152        stub_sec != NULL;
9153        stub_sec = stub_sec->next)
9154     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9155       {
9156         stub_sec_count += 1;
9157         if (stub_sec->rawsize != stub_sec->size)
9158           break;
9159       }
9160
9161   if (stub_sec != NULL
9162       || htab->glink->rawsize != htab->glink->size)
9163     {
9164       htab->stub_error = TRUE;
9165       (*_bfd_error_handler) (_("stubs don't match calculated size"));
9166     }
9167
9168   if (htab->stub_error)
9169     return FALSE;
9170
9171   if (stats != NULL)
9172     {
9173       *stats = bfd_malloc (500);
9174       if (*stats == NULL)
9175         return FALSE;
9176
9177       sprintf (*stats, _("linker stubs in %u group%s\n"
9178                          "  branch       %lu\n"
9179                          "  toc adjust   %lu\n"
9180                          "  long branch  %lu\n"
9181                          "  long toc adj %lu\n"
9182                          "  plt call     %lu"),
9183                stub_sec_count,
9184                stub_sec_count == 1 ? "" : "s",
9185                htab->stub_count[ppc_stub_long_branch - 1],
9186                htab->stub_count[ppc_stub_long_branch_r2off - 1],
9187                htab->stub_count[ppc_stub_plt_branch - 1],
9188                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
9189                htab->stub_count[ppc_stub_plt_call - 1]);
9190     }
9191   return TRUE;
9192 }
9193
9194 /* This function undoes the changes made by add_symbol_adjust.  */
9195
9196 static bfd_boolean
9197 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9198 {
9199   struct ppc_link_hash_entry *eh;
9200
9201   if (h->root.type == bfd_link_hash_indirect)
9202     return TRUE;
9203
9204   if (h->root.type == bfd_link_hash_warning)
9205     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9206
9207   eh = (struct ppc_link_hash_entry *) h;
9208   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
9209     return TRUE;
9210
9211   eh->elf.root.type = bfd_link_hash_undefined;
9212   return TRUE;
9213 }
9214
9215 void
9216 ppc64_elf_restore_symbols (struct bfd_link_info *info)
9217 {
9218   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9219   elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
9220 }
9221
9222 /* The RELOCATE_SECTION function is called by the ELF backend linker
9223    to handle the relocations for a section.
9224
9225    The relocs are always passed as Rela structures; if the section
9226    actually uses Rel structures, the r_addend field will always be
9227    zero.
9228
9229    This function is responsible for adjust the section contents as
9230    necessary, and (if using Rela relocs and generating a
9231    relocatable output file) adjusting the reloc addend as
9232    necessary.
9233
9234    This function does not have to worry about setting the reloc
9235    address or the reloc symbol index.
9236
9237    LOCAL_SYMS is a pointer to the swapped in local symbols.
9238
9239    LOCAL_SECTIONS is an array giving the section in the input file
9240    corresponding to the st_shndx field of each local symbol.
9241
9242    The global hash table entry for the global symbols can be found
9243    via elf_sym_hashes (input_bfd).
9244
9245    When generating relocatable output, this function must handle
9246    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
9247    going to be the section symbol corresponding to the output
9248    section, which means that the addend must be adjusted
9249    accordingly.  */
9250
9251 static bfd_boolean
9252 ppc64_elf_relocate_section (bfd *output_bfd,
9253                             struct bfd_link_info *info,
9254                             bfd *input_bfd,
9255                             asection *input_section,
9256                             bfd_byte *contents,
9257                             Elf_Internal_Rela *relocs,
9258                             Elf_Internal_Sym *local_syms,
9259                             asection **local_sections)
9260 {
9261   struct ppc_link_hash_table *htab;
9262   Elf_Internal_Shdr *symtab_hdr;
9263   struct elf_link_hash_entry **sym_hashes;
9264   Elf_Internal_Rela *rel;
9265   Elf_Internal_Rela *relend;
9266   Elf_Internal_Rela outrel;
9267   bfd_byte *loc;
9268   struct got_entry **local_got_ents;
9269   bfd_vma TOCstart;
9270   bfd_boolean ret = TRUE;
9271   bfd_boolean is_opd;
9272   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
9273   bfd_boolean is_power4 = FALSE;
9274
9275   if (info->relocatable)
9276     return TRUE;
9277
9278   /* Initialize howto table if needed.  */
9279   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9280     ppc_howto_init ();
9281
9282   htab = ppc_hash_table (info);
9283
9284   /* Don't relocate stub sections.  */
9285   if (input_section->owner == htab->stub_bfd)
9286     return TRUE;
9287
9288   local_got_ents = elf_local_got_ents (input_bfd);
9289   TOCstart = elf_gp (output_bfd);
9290   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9291   sym_hashes = elf_sym_hashes (input_bfd);
9292   is_opd = ppc64_elf_section_data (input_section)->opd.adjust != NULL;
9293
9294   rel = relocs;
9295   relend = relocs + input_section->reloc_count;
9296   for (; rel < relend; rel++)
9297     {
9298       enum elf_ppc64_reloc_type r_type;
9299       bfd_vma addend;
9300       bfd_reloc_status_type r;
9301       Elf_Internal_Sym *sym;
9302       asection *sec;
9303       struct elf_link_hash_entry *h_elf;
9304       struct ppc_link_hash_entry *h;
9305       struct ppc_link_hash_entry *fdh;
9306       const char *sym_name;
9307       unsigned long r_symndx, toc_symndx;
9308       char tls_mask, tls_gd, tls_type;
9309       char sym_type;
9310       bfd_vma relocation;
9311       bfd_boolean unresolved_reloc;
9312       bfd_boolean warned;
9313       unsigned long insn, mask;
9314       struct ppc_stub_hash_entry *stub_entry;
9315       bfd_vma max_br_offset;
9316       bfd_vma from;
9317
9318       r_type = ELF64_R_TYPE (rel->r_info);
9319       r_symndx = ELF64_R_SYM (rel->r_info);
9320
9321       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
9322          symbol of the previous ADDR64 reloc.  The symbol gives us the
9323          proper TOC base to use.  */
9324       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
9325           && rel != relocs
9326           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
9327           && is_opd)
9328         r_symndx = ELF64_R_SYM (rel[-1].r_info);
9329
9330       sym = NULL;
9331       sec = NULL;
9332       h_elf = NULL;
9333       sym_name = NULL;
9334       unresolved_reloc = FALSE;
9335       warned = FALSE;
9336
9337       if (r_symndx < symtab_hdr->sh_info)
9338         {
9339           /* It's a local symbol.  */
9340           long *opd_adjust;
9341
9342           sym = local_syms + r_symndx;
9343           sec = local_sections[r_symndx];
9344           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym);
9345           sym_type = ELF64_ST_TYPE (sym->st_info);
9346           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9347           opd_adjust = get_opd_info (sec);
9348           if (opd_adjust != NULL)
9349             {
9350               long adjust = opd_adjust[(sym->st_value + rel->r_addend) / 8];
9351               if (adjust == -1)
9352                 relocation = 0;
9353               else
9354                 relocation += adjust;
9355             }
9356         }
9357       else
9358         {
9359           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
9360                                    r_symndx, symtab_hdr, sym_hashes,
9361                                    h_elf, sec, relocation,
9362                                    unresolved_reloc, warned);
9363           sym_name = h_elf->root.root.string;
9364           sym_type = h_elf->type;
9365         }
9366       h = (struct ppc_link_hash_entry *) h_elf;
9367
9368       /* TLS optimizations.  Replace instruction sequences and relocs
9369          based on information we collected in tls_optimize.  We edit
9370          RELOCS so that --emit-relocs will output something sensible
9371          for the final instruction stream.  */
9372       tls_mask = 0;
9373       tls_gd = 0;
9374       toc_symndx = 0;
9375       if (IS_PPC64_TLS_RELOC (r_type))
9376         {
9377           if (h != NULL)
9378             tls_mask = h->tls_mask;
9379           else if (local_got_ents != NULL)
9380             {
9381               char *lgot_masks;
9382               lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
9383               tls_mask = lgot_masks[r_symndx];
9384             }
9385           if (tls_mask == 0 && r_type == R_PPC64_TLS)
9386             {
9387               /* Check for toc tls entries.  */
9388               char *toc_tls;
9389
9390               if (!get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9391                                  rel, input_bfd))
9392                 return FALSE;
9393
9394               if (toc_tls)
9395                 tls_mask = *toc_tls;
9396             }
9397         }
9398
9399       /* Check that tls relocs are used with tls syms, and non-tls
9400          relocs are used with non-tls syms.  */
9401       if (r_symndx != 0
9402           && r_type != R_PPC64_NONE
9403           && (h == NULL
9404               || h->elf.root.type == bfd_link_hash_defined
9405               || h->elf.root.type == bfd_link_hash_defweak)
9406           && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
9407         {
9408           if (r_type == R_PPC64_TLS && tls_mask != 0)
9409             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
9410             ;
9411           else
9412             (*_bfd_error_handler)
9413               (sym_type == STT_TLS
9414                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
9415                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
9416                input_bfd,
9417                input_section,
9418                (long) rel->r_offset,
9419                ppc64_elf_howto_table[r_type]->name,
9420                sym_name);
9421         }
9422
9423       /* Ensure reloc mapping code below stays sane.  */
9424       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
9425           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
9426           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
9427           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
9428           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
9429           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
9430           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
9431           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
9432           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
9433           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
9434         abort ();
9435
9436       switch (r_type)
9437         {
9438         default:
9439           break;
9440
9441         case R_PPC64_TOC16:
9442         case R_PPC64_TOC16_LO:
9443         case R_PPC64_TOC16_DS:
9444         case R_PPC64_TOC16_LO_DS:
9445           {
9446             /* Check for toc tls entries.  */
9447             char *toc_tls;
9448             int retval;
9449
9450             retval = get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9451                                    rel, input_bfd);
9452             if (retval == 0)
9453               return FALSE;
9454
9455             if (toc_tls)
9456               {
9457                 tls_mask = *toc_tls;
9458                 if (r_type == R_PPC64_TOC16_DS
9459                     || r_type == R_PPC64_TOC16_LO_DS)
9460                   {
9461                     if (tls_mask != 0
9462                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
9463                       goto toctprel;
9464                   }
9465                 else
9466                   {
9467                     /* If we found a GD reloc pair, then we might be
9468                        doing a GD->IE transition.  */
9469                     if (retval == 2)
9470                       {
9471                         tls_gd = TLS_TPRELGD;
9472                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9473                           goto tls_get_addr_check;
9474                       }
9475                     else if (retval == 3)
9476                       {
9477                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9478                           goto tls_get_addr_check;
9479                       }
9480                   }
9481               }
9482           }
9483           break;
9484
9485         case R_PPC64_GOT_TPREL16_DS:
9486         case R_PPC64_GOT_TPREL16_LO_DS:
9487           if (tls_mask != 0
9488               && (tls_mask & TLS_TPREL) == 0)
9489             {
9490             toctprel:
9491               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
9492               insn &= 31 << 21;
9493               insn |= 0x3c0d0000;       /* addis 0,13,0 */
9494               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
9495               r_type = R_PPC64_TPREL16_HA;
9496               if (toc_symndx != 0)
9497                 {
9498                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9499                   /* We changed the symbol.  Start over in order to
9500                      get h, sym, sec etc. right.  */
9501                   rel--;
9502                   continue;
9503                 }
9504               else
9505                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9506             }
9507           break;
9508
9509         case R_PPC64_TLS:
9510           if (tls_mask != 0
9511               && (tls_mask & TLS_TPREL) == 0)
9512             {
9513               bfd_vma rtra;
9514               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
9515               if ((insn & ((0x3f << 26) | (31 << 11)))
9516                   == ((31 << 26) | (13 << 11)))
9517                 rtra = insn & ((1 << 26) - (1 << 16));
9518               else if ((insn & ((0x3f << 26) | (31 << 16)))
9519                        == ((31 << 26) | (13 << 16)))
9520                 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
9521               else
9522                 abort ();
9523               if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
9524                 /* add -> addi.  */
9525                 insn = 14 << 26;
9526               else if ((insn & (31 << 1)) == 23 << 1
9527                        && ((insn & (31 << 6)) < 14 << 6
9528                            || ((insn & (31 << 6)) >= 16 << 6
9529                                && (insn & (31 << 6)) < 24 << 6)))
9530                 /* load and store indexed -> dform.  */
9531                 insn = (32 | ((insn >> 6) & 31)) << 26;
9532               else if ((insn & (31 << 1)) == 21 << 1
9533                        && (insn & (0x1a << 6)) == 0)
9534                 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
9535                 insn = (((58 | ((insn >> 6) & 4)) << 26)
9536                         | ((insn >> 6) & 1));
9537               else if ((insn & (31 << 1)) == 21 << 1
9538                        && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
9539                 /* lwax -> lwa.  */
9540                 insn = (58 << 26) | 2;
9541               else
9542                 abort ();
9543               insn |= rtra;
9544               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9545               /* Was PPC64_TLS which sits on insn boundary, now
9546                  PPC64_TPREL16_LO which is at insn+2.  */
9547               rel->r_offset += 2;
9548               r_type = R_PPC64_TPREL16_LO;
9549               if (toc_symndx != 0)
9550                 {
9551                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9552                   /* We changed the symbol.  Start over in order to
9553                      get h, sym, sec etc. right.  */
9554                   rel--;
9555                   continue;
9556                 }
9557               else
9558                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9559             }
9560           break;
9561
9562         case R_PPC64_GOT_TLSGD16_HI:
9563         case R_PPC64_GOT_TLSGD16_HA:
9564           tls_gd = TLS_TPRELGD;
9565           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9566             goto tls_gdld_hi;
9567           break;
9568
9569         case R_PPC64_GOT_TLSLD16_HI:
9570         case R_PPC64_GOT_TLSLD16_HA:
9571           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9572             {
9573             tls_gdld_hi:
9574               if ((tls_mask & tls_gd) != 0)
9575                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
9576                           + R_PPC64_GOT_TPREL16_DS);
9577               else
9578                 {
9579                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
9580                   rel->r_offset -= 2;
9581                   r_type = R_PPC64_NONE;
9582                 }
9583               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9584             }
9585           break;
9586
9587         case R_PPC64_GOT_TLSGD16:
9588         case R_PPC64_GOT_TLSGD16_LO:
9589           tls_gd = TLS_TPRELGD;
9590           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9591             goto tls_get_addr_check;
9592           break;
9593
9594         case R_PPC64_GOT_TLSLD16:
9595         case R_PPC64_GOT_TLSLD16_LO:
9596           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9597             {
9598             tls_get_addr_check:
9599               if (rel + 1 < relend)
9600                 {
9601                   enum elf_ppc64_reloc_type r_type2;
9602                   unsigned long r_symndx2;
9603                   struct elf_link_hash_entry *h2;
9604                   bfd_vma insn1, insn2, insn3;
9605                   bfd_vma offset;
9606
9607                   /* The next instruction should be a call to
9608                      __tls_get_addr.  Peek at the reloc to be sure.  */
9609                   r_type2 = ELF64_R_TYPE (rel[1].r_info);
9610                   r_symndx2 = ELF64_R_SYM (rel[1].r_info);
9611                   if (r_symndx2 < symtab_hdr->sh_info
9612                       || (r_type2 != R_PPC64_REL14
9613                           && r_type2 != R_PPC64_REL14_BRTAKEN
9614                           && r_type2 != R_PPC64_REL14_BRNTAKEN
9615                           && r_type2 != R_PPC64_REL24))
9616                     break;
9617
9618                   h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
9619                   while (h2->root.type == bfd_link_hash_indirect
9620                          || h2->root.type == bfd_link_hash_warning)
9621                     h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
9622                   if (h2 == NULL || (h2 != &htab->tls_get_addr->elf
9623                                      && h2 != &htab->tls_get_addr_fd->elf))
9624                     break;
9625
9626                   /* OK, it checks out.  Replace the call.  */
9627                   offset = rel[1].r_offset;
9628                   insn1 = bfd_get_32 (output_bfd,
9629                                       contents + rel->r_offset - 2);
9630                   insn3 = bfd_get_32 (output_bfd,
9631                                       contents + offset + 4);
9632                   if ((tls_mask & tls_gd) != 0)
9633                     {
9634                       /* IE */
9635                       insn1 &= (1 << 26) - (1 << 2);
9636                       insn1 |= 58 << 26;        /* ld */
9637                       insn2 = 0x7c636a14;       /* add 3,3,13 */
9638                       rel[1].r_info = ELF64_R_INFO (r_symndx2, R_PPC64_NONE);
9639                       if ((tls_mask & TLS_EXPLICIT) == 0)
9640                         r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
9641                                   + R_PPC64_GOT_TPREL16_DS);
9642                       else
9643                         r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
9644                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9645                     }
9646                   else
9647                     {
9648                       /* LE */
9649                       insn1 = 0x3c6d0000;       /* addis 3,13,0 */
9650                       insn2 = 0x38630000;       /* addi 3,3,0 */
9651                       if (tls_gd == 0)
9652                         {
9653                           /* Was an LD reloc.  */
9654                           r_symndx = 0;
9655                           rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
9656                           rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
9657                         }
9658                       else if (toc_symndx != 0)
9659                         r_symndx = toc_symndx;
9660                       r_type = R_PPC64_TPREL16_HA;
9661                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9662                       rel[1].r_info = ELF64_R_INFO (r_symndx,
9663                                                     R_PPC64_TPREL16_LO);
9664                       rel[1].r_offset += 2;
9665                     }
9666                   if (insn3 == NOP
9667                       || insn3 == CROR_151515 || insn3 == CROR_313131)
9668                     {
9669                       insn3 = insn2;
9670                       insn2 = NOP;
9671                       rel[1].r_offset += 4;
9672                     }
9673                   bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
9674                   bfd_put_32 (output_bfd, insn2, contents + offset);
9675                   bfd_put_32 (output_bfd, insn3, contents + offset + 4);
9676                   if (tls_gd == 0 || toc_symndx != 0)
9677                     {
9678                       /* We changed the symbol.  Start over in order
9679                          to get h, sym, sec etc. right.  */
9680                       rel--;
9681                       continue;
9682                     }
9683                 }
9684             }
9685           break;
9686
9687         case R_PPC64_DTPMOD64:
9688           if (rel + 1 < relend
9689               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
9690               && rel[1].r_offset == rel->r_offset + 8)
9691             {
9692               if ((tls_mask & TLS_GD) == 0)
9693                 {
9694                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
9695                   if ((tls_mask & TLS_TPRELGD) != 0)
9696                     r_type = R_PPC64_TPREL64;
9697                   else
9698                     {
9699                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
9700                       r_type = R_PPC64_NONE;
9701                     }
9702                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9703                 }
9704             }
9705           else
9706             {
9707               if ((tls_mask & TLS_LD) == 0)
9708                 {
9709                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
9710                   r_type = R_PPC64_NONE;
9711                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9712                 }
9713             }
9714           break;
9715
9716         case R_PPC64_TPREL64:
9717           if ((tls_mask & TLS_TPREL) == 0)
9718             {
9719               r_type = R_PPC64_NONE;
9720               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9721             }
9722           break;
9723         }
9724
9725       /* Handle other relocations that tweak non-addend part of insn.  */
9726       insn = 0;
9727       max_br_offset = 1 << 25;
9728       addend = rel->r_addend;
9729       switch (r_type)
9730         {
9731         default:
9732           break;
9733
9734           /* Branch taken prediction relocations.  */
9735         case R_PPC64_ADDR14_BRTAKEN:
9736         case R_PPC64_REL14_BRTAKEN:
9737           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
9738           /* Fall thru.  */
9739
9740           /* Branch not taken prediction relocations.  */
9741         case R_PPC64_ADDR14_BRNTAKEN:
9742         case R_PPC64_REL14_BRNTAKEN:
9743           insn |= bfd_get_32 (output_bfd,
9744                               contents + rel->r_offset) & ~(0x01 << 21);
9745           /* Fall thru.  */
9746
9747         case R_PPC64_REL14:
9748           max_br_offset = 1 << 15;
9749           /* Fall thru.  */
9750
9751         case R_PPC64_REL24:
9752           /* Calls to functions with a different TOC, such as calls to
9753              shared objects, need to alter the TOC pointer.  This is
9754              done using a linkage stub.  A REL24 branching to these
9755              linkage stubs needs to be followed by a nop, as the nop
9756              will be replaced with an instruction to restore the TOC
9757              base pointer.  */
9758           stub_entry = NULL;
9759           fdh = h;
9760           if (((h != NULL
9761                 && (((fdh = h->oh) != NULL
9762                      && fdh->elf.plt.plist != NULL)
9763                     || (fdh = h)->elf.plt.plist != NULL))
9764                || (sec != NULL
9765                    && sec->output_section != NULL
9766                    && sec->id <= htab->top_id
9767                    && (htab->stub_group[sec->id].toc_off
9768                        != htab->stub_group[input_section->id].toc_off)))
9769               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
9770                                                    rel, htab)) != NULL
9771               && (stub_entry->stub_type == ppc_stub_plt_call
9772                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
9773                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
9774             {
9775               bfd_boolean can_plt_call = FALSE;
9776
9777               if (rel->r_offset + 8 <= input_section->size)
9778                 {
9779                   unsigned long nop;
9780                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
9781                   if (nop == NOP
9782                       || nop == CROR_151515 || nop == CROR_313131)
9783                     {
9784                       bfd_put_32 (input_bfd, LD_R2_40R1,
9785                                   contents + rel->r_offset + 4);
9786                       can_plt_call = TRUE;
9787                     }
9788                 }
9789
9790               if (!can_plt_call)
9791                 {
9792                   if (stub_entry->stub_type == ppc_stub_plt_call)
9793                     {
9794                       /* If this is a plain branch rather than a branch
9795                          and link, don't require a nop.  */
9796                       unsigned long br;
9797                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
9798                       if ((br & 1) == 0)
9799                         can_plt_call = TRUE;
9800                     }
9801                   else if (h != NULL
9802                            && strcmp (h->elf.root.root.string,
9803                                       ".__libc_start_main") == 0)
9804                     {
9805                       /* Allow crt1 branch to go via a toc adjusting stub.  */
9806                       can_plt_call = TRUE;
9807                     }
9808                   else
9809                     {
9810                       if (strcmp (input_section->output_section->name,
9811                                   ".init") == 0
9812                           || strcmp (input_section->output_section->name,
9813                                      ".fini") == 0)
9814                         (*_bfd_error_handler)
9815                           (_("%B(%A+0x%lx): automatic multiple TOCs "
9816                              "not supported using your crt files; "
9817                              "recompile with -mminimal-toc or upgrade gcc"),
9818                            input_bfd,
9819                            input_section,
9820                            (long) rel->r_offset);
9821                       else
9822                         (*_bfd_error_handler)
9823                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
9824                              "does not allow automatic multiple TOCs; "
9825                              "recompile with -mminimal-toc or "
9826                              "-fno-optimize-sibling-calls, "
9827                              "or make `%s' extern"),
9828                            input_bfd,
9829                            input_section,
9830                            (long) rel->r_offset,
9831                            sym_name,
9832                            sym_name);
9833                       bfd_set_error (bfd_error_bad_value);
9834                       ret = FALSE;
9835                     }
9836                 }
9837
9838               if (can_plt_call
9839                   && stub_entry->stub_type == ppc_stub_plt_call)
9840                 unresolved_reloc = FALSE;
9841             }
9842
9843           if (stub_entry == NULL
9844               && get_opd_info (sec) != NULL)
9845             {
9846               /* The branch destination is the value of the opd entry. */
9847               bfd_vma off = (relocation - sec->output_section->vma
9848                              - sec->output_offset + rel->r_addend);
9849               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
9850               if (dest != (bfd_vma) -1)
9851                 {
9852                   relocation = dest;
9853                   addend = 0;
9854                 }
9855             }
9856
9857           /* If the branch is out of reach we ought to have a long
9858              branch stub.  */
9859           from = (rel->r_offset
9860                   + input_section->output_offset
9861                   + input_section->output_section->vma);
9862
9863           if (stub_entry == NULL
9864               && (relocation + rel->r_addend - from + max_br_offset
9865                   >= 2 * max_br_offset)
9866               && r_type != R_PPC64_ADDR14_BRTAKEN
9867               && r_type != R_PPC64_ADDR14_BRNTAKEN)
9868             stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
9869                                              htab);
9870
9871           if (stub_entry != NULL)
9872             {
9873               /* Munge up the value and addend so that we call the stub
9874                  rather than the procedure directly.  */
9875               relocation = (stub_entry->stub_offset
9876                             + stub_entry->stub_sec->output_offset
9877                             + stub_entry->stub_sec->output_section->vma);
9878               addend = 0;
9879             }
9880
9881           if (insn != 0)
9882             {
9883               if (is_power4)
9884                 {
9885                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
9886                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
9887                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
9888                   if ((insn & (0x14 << 21)) == (0x04 << 21))
9889                     insn |= 0x02 << 21;
9890                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
9891                     insn |= 0x08 << 21;
9892                   else
9893                     break;
9894                 }
9895               else
9896                 {
9897                   /* Invert 'y' bit if not the default.  */
9898                   if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
9899                     insn ^= 0x01 << 21;
9900                 }
9901
9902               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9903             }
9904
9905           /* NOP out calls to undefined weak functions.
9906              We can thus call a weak function without first
9907              checking whether the function is defined.  */
9908           else if (h != NULL
9909                    && h->elf.root.type == bfd_link_hash_undefweak
9910                    && r_type == R_PPC64_REL24
9911                    && relocation == 0
9912                    && rel->r_addend == 0)
9913             {
9914               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
9915               continue;
9916             }
9917           break;
9918         }
9919
9920       /* Set `addend'.  */
9921       tls_type = 0;
9922       switch (r_type)
9923         {
9924         default:
9925           (*_bfd_error_handler)
9926             (_("%B: unknown relocation type %d for symbol %s"),
9927              input_bfd, (int) r_type, sym_name);
9928
9929           bfd_set_error (bfd_error_bad_value);
9930           ret = FALSE;
9931           continue;
9932
9933         case R_PPC64_NONE:
9934         case R_PPC64_TLS:
9935         case R_PPC64_GNU_VTINHERIT:
9936         case R_PPC64_GNU_VTENTRY:
9937           continue;
9938
9939           /* GOT16 relocations.  Like an ADDR16 using the symbol's
9940              address in the GOT as relocation value instead of the
9941              symbol's value itself.  Also, create a GOT entry for the
9942              symbol and put the symbol value there.  */
9943         case R_PPC64_GOT_TLSGD16:
9944         case R_PPC64_GOT_TLSGD16_LO:
9945         case R_PPC64_GOT_TLSGD16_HI:
9946         case R_PPC64_GOT_TLSGD16_HA:
9947           tls_type = TLS_TLS | TLS_GD;
9948           goto dogot;
9949
9950         case R_PPC64_GOT_TLSLD16:
9951         case R_PPC64_GOT_TLSLD16_LO:
9952         case R_PPC64_GOT_TLSLD16_HI:
9953         case R_PPC64_GOT_TLSLD16_HA:
9954           tls_type = TLS_TLS | TLS_LD;
9955           goto dogot;
9956
9957         case R_PPC64_GOT_TPREL16_DS:
9958         case R_PPC64_GOT_TPREL16_LO_DS:
9959         case R_PPC64_GOT_TPREL16_HI:
9960         case R_PPC64_GOT_TPREL16_HA:
9961           tls_type = TLS_TLS | TLS_TPREL;
9962           goto dogot;
9963
9964         case R_PPC64_GOT_DTPREL16_DS:
9965         case R_PPC64_GOT_DTPREL16_LO_DS:
9966         case R_PPC64_GOT_DTPREL16_HI:
9967         case R_PPC64_GOT_DTPREL16_HA:
9968           tls_type = TLS_TLS | TLS_DTPREL;
9969           goto dogot;
9970
9971         case R_PPC64_GOT16:
9972         case R_PPC64_GOT16_LO:
9973         case R_PPC64_GOT16_HI:
9974         case R_PPC64_GOT16_HA:
9975         case R_PPC64_GOT16_DS:
9976         case R_PPC64_GOT16_LO_DS:
9977         dogot:
9978           {
9979             /* Relocation is to the entry for this symbol in the global
9980                offset table.  */
9981             asection *got;
9982             bfd_vma *offp;
9983             bfd_vma off;
9984             unsigned long indx = 0;
9985
9986             if (tls_type == (TLS_TLS | TLS_LD)
9987                 && (h == NULL
9988                     || !h->elf.def_dynamic))
9989               offp = &ppc64_tlsld_got (input_bfd)->offset;
9990             else
9991               {
9992                 struct got_entry *ent;
9993
9994                 if (h != NULL)
9995                   {
9996                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
9997                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
9998                                                           &h->elf)
9999                         || (info->shared
10000                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
10001                       /* This is actually a static link, or it is a
10002                          -Bsymbolic link and the symbol is defined
10003                          locally, or the symbol was forced to be local
10004                          because of a version file.  */
10005                       ;
10006                     else
10007                       {
10008                         indx = h->elf.dynindx;
10009                         unresolved_reloc = FALSE;
10010                       }
10011                     ent = h->elf.got.glist;
10012                   }
10013                 else
10014                   {
10015                     if (local_got_ents == NULL)
10016                       abort ();
10017                     ent = local_got_ents[r_symndx];
10018                   }
10019
10020                 for (; ent != NULL; ent = ent->next)
10021                   if (ent->addend == rel->r_addend
10022                       && ent->owner == input_bfd
10023                       && ent->tls_type == tls_type)
10024                     break;
10025                 if (ent == NULL)
10026                   abort ();
10027                 offp = &ent->got.offset;
10028               }
10029
10030             got = ppc64_elf_tdata (input_bfd)->got;
10031             if (got == NULL)
10032               abort ();
10033
10034             /* The offset must always be a multiple of 8.  We use the
10035                least significant bit to record whether we have already
10036                processed this entry.  */
10037             off = *offp;
10038             if ((off & 1) != 0)
10039               off &= ~1;
10040             else
10041               {
10042                 /* Generate relocs for the dynamic linker, except in
10043                    the case of TLSLD where we'll use one entry per
10044                    module.  */
10045                 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
10046
10047                 *offp = off | 1;
10048                 if ((info->shared || indx != 0)
10049                     && (h == NULL
10050                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10051                         || h->elf.root.type != bfd_link_hash_undefweak))
10052                   {
10053                     outrel.r_offset = (got->output_section->vma
10054                                        + got->output_offset
10055                                        + off);
10056                     outrel.r_addend = rel->r_addend;
10057                     if (tls_type & (TLS_LD | TLS_GD))
10058                       {
10059                         outrel.r_addend = 0;
10060                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
10061                         if (tls_type == (TLS_TLS | TLS_GD))
10062                           {
10063                             loc = relgot->contents;
10064                             loc += (relgot->reloc_count++
10065                                     * sizeof (Elf64_External_Rela));
10066                             bfd_elf64_swap_reloca_out (output_bfd,
10067                                                        &outrel, loc);
10068                             outrel.r_offset += 8;
10069                             outrel.r_addend = rel->r_addend;
10070                             outrel.r_info
10071                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10072                           }
10073                       }
10074                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
10075                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10076                     else if (tls_type == (TLS_TLS | TLS_TPREL))
10077                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
10078                     else if (indx == 0)
10079                       {
10080                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
10081
10082                         /* Write the .got section contents for the sake
10083                            of prelink.  */
10084                         loc = got->contents + off;
10085                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
10086                                     loc);
10087                       }
10088                     else
10089                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
10090
10091                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
10092                       {
10093                         outrel.r_addend += relocation;
10094                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
10095                           outrel.r_addend -= htab->elf.tls_sec->vma;
10096                       }
10097                     loc = relgot->contents;
10098                     loc += (relgot->reloc_count++
10099                             * sizeof (Elf64_External_Rela));
10100                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10101                   }
10102
10103                 /* Init the .got section contents here if we're not
10104                    emitting a reloc.  */
10105                 else
10106                   {
10107                     relocation += rel->r_addend;
10108                     if (tls_type == (TLS_TLS | TLS_LD))
10109                       relocation = 1;
10110                     else if (tls_type != 0)
10111                       {
10112                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
10113                         if (tls_type == (TLS_TLS | TLS_TPREL))
10114                           relocation += DTP_OFFSET - TP_OFFSET;
10115
10116                         if (tls_type == (TLS_TLS | TLS_GD))
10117                           {
10118                             bfd_put_64 (output_bfd, relocation,
10119                                         got->contents + off + 8);
10120                             relocation = 1;
10121                           }
10122                       }
10123
10124                     bfd_put_64 (output_bfd, relocation,
10125                                 got->contents + off);
10126                   }
10127               }
10128
10129             if (off >= (bfd_vma) -2)
10130               abort ();
10131
10132             relocation = got->output_offset + off;
10133
10134             /* TOC base (r2) is TOC start plus 0x8000.  */
10135             addend = -TOC_BASE_OFF;
10136           }
10137           break;
10138
10139         case R_PPC64_PLT16_HA:
10140         case R_PPC64_PLT16_HI:
10141         case R_PPC64_PLT16_LO:
10142         case R_PPC64_PLT32:
10143         case R_PPC64_PLT64:
10144           /* Relocation is to the entry for this symbol in the
10145              procedure linkage table.  */
10146
10147           /* Resolve a PLT reloc against a local symbol directly,
10148              without using the procedure linkage table.  */
10149           if (h == NULL)
10150             break;
10151
10152           /* It's possible that we didn't make a PLT entry for this
10153              symbol.  This happens when statically linking PIC code,
10154              or when using -Bsymbolic.  Go find a match if there is a
10155              PLT entry.  */
10156           if (htab->plt != NULL)
10157             {
10158               struct plt_entry *ent;
10159               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
10160                 if (ent->addend == rel->r_addend
10161                     && ent->plt.offset != (bfd_vma) -1)
10162                   {
10163                     relocation = (htab->plt->output_section->vma
10164                                   + htab->plt->output_offset
10165                                   + ent->plt.offset);
10166                     unresolved_reloc = FALSE;
10167                   }
10168             }
10169           break;
10170
10171         case R_PPC64_TOC:
10172           /* Relocation value is TOC base.  */
10173           relocation = TOCstart;
10174           if (r_symndx == 0)
10175             relocation += htab->stub_group[input_section->id].toc_off;
10176           else if (unresolved_reloc)
10177             ;
10178           else if (sec != NULL && sec->id <= htab->top_id)
10179             relocation += htab->stub_group[sec->id].toc_off;
10180           else
10181             unresolved_reloc = TRUE;
10182           goto dodyn2;
10183
10184           /* TOC16 relocs.  We want the offset relative to the TOC base,
10185              which is the address of the start of the TOC plus 0x8000.
10186              The TOC consists of sections .got, .toc, .tocbss, and .plt,
10187              in this order.  */
10188         case R_PPC64_TOC16:
10189         case R_PPC64_TOC16_LO:
10190         case R_PPC64_TOC16_HI:
10191         case R_PPC64_TOC16_DS:
10192         case R_PPC64_TOC16_LO_DS:
10193         case R_PPC64_TOC16_HA:
10194           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
10195           break;
10196
10197           /* Relocate against the beginning of the section.  */
10198         case R_PPC64_SECTOFF:
10199         case R_PPC64_SECTOFF_LO:
10200         case R_PPC64_SECTOFF_HI:
10201         case R_PPC64_SECTOFF_DS:
10202         case R_PPC64_SECTOFF_LO_DS:
10203         case R_PPC64_SECTOFF_HA:
10204           if (sec != NULL)
10205             addend -= sec->output_section->vma;
10206           break;
10207
10208         case R_PPC64_REL14:
10209         case R_PPC64_REL14_BRNTAKEN:
10210         case R_PPC64_REL14_BRTAKEN:
10211         case R_PPC64_REL24:
10212           break;
10213
10214         case R_PPC64_TPREL16:
10215         case R_PPC64_TPREL16_LO:
10216         case R_PPC64_TPREL16_HI:
10217         case R_PPC64_TPREL16_HA:
10218         case R_PPC64_TPREL16_DS:
10219         case R_PPC64_TPREL16_LO_DS:
10220         case R_PPC64_TPREL16_HIGHER:
10221         case R_PPC64_TPREL16_HIGHERA:
10222         case R_PPC64_TPREL16_HIGHEST:
10223         case R_PPC64_TPREL16_HIGHESTA:
10224           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10225           if (info->shared)
10226             /* The TPREL16 relocs shouldn't really be used in shared
10227                libs as they will result in DT_TEXTREL being set, but
10228                support them anyway.  */
10229             goto dodyn;
10230           break;
10231
10232         case R_PPC64_DTPREL16:
10233         case R_PPC64_DTPREL16_LO:
10234         case R_PPC64_DTPREL16_HI:
10235         case R_PPC64_DTPREL16_HA:
10236         case R_PPC64_DTPREL16_DS:
10237         case R_PPC64_DTPREL16_LO_DS:
10238         case R_PPC64_DTPREL16_HIGHER:
10239         case R_PPC64_DTPREL16_HIGHERA:
10240         case R_PPC64_DTPREL16_HIGHEST:
10241         case R_PPC64_DTPREL16_HIGHESTA:
10242           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10243           break;
10244
10245         case R_PPC64_DTPMOD64:
10246           relocation = 1;
10247           addend = 0;
10248           goto dodyn;
10249
10250         case R_PPC64_TPREL64:
10251           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10252           goto dodyn;
10253
10254         case R_PPC64_DTPREL64:
10255           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10256           /* Fall thru */
10257
10258           /* Relocations that may need to be propagated if this is a
10259              dynamic object.  */
10260         case R_PPC64_REL30:
10261         case R_PPC64_REL32:
10262         case R_PPC64_REL64:
10263         case R_PPC64_ADDR14:
10264         case R_PPC64_ADDR14_BRNTAKEN:
10265         case R_PPC64_ADDR14_BRTAKEN:
10266         case R_PPC64_ADDR16:
10267         case R_PPC64_ADDR16_DS:
10268         case R_PPC64_ADDR16_HA:
10269         case R_PPC64_ADDR16_HI:
10270         case R_PPC64_ADDR16_HIGHER:
10271         case R_PPC64_ADDR16_HIGHERA:
10272         case R_PPC64_ADDR16_HIGHEST:
10273         case R_PPC64_ADDR16_HIGHESTA:
10274         case R_PPC64_ADDR16_LO:
10275         case R_PPC64_ADDR16_LO_DS:
10276         case R_PPC64_ADDR24:
10277         case R_PPC64_ADDR32:
10278         case R_PPC64_ADDR64:
10279         case R_PPC64_UADDR16:
10280         case R_PPC64_UADDR32:
10281         case R_PPC64_UADDR64:
10282           /* r_symndx will be zero only for relocs against symbols
10283              from removed linkonce sections, or sections discarded by
10284              a linker script.  */
10285         dodyn:
10286           if (r_symndx == 0)
10287             break;
10288           /* Fall thru.  */
10289
10290         dodyn2:
10291           if ((input_section->flags & SEC_ALLOC) == 0)
10292             break;
10293
10294           if (NO_OPD_RELOCS && is_opd)
10295             break;
10296
10297           if ((info->shared
10298                && (h == NULL
10299                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10300                    || h->elf.root.type != bfd_link_hash_undefweak)
10301                && (MUST_BE_DYN_RELOC (r_type)
10302                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
10303               || (ELIMINATE_COPY_RELOCS
10304                   && !info->shared
10305                   && h != NULL
10306                   && h->elf.dynindx != -1
10307                   && !h->elf.non_got_ref
10308                   && h->elf.def_dynamic
10309                   && !h->elf.def_regular))
10310             {
10311               Elf_Internal_Rela outrel;
10312               bfd_boolean skip, relocate;
10313               asection *sreloc;
10314               bfd_byte *loc;
10315               bfd_vma out_off;
10316
10317               /* When generating a dynamic object, these relocations
10318                  are copied into the output file to be resolved at run
10319                  time.  */
10320
10321               skip = FALSE;
10322               relocate = FALSE;
10323
10324               out_off = _bfd_elf_section_offset (output_bfd, info,
10325                                                  input_section, rel->r_offset);
10326               if (out_off == (bfd_vma) -1)
10327                 skip = TRUE;
10328               else if (out_off == (bfd_vma) -2)
10329                 skip = TRUE, relocate = TRUE;
10330               out_off += (input_section->output_section->vma
10331                           + input_section->output_offset);
10332               outrel.r_offset = out_off;
10333               outrel.r_addend = rel->r_addend;
10334
10335               /* Optimize unaligned reloc use.  */
10336               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
10337                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
10338                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
10339               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
10340                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
10341                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
10342               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
10343                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
10344                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
10345
10346               if (skip)
10347                 memset (&outrel, 0, sizeof outrel);
10348               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
10349                        && !is_opd
10350                        && r_type != R_PPC64_TOC)
10351                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
10352               else
10353                 {
10354                   /* This symbol is local, or marked to become local,
10355                      or this is an opd section reloc which must point
10356                      at a local function.  */
10357                   outrel.r_addend += relocation;
10358                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
10359                     {
10360                       if (is_opd && h != NULL)
10361                         {
10362                           /* Lie about opd entries.  This case occurs
10363                              when building shared libraries and we
10364                              reference a function in another shared
10365                              lib.  The same thing happens for a weak
10366                              definition in an application that's
10367                              overridden by a strong definition in a
10368                              shared lib.  (I believe this is a generic
10369                              bug in binutils handling of weak syms.)
10370                              In these cases we won't use the opd
10371                              entry in this lib.  */
10372                           unresolved_reloc = FALSE;
10373                         }
10374                       outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10375
10376                       /* We need to relocate .opd contents for ld.so.
10377                          Prelink also wants simple and consistent rules
10378                          for relocs.  This make all RELATIVE relocs have
10379                          *r_offset equal to r_addend.  */
10380                       relocate = TRUE;
10381                     }
10382                   else
10383                     {
10384                       long indx = 0;
10385
10386                       if (bfd_is_abs_section (sec))
10387                         ;
10388                       else if (sec == NULL || sec->owner == NULL)
10389                         {
10390                           bfd_set_error (bfd_error_bad_value);
10391                           return FALSE;
10392                         }
10393                       else
10394                         {
10395                           asection *osec;
10396
10397                           osec = sec->output_section;
10398                           indx = elf_section_data (osec)->dynindx;
10399
10400                           /* We are turning this relocation into one
10401                              against a section symbol, so subtract out
10402                              the output section's address but not the
10403                              offset of the input section in the output
10404                              section.  */
10405                           outrel.r_addend -= osec->vma;
10406                         }
10407
10408                       outrel.r_info = ELF64_R_INFO (indx, r_type);
10409                     }
10410                 }
10411
10412               sreloc = elf_section_data (input_section)->sreloc;
10413               if (sreloc == NULL)
10414                 abort ();
10415
10416               loc = sreloc->contents;
10417               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
10418               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10419
10420               /* If this reloc is against an external symbol, it will
10421                  be computed at runtime, so there's no need to do
10422                  anything now.  However, for the sake of prelink ensure
10423                  that the section contents are a known value.  */
10424               if (! relocate)
10425                 {
10426                   unresolved_reloc = FALSE;
10427                   /* The value chosen here is quite arbitrary as ld.so
10428                      ignores section contents except for the special
10429                      case of .opd where the contents might be accessed
10430                      before relocation.  Choose zero, as that won't
10431                      cause reloc overflow.  */
10432                   relocation = 0;
10433                   addend = 0;
10434                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
10435                      to improve backward compatibility with older
10436                      versions of ld.  */
10437                   if (r_type == R_PPC64_ADDR64)
10438                     addend = outrel.r_addend;
10439                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
10440                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
10441                     addend = (input_section->output_section->vma
10442                               + input_section->output_offset
10443                               + rel->r_offset);
10444                 }
10445             }
10446           break;
10447
10448         case R_PPC64_COPY:
10449         case R_PPC64_GLOB_DAT:
10450         case R_PPC64_JMP_SLOT:
10451         case R_PPC64_RELATIVE:
10452           /* We shouldn't ever see these dynamic relocs in relocatable
10453              files.  */
10454           /* Fall through.  */
10455
10456         case R_PPC64_PLTGOT16:
10457         case R_PPC64_PLTGOT16_DS:
10458         case R_PPC64_PLTGOT16_HA:
10459         case R_PPC64_PLTGOT16_HI:
10460         case R_PPC64_PLTGOT16_LO:
10461         case R_PPC64_PLTGOT16_LO_DS:
10462         case R_PPC64_PLTREL32:
10463         case R_PPC64_PLTREL64:
10464           /* These ones haven't been implemented yet.  */
10465
10466           (*_bfd_error_handler)
10467             (_("%B: relocation %s is not supported for symbol %s."),
10468              input_bfd,
10469              ppc64_elf_howto_table[r_type]->name, sym_name);
10470
10471           bfd_set_error (bfd_error_invalid_operation);
10472           ret = FALSE;
10473           continue;
10474         }
10475
10476       /* Do any further special processing.  */
10477       switch (r_type)
10478         {
10479         default:
10480           break;
10481
10482         case R_PPC64_ADDR16_HA:
10483         case R_PPC64_ADDR16_HIGHERA:
10484         case R_PPC64_ADDR16_HIGHESTA:
10485         case R_PPC64_GOT16_HA:
10486         case R_PPC64_PLTGOT16_HA:
10487         case R_PPC64_PLT16_HA:
10488         case R_PPC64_TOC16_HA:
10489         case R_PPC64_SECTOFF_HA:
10490         case R_PPC64_TPREL16_HA:
10491         case R_PPC64_DTPREL16_HA:
10492         case R_PPC64_GOT_TLSGD16_HA:
10493         case R_PPC64_GOT_TLSLD16_HA:
10494         case R_PPC64_GOT_TPREL16_HA:
10495         case R_PPC64_GOT_DTPREL16_HA:
10496         case R_PPC64_TPREL16_HIGHER:
10497         case R_PPC64_TPREL16_HIGHERA:
10498         case R_PPC64_TPREL16_HIGHEST:
10499         case R_PPC64_TPREL16_HIGHESTA:
10500         case R_PPC64_DTPREL16_HIGHER:
10501         case R_PPC64_DTPREL16_HIGHERA:
10502         case R_PPC64_DTPREL16_HIGHEST:
10503         case R_PPC64_DTPREL16_HIGHESTA:
10504           /* It's just possible that this symbol is a weak symbol
10505              that's not actually defined anywhere. In that case,
10506              'sec' would be NULL, and we should leave the symbol
10507              alone (it will be set to zero elsewhere in the link).  */
10508           if (sec != NULL)
10509             /* Add 0x10000 if sign bit in 0:15 is set.
10510                Bits 0:15 are not used.  */
10511             addend += 0x8000;
10512           break;
10513
10514         case R_PPC64_ADDR16_DS:
10515         case R_PPC64_ADDR16_LO_DS:
10516         case R_PPC64_GOT16_DS:
10517         case R_PPC64_GOT16_LO_DS:
10518         case R_PPC64_PLT16_LO_DS:
10519         case R_PPC64_SECTOFF_DS:
10520         case R_PPC64_SECTOFF_LO_DS:
10521         case R_PPC64_TOC16_DS:
10522         case R_PPC64_TOC16_LO_DS:
10523         case R_PPC64_PLTGOT16_DS:
10524         case R_PPC64_PLTGOT16_LO_DS:
10525         case R_PPC64_GOT_TPREL16_DS:
10526         case R_PPC64_GOT_TPREL16_LO_DS:
10527         case R_PPC64_GOT_DTPREL16_DS:
10528         case R_PPC64_GOT_DTPREL16_LO_DS:
10529         case R_PPC64_TPREL16_DS:
10530         case R_PPC64_TPREL16_LO_DS:
10531         case R_PPC64_DTPREL16_DS:
10532         case R_PPC64_DTPREL16_LO_DS:
10533           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
10534           mask = 3;
10535           /* If this reloc is against an lq insn, then the value must be
10536              a multiple of 16.  This is somewhat of a hack, but the
10537              "correct" way to do this by defining _DQ forms of all the
10538              _DS relocs bloats all reloc switches in this file.  It
10539              doesn't seem to make much sense to use any of these relocs
10540              in data, so testing the insn should be safe.  */
10541           if ((insn & (0x3f << 26)) == (56u << 26))
10542             mask = 15;
10543           if (((relocation + addend) & mask) != 0)
10544             {
10545               (*_bfd_error_handler)
10546                 (_("%B: error: relocation %s not a multiple of %d"),
10547                  input_bfd,
10548                  ppc64_elf_howto_table[r_type]->name,
10549                  mask + 1);
10550               bfd_set_error (bfd_error_bad_value);
10551               ret = FALSE;
10552               continue;
10553             }
10554           break;
10555         }
10556
10557       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
10558          because such sections are not SEC_ALLOC and thus ld.so will
10559          not process them.  */
10560       if (unresolved_reloc
10561           && !((input_section->flags & SEC_DEBUGGING) != 0
10562                && h->elf.def_dynamic))
10563         {
10564           (*_bfd_error_handler)
10565             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
10566              input_bfd,
10567              input_section,
10568              (long) rel->r_offset,
10569              ppc64_elf_howto_table[(int) r_type]->name,
10570              h->elf.root.root.string);
10571           ret = FALSE;
10572         }
10573
10574       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
10575                                     input_bfd,
10576                                     input_section,
10577                                     contents,
10578                                     rel->r_offset,
10579                                     relocation,
10580                                     addend);
10581
10582       if (r != bfd_reloc_ok)
10583         {
10584           if (sym_name == NULL)
10585             sym_name = "(null)";
10586           if (r == bfd_reloc_overflow)
10587             {
10588               if (warned)
10589                 continue;
10590               if (h != NULL
10591                   && h->elf.root.type == bfd_link_hash_undefweak
10592                   && ppc64_elf_howto_table[r_type]->pc_relative)
10593                 {
10594                   /* Assume this is a call protected by other code that
10595                      detects the symbol is undefined.  If this is the case,
10596                      we can safely ignore the overflow.  If not, the
10597                      program is hosed anyway, and a little warning isn't
10598                      going to help.  */
10599
10600                   continue;
10601                 }
10602
10603               if (!((*info->callbacks->reloc_overflow)
10604                     (info, (h ? &h->elf.root : NULL), sym_name,
10605                      ppc64_elf_howto_table[r_type]->name,
10606                      rel->r_addend, input_bfd, input_section, rel->r_offset)))
10607                 return FALSE;
10608             }
10609           else
10610             {
10611               (*_bfd_error_handler)
10612                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
10613                  input_bfd,
10614                  input_section,
10615                  (long) rel->r_offset,
10616                  ppc64_elf_howto_table[r_type]->name,
10617                  sym_name,
10618                  (int) r);
10619               ret = FALSE;
10620             }
10621         }
10622     }
10623
10624   /* If we're emitting relocations, then shortly after this function
10625      returns, reloc offsets and addends for this section will be
10626      adjusted.  Worse, reloc symbol indices will be for the output
10627      file rather than the input.  Save a copy of the relocs for
10628      opd_entry_value.  */
10629   if (is_opd && info->emitrelocations)
10630     {
10631       bfd_size_type amt;
10632       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
10633       rel = bfd_alloc (input_bfd, amt);
10634       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
10635       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
10636       if (rel == NULL)
10637         return FALSE;
10638       memcpy (rel, relocs, amt);
10639     }
10640   return ret;
10641 }
10642
10643 /* Adjust the value of any local symbols in opd sections.  */
10644
10645 static bfd_boolean
10646 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
10647                               const char *name ATTRIBUTE_UNUSED,
10648                               Elf_Internal_Sym *elfsym,
10649                               asection *input_sec,
10650                               struct elf_link_hash_entry *h)
10651 {
10652   long *opd_adjust, adjust;
10653   bfd_vma value;
10654
10655   if (h != NULL)
10656     return TRUE;
10657
10658   opd_adjust = get_opd_info (input_sec);
10659   if (opd_adjust == NULL)
10660     return TRUE;
10661
10662   value = elfsym->st_value - input_sec->output_offset;
10663   if (!info->relocatable)
10664     value -= input_sec->output_section->vma;
10665
10666   adjust = opd_adjust[value / 8];
10667   if (adjust == -1)
10668     elfsym->st_value = 0;
10669   else
10670     elfsym->st_value += adjust;
10671   return TRUE;
10672 }
10673
10674 /* Finish up dynamic symbol handling.  We set the contents of various
10675    dynamic sections here.  */
10676
10677 static bfd_boolean
10678 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
10679                                  struct bfd_link_info *info,
10680                                  struct elf_link_hash_entry *h,
10681                                  Elf_Internal_Sym *sym)
10682 {
10683   struct ppc_link_hash_table *htab;
10684   bfd *dynobj;
10685   struct plt_entry *ent;
10686   Elf_Internal_Rela rela;
10687   bfd_byte *loc;
10688
10689   htab = ppc_hash_table (info);
10690   dynobj = htab->elf.dynobj;
10691
10692   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
10693     if (ent->plt.offset != (bfd_vma) -1)
10694       {
10695         /* This symbol has an entry in the procedure linkage
10696            table.  Set it up.  */
10697
10698         if (htab->plt == NULL
10699             || htab->relplt == NULL
10700             || htab->glink == NULL)
10701           abort ();
10702
10703         /* Create a JMP_SLOT reloc to inform the dynamic linker to
10704            fill in the PLT entry.  */
10705         rela.r_offset = (htab->plt->output_section->vma
10706                          + htab->plt->output_offset
10707                          + ent->plt.offset);
10708         rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
10709         rela.r_addend = ent->addend;
10710
10711         loc = htab->relplt->contents;
10712         loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
10713                 * sizeof (Elf64_External_Rela));
10714         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
10715       }
10716
10717   if (h->needs_copy)
10718     {
10719       Elf_Internal_Rela rela;
10720       bfd_byte *loc;
10721
10722       /* This symbol needs a copy reloc.  Set it up.  */
10723
10724       if (h->dynindx == -1
10725           || (h->root.type != bfd_link_hash_defined
10726               && h->root.type != bfd_link_hash_defweak)
10727           || htab->relbss == NULL)
10728         abort ();
10729
10730       rela.r_offset = (h->root.u.def.value
10731                        + h->root.u.def.section->output_section->vma
10732                        + h->root.u.def.section->output_offset);
10733       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
10734       rela.r_addend = 0;
10735       loc = htab->relbss->contents;
10736       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
10737       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
10738     }
10739
10740   /* Mark some specially defined symbols as absolute.  */
10741   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
10742     sym->st_shndx = SHN_ABS;
10743
10744   return TRUE;
10745 }
10746
10747 /* Used to decide how to sort relocs in an optimal manner for the
10748    dynamic linker, before writing them out.  */
10749
10750 static enum elf_reloc_type_class
10751 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
10752 {
10753   enum elf_ppc64_reloc_type r_type;
10754
10755   r_type = ELF64_R_TYPE (rela->r_info);
10756   switch (r_type)
10757     {
10758     case R_PPC64_RELATIVE:
10759       return reloc_class_relative;
10760     case R_PPC64_JMP_SLOT:
10761       return reloc_class_plt;
10762     case R_PPC64_COPY:
10763       return reloc_class_copy;
10764     default:
10765       return reloc_class_normal;
10766     }
10767 }
10768
10769 /* Finish up the dynamic sections.  */
10770
10771 static bfd_boolean
10772 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
10773                                    struct bfd_link_info *info)
10774 {
10775   struct ppc_link_hash_table *htab;
10776   bfd *dynobj;
10777   asection *sdyn;
10778
10779   htab = ppc_hash_table (info);
10780   dynobj = htab->elf.dynobj;
10781   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
10782
10783   if (htab->elf.dynamic_sections_created)
10784     {
10785       Elf64_External_Dyn *dyncon, *dynconend;
10786
10787       if (sdyn == NULL || htab->got == NULL)
10788         abort ();
10789
10790       dyncon = (Elf64_External_Dyn *) sdyn->contents;
10791       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
10792       for (; dyncon < dynconend; dyncon++)
10793         {
10794           Elf_Internal_Dyn dyn;
10795           asection *s;
10796
10797           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
10798
10799           switch (dyn.d_tag)
10800             {
10801             default:
10802               continue;
10803
10804             case DT_PPC64_GLINK:
10805               s = htab->glink;
10806               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10807               /* We stupidly defined DT_PPC64_GLINK to be the start
10808                  of glink rather than the first entry point, which is
10809                  what ld.so needs, and now have a bigger stub to
10810                  support automatic multiple TOCs.  */
10811               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
10812               break;
10813
10814             case DT_PPC64_OPD:
10815               s = bfd_get_section_by_name (output_bfd, ".opd");
10816               if (s == NULL)
10817                 continue;
10818               dyn.d_un.d_ptr = s->vma;
10819               break;
10820
10821             case DT_PPC64_OPDSZ:
10822               s = bfd_get_section_by_name (output_bfd, ".opd");
10823               if (s == NULL)
10824                 continue;
10825               dyn.d_un.d_val = s->size;
10826               break;
10827
10828             case DT_PLTGOT:
10829               s = htab->plt;
10830               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10831               break;
10832
10833             case DT_JMPREL:
10834               s = htab->relplt;
10835               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10836               break;
10837
10838             case DT_PLTRELSZ:
10839               dyn.d_un.d_val = htab->relplt->size;
10840               break;
10841
10842             case DT_RELASZ:
10843               /* Don't count procedure linkage table relocs in the
10844                  overall reloc count.  */
10845               s = htab->relplt;
10846               if (s == NULL)
10847                 continue;
10848               dyn.d_un.d_val -= s->size;
10849               break;
10850
10851             case DT_RELA:
10852               /* We may not be using the standard ELF linker script.
10853                  If .rela.plt is the first .rela section, we adjust
10854                  DT_RELA to not include it.  */
10855               s = htab->relplt;
10856               if (s == NULL)
10857                 continue;
10858               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
10859                 continue;
10860               dyn.d_un.d_ptr += s->size;
10861               break;
10862             }
10863
10864           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
10865         }
10866     }
10867
10868   if (htab->got != NULL && htab->got->size != 0)
10869     {
10870       /* Fill in the first entry in the global offset table.
10871          We use it to hold the link-time TOCbase.  */
10872       bfd_put_64 (output_bfd,
10873                   elf_gp (output_bfd) + TOC_BASE_OFF,
10874                   htab->got->contents);
10875
10876       /* Set .got entry size.  */
10877       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
10878     }
10879
10880   if (htab->plt != NULL && htab->plt->size != 0)
10881     {
10882       /* Set .plt entry size.  */
10883       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
10884         = PLT_ENTRY_SIZE;
10885     }
10886
10887   /* We need to handle writing out multiple GOT sections ourselves,
10888      since we didn't add them to DYNOBJ.  We know dynobj is the first
10889      bfd.  */
10890   while ((dynobj = dynobj->link_next) != NULL)
10891     {
10892       asection *s;
10893
10894       if (!is_ppc64_elf_target (dynobj->xvec))
10895         continue;
10896
10897       s = ppc64_elf_tdata (dynobj)->got;
10898       if (s != NULL
10899           && s->size != 0
10900           && s->output_section != bfd_abs_section_ptr
10901           && !bfd_set_section_contents (output_bfd, s->output_section,
10902                                         s->contents, s->output_offset,
10903                                         s->size))
10904         return FALSE;
10905       s = ppc64_elf_tdata (dynobj)->relgot;
10906       if (s != NULL
10907           && s->size != 0
10908           && s->output_section != bfd_abs_section_ptr
10909           && !bfd_set_section_contents (output_bfd, s->output_section,
10910                                         s->contents, s->output_offset,
10911                                         s->size))
10912         return FALSE;
10913     }
10914
10915   return TRUE;
10916 }
10917
10918 #include "elf64-target.h"