bfd/elf64-ppc.c

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