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