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