bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.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 *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141
 142 /* Offset of tp and dtp pointers from start of TLS block.  */
 143 #define TP_OFFSET       0x7000
 144 #define DTP_OFFSET      0x8000
 145
 146 /* .plt call stub instructions.  The normal stub is like this, but
 147    sometimes the .plt entry crosses a 64k boundary and we need to
 148    insert an addi to adjust r11.  */
 149 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 150 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 151 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 152 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 153 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 154 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 155 #define BCTR            0x4e800420      /* bctr                      */
 156
 157 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 158 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 159 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 160
 161 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 162 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 163 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 164 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 165 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 166 #define BNECTR          0x4ca20420      /* bnectr+               */
 167 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 168
 169 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 170 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 171 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 172
 173 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 174
 175 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 176 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 177 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 178
 179 /* glink call stub instructions.  We enter with the index in R0.  */
 180 #define GLINK_CALL_STUB_SIZE (16*4)
 181                                         /* 0:                           */
 182                                         /*  .quad plt0-1f               */
 183                                         /* __glink:                     */
 184 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 185 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 186                                         /* 1:                           */
 187 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 188                                         /*  ld %2,(0b-1b)(%11)          */
 189 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 190 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 191                                         /*  ld %12,0(%11)               */
 192                                         /*  ld %2,8(%11)                */
 193                                         /*  mtctr %12                   */
 194                                         /*  ld %11,16(%11)              */
 195                                         /*  bctr                        */
 196 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 197 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 198 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 199 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 200 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 201
 202 /* Pad with this.  */
 203 #define NOP             0x60000000
 204
 205 /* Some other nops.  */
 206 #define CROR_151515     0x4def7b82
 207 #define CROR_313131     0x4ffffb82
 208
 209 /* .glink entries for the first 32k functions are two instructions.  */
 210 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 211 #define B_DOT           0x48000000      /* b     .              */
 212
 213 /* After that, we need two instructions to load the index, followed by
 214    a branch.  */
 215 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 216 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 217
 218 /* Instructions used by the save and restore reg functions.  */
 219 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 220 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 221 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 222 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 223 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 224 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 225 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 226 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 227 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 228 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 229 #define BLR             0x4e800020      /* blr                  */
 230
 231 /* Since .opd is an array of descriptors and each entry will end up
 232    with identical R_PPC64_RELATIVE relocs, there is really no need to
 233    propagate .opd relocs;  The dynamic linker should be taught to
 234    relocate .opd without reloc entries.  */
 235 #ifndef NO_OPD_RELOCS
 236 #define NO_OPD_RELOCS 0
 237 #endif
 238
 239 static inline int
 240 abiversion (bfd *abfd)
 241 {
 242   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 243 }
 244
 245 static inline void
 246 set_abiversion (bfd *abfd, int ver)
 247 {
 248   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 249   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 250 }
 251 \f
 252 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 253
 254 /* Relocation HOWTO's.  */
 255 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 256
 257 static reloc_howto_type ppc64_elf_howto_raw[] = {
 258   /* This reloc does nothing.  */
 259   HOWTO (R_PPC64_NONE,          /* type */
 260          0,                     /* rightshift */
 261          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 262          32,                    /* bitsize */
 263          FALSE,                 /* pc_relative */
 264          0,                     /* bitpos */
 265          complain_overflow_dont, /* complain_on_overflow */
 266          bfd_elf_generic_reloc, /* special_function */
 267          "R_PPC64_NONE",        /* name */
 268          FALSE,                 /* partial_inplace */
 269          0,                     /* src_mask */
 270          0,                     /* dst_mask */
 271          FALSE),                /* pcrel_offset */
 272
 273   /* A standard 32 bit relocation.  */
 274   HOWTO (R_PPC64_ADDR32,        /* type */
 275          0,                     /* rightshift */
 276          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          32,                    /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_bitfield, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_ADDR32",      /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0xffffffff,            /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* An absolute 26 bit branch; the lower two bits must be zero.
 289      FIXME: we don't check that, we just clear them.  */
 290   HOWTO (R_PPC64_ADDR24,        /* type */
 291          0,                     /* rightshift */
 292          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 293          26,                    /* bitsize */
 294          FALSE,                 /* pc_relative */
 295          0,                     /* bitpos */
 296          complain_overflow_bitfield, /* complain_on_overflow */
 297          bfd_elf_generic_reloc, /* special_function */
 298          "R_PPC64_ADDR24",      /* name */
 299          FALSE,                 /* partial_inplace */
 300          0,                     /* src_mask */
 301          0x03fffffc,            /* dst_mask */
 302          FALSE),                /* pcrel_offset */
 303
 304   /* A standard 16 bit relocation.  */
 305   HOWTO (R_PPC64_ADDR16,        /* type */
 306          0,                     /* rightshift */
 307          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          16,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR16",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0xffff,                /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A 16 bit relocation without overflow.  */
 320   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_dont,/* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16_LO",   /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* Bits 16-31 of an address.  */
 335   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 336          16,                    /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_signed, /* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_HI",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 350      bits, treated as a signed number, is negative.  */
 351   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 352          16,                    /* rightshift */
 353          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 354          16,                    /* bitsize */
 355          FALSE,                 /* pc_relative */
 356          0,                     /* bitpos */
 357          complain_overflow_signed, /* complain_on_overflow */
 358          ppc64_elf_ha_reloc,    /* special_function */
 359          "R_PPC64_ADDR16_HA",   /* name */
 360          FALSE,                 /* partial_inplace */
 361          0,                     /* src_mask */
 362          0xffff,                /* dst_mask */
 363          FALSE),                /* pcrel_offset */
 364
 365   /* An absolute 16 bit branch; the lower two bits must be zero.
 366      FIXME: we don't check that, we just clear them.  */
 367   HOWTO (R_PPC64_ADDR14,        /* type */
 368          0,                     /* rightshift */
 369          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 370          16,                    /* bitsize */
 371          FALSE,                 /* pc_relative */
 372          0,                     /* bitpos */
 373          complain_overflow_signed, /* complain_on_overflow */
 374          ppc64_elf_branch_reloc, /* special_function */
 375          "R_PPC64_ADDR14",      /* name */
 376          FALSE,                 /* partial_inplace */
 377          0,                     /* src_mask */
 378          0x0000fffc,            /* dst_mask */
 379          FALSE),                /* pcrel_offset */
 380
 381   /* An absolute 16 bit branch, for which bit 10 should be set to
 382      indicate that the branch is expected to be taken.  The lower two
 383      bits must be zero.  */
 384   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 385          0,                     /* rightshift */
 386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          16,                    /* bitsize */
 388          FALSE,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_signed, /* complain_on_overflow */
 391          ppc64_elf_brtaken_reloc, /* special_function */
 392          "R_PPC64_ADDR14_BRTAKEN",/* name */
 393          FALSE,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          0x0000fffc,            /* dst_mask */
 396          FALSE),                /* pcrel_offset */
 397
 398   /* An absolute 16 bit branch, for which bit 10 should be set to
 399      indicate that the branch is not expected to be taken.  The lower
 400      two bits must be zero.  */
 401   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 402          0,                     /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          16,                    /* bitsize */
 405          FALSE,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_signed, /* complain_on_overflow */
 408          ppc64_elf_brtaken_reloc, /* special_function */
 409          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 410          FALSE,                 /* partial_inplace */
 411          0,                     /* src_mask */
 412          0x0000fffc,            /* dst_mask */
 413          FALSE),                /* pcrel_offset */
 414
 415   /* A relative 26 bit branch; the lower two bits must be zero.  */
 416   HOWTO (R_PPC64_REL24,         /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          26,                    /* bitsize */
 420          TRUE,                  /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_branch_reloc, /* special_function */
 424          "R_PPC64_REL24",       /* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x03fffffc,            /* dst_mask */
 428          TRUE),                 /* pcrel_offset */
 429
 430   /* A relative 16 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL14,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          16,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL14",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x0000fffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 446      the branch is expected to be taken.  The lower two bits must be
 447      zero.  */
 448   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 449          0,                     /* rightshift */
 450          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 451          16,                    /* bitsize */
 452          TRUE,                  /* pc_relative */
 453          0,                     /* bitpos */
 454          complain_overflow_signed, /* complain_on_overflow */
 455          ppc64_elf_brtaken_reloc, /* special_function */
 456          "R_PPC64_REL14_BRTAKEN", /* name */
 457          FALSE,                 /* partial_inplace */
 458          0,                     /* src_mask */
 459          0x0000fffc,            /* dst_mask */
 460          TRUE),                 /* pcrel_offset */
 461
 462   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 463      the branch is not expected to be taken.  The lower two bits must
 464      be zero.  */
 465   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 466          0,                     /* rightshift */
 467          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 468          16,                    /* bitsize */
 469          TRUE,                  /* pc_relative */
 470          0,                     /* bitpos */
 471          complain_overflow_signed, /* complain_on_overflow */
 472          ppc64_elf_brtaken_reloc, /* special_function */
 473          "R_PPC64_REL14_BRNTAKEN",/* name */
 474          FALSE,                 /* partial_inplace */
 475          0,                     /* src_mask */
 476          0x0000fffc,            /* dst_mask */
 477          TRUE),                 /* pcrel_offset */
 478
 479   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 480      symbol.  */
 481   HOWTO (R_PPC64_GOT16,         /* type */
 482          0,                     /* rightshift */
 483          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 484          16,                    /* bitsize */
 485          FALSE,                 /* pc_relative */
 486          0,                     /* bitpos */
 487          complain_overflow_signed, /* complain_on_overflow */
 488          ppc64_elf_unhandled_reloc, /* special_function */
 489          "R_PPC64_GOT16",       /* name */
 490          FALSE,                 /* partial_inplace */
 491          0,                     /* src_mask */
 492          0xffff,                /* dst_mask */
 493          FALSE),                /* pcrel_offset */
 494
 495   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 496      the symbol.  */
 497   HOWTO (R_PPC64_GOT16_LO,      /* type */
 498          0,                     /* rightshift */
 499          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 500          16,                    /* bitsize */
 501          FALSE,                 /* pc_relative */
 502          0,                     /* bitpos */
 503          complain_overflow_dont, /* complain_on_overflow */
 504          ppc64_elf_unhandled_reloc, /* special_function */
 505          "R_PPC64_GOT16_LO",    /* name */
 506          FALSE,                 /* partial_inplace */
 507          0,                     /* src_mask */
 508          0xffff,                /* dst_mask */
 509          FALSE),                /* pcrel_offset */
 510
 511   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 512      the symbol.  */
 513   HOWTO (R_PPC64_GOT16_HI,      /* type */
 514          16,                    /* rightshift */
 515          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 516          16,                    /* bitsize */
 517          FALSE,                 /* pc_relative */
 518          0,                     /* bitpos */
 519          complain_overflow_signed,/* complain_on_overflow */
 520          ppc64_elf_unhandled_reloc, /* special_function */
 521          "R_PPC64_GOT16_HI",    /* name */
 522          FALSE,                 /* partial_inplace */
 523          0,                     /* src_mask */
 524          0xffff,                /* dst_mask */
 525          FALSE),                /* pcrel_offset */
 526
 527   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 528      the symbol.  */
 529   HOWTO (R_PPC64_GOT16_HA,      /* type */
 530          16,                    /* rightshift */
 531          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 532          16,                    /* bitsize */
 533          FALSE,                 /* pc_relative */
 534          0,                     /* bitpos */
 535          complain_overflow_signed,/* complain_on_overflow */
 536          ppc64_elf_unhandled_reloc, /* special_function */
 537          "R_PPC64_GOT16_HA",    /* name */
 538          FALSE,                 /* partial_inplace */
 539          0,                     /* src_mask */
 540          0xffff,                /* dst_mask */
 541          FALSE),                /* pcrel_offset */
 542
 543   /* This is used only by the dynamic linker.  The symbol should exist
 544      both in the object being run and in some shared library.  The
 545      dynamic linker copies the data addressed by the symbol from the
 546      shared library into the object, because the object being
 547      run has to have the data at some particular address.  */
 548   HOWTO (R_PPC64_COPY,          /* type */
 549          0,                     /* rightshift */
 550          0,                     /* this one is variable size */
 551          0,                     /* bitsize */
 552          FALSE,                 /* pc_relative */
 553          0,                     /* bitpos */
 554          complain_overflow_dont, /* complain_on_overflow */
 555          ppc64_elf_unhandled_reloc, /* special_function */
 556          "R_PPC64_COPY",        /* name */
 557          FALSE,                 /* partial_inplace */
 558          0,                     /* src_mask */
 559          0,                     /* dst_mask */
 560          FALSE),                /* pcrel_offset */
 561
 562   /* Like R_PPC64_ADDR64, but used when setting global offset table
 563      entries.  */
 564   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 565          0,                     /* rightshift */
 566          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 567          64,                    /* bitsize */
 568          FALSE,                 /* pc_relative */
 569          0,                     /* bitpos */
 570          complain_overflow_dont, /* complain_on_overflow */
 571          ppc64_elf_unhandled_reloc,  /* special_function */
 572          "R_PPC64_GLOB_DAT",    /* name */
 573          FALSE,                 /* partial_inplace */
 574          0,                     /* src_mask */
 575          ONES (64),             /* dst_mask */
 576          FALSE),                /* pcrel_offset */
 577
 578   /* Created by the link editor.  Marks a procedure linkage table
 579      entry for a symbol.  */
 580   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 581          0,                     /* rightshift */
 582          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 583          0,                     /* bitsize */
 584          FALSE,                 /* pc_relative */
 585          0,                     /* bitpos */
 586          complain_overflow_dont, /* complain_on_overflow */
 587          ppc64_elf_unhandled_reloc, /* special_function */
 588          "R_PPC64_JMP_SLOT",    /* name */
 589          FALSE,                 /* partial_inplace */
 590          0,                     /* src_mask */
 591          0,                     /* dst_mask */
 592          FALSE),                /* pcrel_offset */
 593
 594   /* Used only by the dynamic linker.  When the object is run, this
 595      doubleword64 is set to the load address of the object, plus the
 596      addend.  */
 597   HOWTO (R_PPC64_RELATIVE,      /* type */
 598          0,                     /* rightshift */
 599          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 600          64,                    /* bitsize */
 601          FALSE,                 /* pc_relative */
 602          0,                     /* bitpos */
 603          complain_overflow_dont, /* complain_on_overflow */
 604          bfd_elf_generic_reloc, /* special_function */
 605          "R_PPC64_RELATIVE",    /* name */
 606          FALSE,                 /* partial_inplace */
 607          0,                     /* src_mask */
 608          ONES (64),             /* dst_mask */
 609          FALSE),                /* pcrel_offset */
 610
 611   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 612   HOWTO (R_PPC64_UADDR32,       /* type */
 613          0,                     /* rightshift */
 614          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 615          32,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_bitfield, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_UADDR32",     /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          0xffffffff,            /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR16,       /* type */
 628          0,                     /* rightshift */
 629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          16,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR16",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffff,                /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* 32-bit PC relative.  */
 642   HOWTO (R_PPC64_REL32,         /* type */
 643          0,                     /* rightshift */
 644          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          32,                    /* bitsize */
 646          TRUE,                  /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_signed, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_REL32",       /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffffffff,            /* dst_mask */
 654          TRUE),                 /* pcrel_offset */
 655
 656   /* 32-bit relocation to the symbol's procedure linkage table.  */
 657   HOWTO (R_PPC64_PLT32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          FALSE,                 /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_bitfield, /* complain_on_overflow */
 664          ppc64_elf_unhandled_reloc, /* special_function */
 665          "R_PPC64_PLT32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          FALSE),                /* pcrel_offset */
 670
 671   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 672      FIXME: R_PPC64_PLTREL32 not supported.  */
 673   HOWTO (R_PPC64_PLTREL32,      /* type */
 674          0,                     /* rightshift */
 675          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 676          32,                    /* bitsize */
 677          TRUE,                  /* pc_relative */
 678          0,                     /* bitpos */
 679          complain_overflow_signed, /* complain_on_overflow */
 680          bfd_elf_generic_reloc, /* special_function */
 681          "R_PPC64_PLTREL32",    /* name */
 682          FALSE,                 /* partial_inplace */
 683          0,                     /* src_mask */
 684          0xffffffff,            /* dst_mask */
 685          TRUE),                 /* pcrel_offset */
 686
 687   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 688      the symbol.  */
 689   HOWTO (R_PPC64_PLT16_LO,      /* type */
 690          0,                     /* rightshift */
 691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 692          16,                    /* bitsize */
 693          FALSE,                 /* pc_relative */
 694          0,                     /* bitpos */
 695          complain_overflow_dont, /* complain_on_overflow */
 696          ppc64_elf_unhandled_reloc, /* special_function */
 697          "R_PPC64_PLT16_LO",    /* name */
 698          FALSE,                 /* partial_inplace */
 699          0,                     /* src_mask */
 700          0xffff,                /* dst_mask */
 701          FALSE),                /* pcrel_offset */
 702
 703   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 704      the symbol.  */
 705   HOWTO (R_PPC64_PLT16_HI,      /* type */
 706          16,                    /* rightshift */
 707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 708          16,                    /* bitsize */
 709          FALSE,                 /* pc_relative */
 710          0,                     /* bitpos */
 711          complain_overflow_signed, /* complain_on_overflow */
 712          ppc64_elf_unhandled_reloc, /* special_function */
 713          "R_PPC64_PLT16_HI",    /* name */
 714          FALSE,                 /* partial_inplace */
 715          0,                     /* src_mask */
 716          0xffff,                /* dst_mask */
 717          FALSE),                /* pcrel_offset */
 718
 719   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 720      the symbol.  */
 721   HOWTO (R_PPC64_PLT16_HA,      /* type */
 722          16,                    /* rightshift */
 723          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 724          16,                    /* bitsize */
 725          FALSE,                 /* pc_relative */
 726          0,                     /* bitpos */
 727          complain_overflow_signed, /* complain_on_overflow */
 728          ppc64_elf_unhandled_reloc, /* special_function */
 729          "R_PPC64_PLT16_HA",    /* name */
 730          FALSE,                 /* partial_inplace */
 731          0,                     /* src_mask */
 732          0xffff,                /* dst_mask */
 733          FALSE),                /* pcrel_offset */
 734
 735   /* 16-bit section relative relocation.  */
 736   HOWTO (R_PPC64_SECTOFF,       /* type */
 737          0,                     /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_sectoff_reloc, /* special_function */
 744          "R_PPC64_SECTOFF",     /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 751   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_dont, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF_LO",  /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* 16-bit upper half section relative relocation.  */
 766   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 767          16,                    /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_signed, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_HI",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half adjusted section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_ha_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HA",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 796   HOWTO (R_PPC64_REL30,         /* type */
 797          2,                     /* rightshift */
 798          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          30,                    /* bitsize */
 800          TRUE,                  /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_dont, /* complain_on_overflow */
 803          bfd_elf_generic_reloc, /* special_function */
 804          "R_PPC64_REL30",       /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xfffffffc,            /* dst_mask */
 808          TRUE),                 /* pcrel_offset */
 809
 810   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 811
 812   /* A standard 64-bit relocation.  */
 813   HOWTO (R_PPC64_ADDR64,        /* type */
 814          0,                     /* rightshift */
 815          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 816          64,                    /* bitsize */
 817          FALSE,                 /* pc_relative */
 818          0,                     /* bitpos */
 819          complain_overflow_dont, /* complain_on_overflow */
 820          bfd_elf_generic_reloc, /* special_function */
 821          "R_PPC64_ADDR64",      /* name */
 822          FALSE,                 /* partial_inplace */
 823          0,                     /* src_mask */
 824          ONES (64),             /* dst_mask */
 825          FALSE),                /* pcrel_offset */
 826
 827   /* The bits 32-47 of an address.  */
 828   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 829          32,                    /* rightshift */
 830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 831          16,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR16_HIGHER", /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          0xffff,                /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address, plus 1 if the contents of the low
 843      16 bits, treated as a signed number, is negative.  */
 844   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 845          32,                    /* rightshift */
 846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 847          16,                    /* bitsize */
 848          FALSE,                 /* pc_relative */
 849          0,                     /* bitpos */
 850          complain_overflow_dont, /* complain_on_overflow */
 851          ppc64_elf_ha_reloc,    /* special_function */
 852          "R_PPC64_ADDR16_HIGHERA", /* name */
 853          FALSE,                 /* partial_inplace */
 854          0,                     /* src_mask */
 855          0xffff,                /* dst_mask */
 856          FALSE),                /* pcrel_offset */
 857
 858   /* The bits 48-63 of an address.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 860          48,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          bfd_elf_generic_reloc, /* special_function */
 867          "R_PPC64_ADDR16_HIGHEST", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address, plus 1 if the contents of the low
 874      16 bits, treated as a signed number, is negative.  */
 875   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 876          48,                    /* rightshift */
 877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 878          16,                    /* bitsize */
 879          FALSE,                 /* pc_relative */
 880          0,                     /* bitpos */
 881          complain_overflow_dont, /* complain_on_overflow */
 882          ppc64_elf_ha_reloc,    /* special_function */
 883          "R_PPC64_ADDR16_HIGHESTA", /* name */
 884          FALSE,                 /* partial_inplace */
 885          0,                     /* src_mask */
 886          0xffff,                /* dst_mask */
 887          FALSE),                /* pcrel_offset */
 888
 889   /* Like ADDR64, but may be unaligned.  */
 890   HOWTO (R_PPC64_UADDR64,       /* type */
 891          0,                     /* rightshift */
 892          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 893          64,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          bfd_elf_generic_reloc, /* special_function */
 898          "R_PPC64_UADDR64",     /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          ONES (64),             /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* 64-bit relative relocation.  */
 905   HOWTO (R_PPC64_REL64,         /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          TRUE,                  /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_REL64",       /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          TRUE),                 /* pcrel_offset */
 918
 919   /* 64-bit relocation to the symbol's procedure linkage table.  */
 920   HOWTO (R_PPC64_PLT64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          FALSE,                 /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          ppc64_elf_unhandled_reloc, /* special_function */
 928          "R_PPC64_PLT64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          FALSE),                /* pcrel_offset */
 933
 934   /* 64-bit PC relative relocation to the symbol's procedure linkage
 935      table.  */
 936   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 937   HOWTO (R_PPC64_PLTREL64,      /* type */
 938          0,                     /* rightshift */
 939          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 940          64,                    /* bitsize */
 941          TRUE,                  /* pc_relative */
 942          0,                     /* bitpos */
 943          complain_overflow_dont, /* complain_on_overflow */
 944          ppc64_elf_unhandled_reloc, /* special_function */
 945          "R_PPC64_PLTREL64",    /* name */
 946          FALSE,                 /* partial_inplace */
 947          0,                     /* src_mask */
 948          ONES (64),             /* dst_mask */
 949          TRUE),                 /* pcrel_offset */
 950
 951   /* 16 bit TOC-relative relocation.  */
 952
 953   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 954   HOWTO (R_PPC64_TOC16,         /* type */
 955          0,                     /* rightshift */
 956          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 957          16,                    /* bitsize */
 958          FALSE,                 /* pc_relative */
 959          0,                     /* bitpos */
 960          complain_overflow_signed, /* complain_on_overflow */
 961          ppc64_elf_toc_reloc,   /* special_function */
 962          "R_PPC64_TOC16",       /* name */
 963          FALSE,                 /* partial_inplace */
 964          0,                     /* src_mask */
 965          0xffff,                /* dst_mask */
 966          FALSE),                /* pcrel_offset */
 967
 968   /* 16 bit TOC-relative relocation without overflow.  */
 969
 970   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 971   HOWTO (R_PPC64_TOC16_LO,      /* type */
 972          0,                     /* rightshift */
 973          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 974          16,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_dont, /* complain_on_overflow */
 978          ppc64_elf_toc_reloc,   /* special_function */
 979          "R_PPC64_TOC16_LO",    /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          0xffff,                /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* 16 bit TOC-relative relocation, high 16 bits.  */
 986
 987   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 988   HOWTO (R_PPC64_TOC16_HI,      /* type */
 989          16,                    /* rightshift */
 990          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 991          16,                    /* bitsize */
 992          FALSE,                 /* pc_relative */
 993          0,                     /* bitpos */
 994          complain_overflow_signed, /* complain_on_overflow */
 995          ppc64_elf_toc_reloc,   /* special_function */
 996          "R_PPC64_TOC16_HI",    /* name */
 997          FALSE,                 /* partial_inplace */
 998          0,                     /* src_mask */
 999          0xffff,                /* dst_mask */
1000          FALSE),                /* pcrel_offset */
1001
1002   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1003      contents of the low 16 bits, treated as a signed number, is
1004      negative.  */
1005
1006   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1007   HOWTO (R_PPC64_TOC16_HA,      /* type */
1008          16,                    /* rightshift */
1009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1010          16,                    /* bitsize */
1011          FALSE,                 /* pc_relative */
1012          0,                     /* bitpos */
1013          complain_overflow_signed, /* complain_on_overflow */
1014          ppc64_elf_toc_ha_reloc, /* special_function */
1015          "R_PPC64_TOC16_HA",    /* name */
1016          FALSE,                 /* partial_inplace */
1017          0,                     /* src_mask */
1018          0xffff,                /* dst_mask */
1019          FALSE),                /* pcrel_offset */
1020
1021   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1022
1023   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1024   HOWTO (R_PPC64_TOC,           /* type */
1025          0,                     /* rightshift */
1026          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1027          64,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_dont, /* complain_on_overflow */
1031          ppc64_elf_toc64_reloc, /* special_function */
1032          "R_PPC64_TOC",         /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          ONES (64),             /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* Like R_PPC64_GOT16, but also informs the link editor that the
1039      value to relocate may (!) refer to a PLT entry which the link
1040      editor (a) may replace with the symbol value.  If the link editor
1041      is unable to fully resolve the symbol, it may (b) create a PLT
1042      entry and store the address to the new PLT entry in the GOT.
1043      This permits lazy resolution of function symbols at run time.
1044      The link editor may also skip all of this and just (c) emit a
1045      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1046   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1047     HOWTO (R_PPC64_PLTGOT16,    /* type */
1048          0,                     /* rightshift */
1049          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1050          16,                    /* bitsize */
1051          FALSE,                 /* pc_relative */
1052          0,                     /* bitpos */
1053          complain_overflow_signed, /* complain_on_overflow */
1054          ppc64_elf_unhandled_reloc, /* special_function */
1055          "R_PPC64_PLTGOT16",    /* name */
1056          FALSE,                 /* partial_inplace */
1057          0,                     /* src_mask */
1058          0xffff,                /* dst_mask */
1059          FALSE),                /* pcrel_offset */
1060
1061   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1062   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1063   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1064          0,                     /* rightshift */
1065          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1066          16,                    /* bitsize */
1067          FALSE,                 /* pc_relative */
1068          0,                     /* bitpos */
1069          complain_overflow_dont, /* complain_on_overflow */
1070          ppc64_elf_unhandled_reloc, /* special_function */
1071          "R_PPC64_PLTGOT16_LO", /* name */
1072          FALSE,                 /* partial_inplace */
1073          0,                     /* src_mask */
1074          0xffff,                /* dst_mask */
1075          FALSE),                /* pcrel_offset */
1076
1077   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1078   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1079   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1080          16,                    /* rightshift */
1081          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1082          16,                    /* bitsize */
1083          FALSE,                 /* pc_relative */
1084          0,                     /* bitpos */
1085          complain_overflow_signed, /* complain_on_overflow */
1086          ppc64_elf_unhandled_reloc, /* special_function */
1087          "R_PPC64_PLTGOT16_HI", /* name */
1088          FALSE,                 /* partial_inplace */
1089          0,                     /* src_mask */
1090          0xffff,                /* dst_mask */
1091          FALSE),                /* pcrel_offset */
1092
1093   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1094      1 if the contents of the low 16 bits, treated as a signed number,
1095      is negative.  */
1096   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1097   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1098          16,                    /* rightshift */
1099          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1100          16,                    /* bitsize */
1101          FALSE,                 /* pc_relative */
1102          0,                     /* bitpos */
1103          complain_overflow_signed, /* complain_on_overflow */
1104          ppc64_elf_unhandled_reloc, /* special_function */
1105          "R_PPC64_PLTGOT16_HA", /* name */
1106          FALSE,                 /* partial_inplace */
1107          0,                     /* src_mask */
1108          0xffff,                /* dst_mask */
1109          FALSE),                /* pcrel_offset */
1110
1111   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1112   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1113          0,                     /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          bfd_elf_generic_reloc, /* special_function */
1120          "R_PPC64_ADDR16_DS",   /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xfffc,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_dont,/* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_LO_DS",/* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_GOT16_DS,      /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_signed, /* complain_on_overflow */
1149          ppc64_elf_unhandled_reloc, /* special_function */
1150          "R_PPC64_GOT16_DS",    /* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_dont, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_LO_DS", /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_PLT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_signed, /* complain_on_overflow */
1194          ppc64_elf_sectoff_reloc, /* special_function */
1195          "R_PPC64_SECTOFF_DS",  /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_dont, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_LO_DS",/* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_TOC16_DS,      /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_signed, /* complain_on_overflow */
1224          ppc64_elf_toc_reloc,   /* special_function */
1225          "R_PPC64_TOC16_DS",    /* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_dont, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_LO_DS", /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1247   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1248   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1249          0,                     /* rightshift */
1250          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1251          16,                    /* bitsize */
1252          FALSE,                 /* pc_relative */
1253          0,                     /* bitpos */
1254          complain_overflow_signed, /* complain_on_overflow */
1255          ppc64_elf_unhandled_reloc, /* special_function */
1256          "R_PPC64_PLTGOT16_DS", /* name */
1257          FALSE,                 /* partial_inplace */
1258          0,                     /* src_mask */
1259          0xfffc,                /* dst_mask */
1260          FALSE),                /* pcrel_offset */
1261
1262   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1263   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1264   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1265          0,                     /* rightshift */
1266          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1267          16,                    /* bitsize */
1268          FALSE,                 /* pc_relative */
1269          0,                     /* bitpos */
1270          complain_overflow_dont, /* complain_on_overflow */
1271          ppc64_elf_unhandled_reloc, /* special_function */
1272          "R_PPC64_PLTGOT16_LO_DS",/* name */
1273          FALSE,                 /* partial_inplace */
1274          0,                     /* src_mask */
1275          0xfffc,                /* dst_mask */
1276          FALSE),                /* pcrel_offset */
1277
1278   /* Marker relocs for TLS.  */
1279   HOWTO (R_PPC64_TLS,
1280          0,                     /* rightshift */
1281          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          32,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          bfd_elf_generic_reloc, /* special_function */
1287          "R_PPC64_TLS",         /* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0,                     /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   HOWTO (R_PPC64_TLSGD,
1294          0,                     /* rightshift */
1295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1296          32,                    /* bitsize */
1297          FALSE,                 /* pc_relative */
1298          0,                     /* bitpos */
1299          complain_overflow_dont, /* complain_on_overflow */
1300          bfd_elf_generic_reloc, /* special_function */
1301          "R_PPC64_TLSGD",       /* name */
1302          FALSE,                 /* partial_inplace */
1303          0,                     /* src_mask */
1304          0,                     /* dst_mask */
1305          FALSE),                /* pcrel_offset */
1306
1307   HOWTO (R_PPC64_TLSLD,
1308          0,                     /* rightshift */
1309          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1310          32,                    /* bitsize */
1311          FALSE,                 /* pc_relative */
1312          0,                     /* bitpos */
1313          complain_overflow_dont, /* complain_on_overflow */
1314          bfd_elf_generic_reloc, /* special_function */
1315          "R_PPC64_TLSLD",       /* name */
1316          FALSE,                 /* partial_inplace */
1317          0,                     /* src_mask */
1318          0,                     /* dst_mask */
1319          FALSE),                /* pcrel_offset */
1320
1321   HOWTO (R_PPC64_TOCSAVE,
1322          0,                     /* rightshift */
1323          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1324          32,                    /* bitsize */
1325          FALSE,                 /* pc_relative */
1326          0,                     /* bitpos */
1327          complain_overflow_dont, /* complain_on_overflow */
1328          bfd_elf_generic_reloc, /* special_function */
1329          "R_PPC64_TOCSAVE",     /* name */
1330          FALSE,                 /* partial_inplace */
1331          0,                     /* src_mask */
1332          0,                     /* dst_mask */
1333          FALSE),                /* pcrel_offset */
1334
1335   /* Computes the load module index of the load module that contains the
1336      definition of its TLS sym.  */
1337   HOWTO (R_PPC64_DTPMOD64,
1338          0,                     /* rightshift */
1339          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1340          64,                    /* bitsize */
1341          FALSE,                 /* pc_relative */
1342          0,                     /* bitpos */
1343          complain_overflow_dont, /* complain_on_overflow */
1344          ppc64_elf_unhandled_reloc, /* special_function */
1345          "R_PPC64_DTPMOD64",    /* name */
1346          FALSE,                 /* partial_inplace */
1347          0,                     /* src_mask */
1348          ONES (64),             /* dst_mask */
1349          FALSE),                /* pcrel_offset */
1350
1351   /* Computes a dtv-relative displacement, the difference between the value
1352      of sym+add and the base address of the thread-local storage block that
1353      contains the definition of sym, minus 0x8000.  */
1354   HOWTO (R_PPC64_DTPREL64,
1355          0,                     /* rightshift */
1356          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1357          64,                    /* bitsize */
1358          FALSE,                 /* pc_relative */
1359          0,                     /* bitpos */
1360          complain_overflow_dont, /* complain_on_overflow */
1361          ppc64_elf_unhandled_reloc, /* special_function */
1362          "R_PPC64_DTPREL64",    /* name */
1363          FALSE,                 /* partial_inplace */
1364          0,                     /* src_mask */
1365          ONES (64),             /* dst_mask */
1366          FALSE),                /* pcrel_offset */
1367
1368   /* A 16 bit dtprel reloc.  */
1369   HOWTO (R_PPC64_DTPREL16,
1370          0,                     /* rightshift */
1371          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          16,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_signed, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL16",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          0xffff,                /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* Like DTPREL16, but no overflow.  */
1384   HOWTO (R_PPC64_DTPREL16_LO,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_dont, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16_LO", /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1399   HOWTO (R_PPC64_DTPREL16_HI,
1400          16,                    /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_signed, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_HI", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HA,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HA", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HIGHER,
1430          32,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_dont, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HIGHER", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHERA", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1460          48,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHEST", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16, but for insns with a DS field.  */
1489   HOWTO (R_PPC64_DTPREL16_DS,
1490          0,                     /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_signed, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_DS", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xfffc,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16_DS, but no overflow.  */
1504   HOWTO (R_PPC64_DTPREL16_LO_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_dont, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_LO_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Computes a tp-relative displacement, the difference between the value of
1519      sym+add and the value of the thread pointer (r13).  */
1520   HOWTO (R_PPC64_TPREL64,
1521          0,                     /* rightshift */
1522          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1523          64,                    /* bitsize */
1524          FALSE,                 /* pc_relative */
1525          0,                     /* bitpos */
1526          complain_overflow_dont, /* complain_on_overflow */
1527          ppc64_elf_unhandled_reloc, /* special_function */
1528          "R_PPC64_TPREL64",     /* name */
1529          FALSE,                 /* partial_inplace */
1530          0,                     /* src_mask */
1531          ONES (64),             /* dst_mask */
1532          FALSE),                /* pcrel_offset */
1533
1534   /* A 16 bit tprel reloc.  */
1535   HOWTO (R_PPC64_TPREL16,
1536          0,                     /* rightshift */
1537          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          16,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_signed, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL16",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          0xffff,                /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* Like TPREL16, but no overflow.  */
1550   HOWTO (R_PPC64_TPREL16_LO,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_dont, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16_LO",  /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1565   HOWTO (R_PPC64_TPREL16_HI,
1566          16,                    /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_signed, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_HI",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HA,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HA",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HIGHER,
1596          32,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_dont, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HIGHER",      /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHERA,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHERA", /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHEST,
1626          48,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHEST", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHESTA", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16, but for insns with a DS field.  */
1655   HOWTO (R_PPC64_TPREL16_DS,
1656          0,                     /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_signed, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_DS",  /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xfffc,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16_DS, but no overflow.  */
1670   HOWTO (R_PPC64_TPREL16_LO_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_dont, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_LO_DS", /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1685      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1686      to the first entry relative to the TOC base (r2).  */
1687   HOWTO (R_PPC64_GOT_TLSGD16,
1688          0,                     /* rightshift */
1689          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1690          16,                    /* bitsize */
1691          FALSE,                 /* pc_relative */
1692          0,                     /* bitpos */
1693          complain_overflow_signed, /* complain_on_overflow */
1694          ppc64_elf_unhandled_reloc, /* special_function */
1695          "R_PPC64_GOT_TLSGD16", /* name */
1696          FALSE,                 /* partial_inplace */
1697          0,                     /* src_mask */
1698          0xffff,                /* dst_mask */
1699          FALSE),                /* pcrel_offset */
1700
1701   /* Like GOT_TLSGD16, but no overflow.  */
1702   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_dont, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16_LO", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1718          16,                    /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_signed, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_HI", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HA", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1747      with values (sym+add)@dtpmod and zero, and computes the offset to the
1748      first entry relative to the TOC base (r2).  */
1749   HOWTO (R_PPC64_GOT_TLSLD16,
1750          0,                     /* rightshift */
1751          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1752          16,                    /* bitsize */
1753          FALSE,                 /* pc_relative */
1754          0,                     /* bitpos */
1755          complain_overflow_signed, /* complain_on_overflow */
1756          ppc64_elf_unhandled_reloc, /* special_function */
1757          "R_PPC64_GOT_TLSLD16", /* name */
1758          FALSE,                 /* partial_inplace */
1759          0,                     /* src_mask */
1760          0xffff,                /* dst_mask */
1761          FALSE),                /* pcrel_offset */
1762
1763   /* Like GOT_TLSLD16, but no overflow.  */
1764   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_dont, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16_LO", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1780          16,                    /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_signed, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_HI", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HA", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1809      the offset to the entry relative to the TOC base (r2).  */
1810   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1811          0,                     /* rightshift */
1812          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1813          16,                    /* bitsize */
1814          FALSE,                 /* pc_relative */
1815          0,                     /* bitpos */
1816          complain_overflow_signed, /* complain_on_overflow */
1817          ppc64_elf_unhandled_reloc, /* special_function */
1818          "R_PPC64_GOT_DTPREL16_DS", /* name */
1819          FALSE,                 /* partial_inplace */
1820          0,                     /* src_mask */
1821          0xfffc,                /* dst_mask */
1822          FALSE),                /* pcrel_offset */
1823
1824   /* Like GOT_DTPREL16_DS, but no overflow.  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_dont, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1841          16,                    /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_signed, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_HI", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xffff,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HA", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1870      offset to the entry relative to the TOC base (r2).  */
1871   HOWTO (R_PPC64_GOT_TPREL16_DS,
1872          0,                     /* rightshift */
1873          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1874          16,                    /* bitsize */
1875          FALSE,                 /* pc_relative */
1876          0,                     /* bitpos */
1877          complain_overflow_signed, /* complain_on_overflow */
1878          ppc64_elf_unhandled_reloc, /* special_function */
1879          "R_PPC64_GOT_TPREL16_DS", /* name */
1880          FALSE,                 /* partial_inplace */
1881          0,                     /* src_mask */
1882          0xfffc,                /* dst_mask */
1883          FALSE),                /* pcrel_offset */
1884
1885   /* Like GOT_TPREL16_DS, but no overflow.  */
1886   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_dont, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_HI,
1902          16,                    /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_signed, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_HI", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xffff,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HA,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HA", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   HOWTO (R_PPC64_JMP_IREL,      /* type */
1931          0,                     /* rightshift */
1932          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1933          0,                     /* bitsize */
1934          FALSE,                 /* pc_relative */
1935          0,                     /* bitpos */
1936          complain_overflow_dont, /* complain_on_overflow */
1937          ppc64_elf_unhandled_reloc, /* special_function */
1938          "R_PPC64_JMP_IREL",    /* name */
1939          FALSE,                 /* partial_inplace */
1940          0,                     /* src_mask */
1941          0,                     /* dst_mask */
1942          FALSE),                /* pcrel_offset */
1943
1944   HOWTO (R_PPC64_IRELATIVE,     /* type */
1945          0,                     /* rightshift */
1946          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1947          64,                    /* bitsize */
1948          FALSE,                 /* pc_relative */
1949          0,                     /* bitpos */
1950          complain_overflow_dont, /* complain_on_overflow */
1951          bfd_elf_generic_reloc, /* special_function */
1952          "R_PPC64_IRELATIVE",   /* name */
1953          FALSE,                 /* partial_inplace */
1954          0,                     /* src_mask */
1955          ONES (64),             /* dst_mask */
1956          FALSE),                /* pcrel_offset */
1957
1958   /* A 16 bit relative relocation.  */
1959   HOWTO (R_PPC64_REL16,         /* type */
1960          0,                     /* rightshift */
1961          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1962          16,                    /* bitsize */
1963          TRUE,                  /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_signed, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_REL16",       /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          0xffff,                /* dst_mask */
1971          TRUE),                 /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation without overflow.  */
1974   HOWTO (R_PPC64_REL16_LO,      /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_dont,/* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16_LO",    /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* The high order 16 bits of a relative address.  */
1989   HOWTO (R_PPC64_REL16_HI,      /* type */
1990          16,                    /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_signed, /* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_HI",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address, plus 1 if the contents of
2004      the low 16 bits, treated as a signed number, is negative.  */
2005   HOWTO (R_PPC64_REL16_HA,      /* type */
2006          16,                    /* rightshift */
2007          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2008          16,                    /* bitsize */
2009          TRUE,                  /* pc_relative */
2010          0,                     /* bitpos */
2011          complain_overflow_signed, /* complain_on_overflow */
2012          ppc64_elf_ha_reloc,    /* special_function */
2013          "R_PPC64_REL16_HA",    /* name */
2014          FALSE,                 /* partial_inplace */
2015          0,                     /* src_mask */
2016          0xffff,                /* dst_mask */
2017          TRUE),                 /* pcrel_offset */
2018
2019   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2020   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          FALSE,                 /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_dont, /* complain_on_overflow */
2027          bfd_elf_generic_reloc, /* special_function */
2028          "R_PPC64_ADDR16_HIGH", /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          FALSE),                /* pcrel_offset */
2033
2034   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2035   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2036          16,                    /* rightshift */
2037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          FALSE,                 /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_dont, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_ADDR16_HIGHA",        /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0xffff,                /* dst_mask */
2047          FALSE),                /* pcrel_offset */
2048
2049   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2050   HOWTO (R_PPC64_DTPREL16_HIGH,
2051          16,                    /* rightshift */
2052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_dont, /* complain_on_overflow */
2057          ppc64_elf_unhandled_reloc, /* special_function */
2058          "R_PPC64_DTPREL16_HIGH", /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0xffff,                /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2065   HOWTO (R_PPC64_DTPREL16_HIGHA,
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          ppc64_elf_unhandled_reloc, /* special_function */
2073          "R_PPC64_DTPREL16_HIGHA", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2080   HOWTO (R_PPC64_TPREL16_HIGH,
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_unhandled_reloc, /* special_function */
2088          "R_PPC64_TPREL16_HIGH",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2095   HOWTO (R_PPC64_TPREL16_HIGHA,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_TPREL16_HIGHA",       /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like ADDR64, but use local entry point of function.  */
2110   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2111          0,                     /* rightshift */
2112          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2113          64,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          bfd_elf_generic_reloc, /* special_function */
2118          "R_PPC64_ADDR64_LOCAL", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          ONES (64),             /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* GNU extension to record C++ vtable hierarchy.  */
2125   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2126          0,                     /* rightshift */
2127          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          0,                     /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          NULL,                  /* special_function */
2133          "R_PPC64_GNU_VTINHERIT", /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0,                     /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* GNU extension to record C++ vtable member usage.  */
2140   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2141          0,                     /* rightshift */
2142          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          0,                     /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          NULL,                  /* special_function */
2148          "R_PPC64_GNU_VTENTRY", /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0,                     /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153 };
2154
2155 \f
2156 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2157    be done.  */
2158
2159 static void
2160 ppc_howto_init (void)
2161 {
2162   unsigned int i, type;
2163
2164   for (i = 0;
2165        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2166        i++)
2167     {
2168       type = ppc64_elf_howto_raw[i].type;
2169       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2170                           / sizeof (ppc64_elf_howto_table[0])));
2171       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2172     }
2173 }
2174
2175 static reloc_howto_type *
2176 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2177                              bfd_reloc_code_real_type code)
2178 {
2179   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2180
2181   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2182     /* Initialize howto table if needed.  */
2183     ppc_howto_init ();
2184
2185   switch (code)
2186     {
2187     default:
2188       return NULL;
2189
2190     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2191       break;
2192     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2193       break;
2194     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2195       break;
2196     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2197       break;
2198     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2199       break;
2200     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2201       break;
2202     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2203       break;
2204     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2205       break;
2206     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2207       break;
2208     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2209       break;
2210     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2211       break;
2212     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2213       break;
2214     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2215       break;
2216     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2217       break;
2218     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2219       break;
2220     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2221       break;
2222     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2223       break;
2224     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2225       break;
2226     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2227       break;
2228     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2229       break;
2230     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2231       break;
2232     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2233       break;
2234     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2235       break;
2236     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2237       break;
2238     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2239       break;
2240     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2241       break;
2242     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2243       break;
2244     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2245       break;
2246     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2247       break;
2248     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2249       break;
2250     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2251       break;
2252     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2253       break;
2254     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2255       break;
2256     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2257       break;
2258     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2259       break;
2260     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2261       break;
2262     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2263       break;
2264     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2265       break;
2266     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2267       break;
2268     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2269       break;
2270     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2271       break;
2272     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2273       break;
2274     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2275       break;
2276     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2279       break;
2280     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2281       break;
2282     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2285       break;
2286     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2287       break;
2288     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2289       break;
2290     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2291       break;
2292     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2293       break;
2294     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2295       break;
2296     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2297       break;
2298     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2299       break;
2300     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2301       break;
2302     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2303       break;
2304     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2305       break;
2306     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2307       break;
2308     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2309       break;
2310     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2311       break;
2312     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2313       break;
2314     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2315       break;
2316     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2317       break;
2318     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2319       break;
2320     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2321       break;
2322     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2323       break;
2324     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2325       break;
2326     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2327       break;
2328     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2329       break;
2330     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2331       break;
2332     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2333       break;
2334     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2335       break;
2336     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2337       break;
2338     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2339       break;
2340     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2341       break;
2342     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2343       break;
2344     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2345       break;
2346     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2347       break;
2348     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2349       break;
2350     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2351       break;
2352     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2353       break;
2354     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2355       break;
2356     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2357       break;
2358     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2359       break;
2360     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2361       break;
2362     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2363       break;
2364     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2365       break;
2366     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2367       break;
2368     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2369       break;
2370     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2371       break;
2372     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2373       break;
2374     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2375       break;
2376     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2377       break;
2378     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2379       break;
2380     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2381       break;
2382     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2383       break;
2384     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2385       break;
2386     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2387       break;
2388     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2389       break;
2390     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2391       break;
2392     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2393       break;
2394     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2395       break;
2396     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2397       break;
2398     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2399       break;
2400     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2401       break;
2402     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2403       break;
2404     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2405       break;
2406     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2407       break;
2408     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2409       break;
2410     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2411       break;
2412     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2413       break;
2414     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2415       break;
2416     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2417       break;
2418     }
2419
2420   return ppc64_elf_howto_table[r];
2421 };
2422
2423 static reloc_howto_type *
2424 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2425                              const char *r_name)
2426 {
2427   unsigned int i;
2428
2429   for (i = 0;
2430        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2431        i++)
2432     if (ppc64_elf_howto_raw[i].name != NULL
2433         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2434       return &ppc64_elf_howto_raw[i];
2435
2436   return NULL;
2437 }
2438
2439 /* Set the howto pointer for a PowerPC ELF reloc.  */
2440
2441 static void
2442 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2443                          Elf_Internal_Rela *dst)
2444 {
2445   unsigned int type;
2446
2447   /* Initialize howto table if needed.  */
2448   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2449     ppc_howto_init ();
2450
2451   type = ELF64_R_TYPE (dst->r_info);
2452   if (type >= (sizeof (ppc64_elf_howto_table)
2453                / sizeof (ppc64_elf_howto_table[0])))
2454     {
2455       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2456                              abfd, (int) type);
2457       type = R_PPC64_NONE;
2458     }
2459   cache_ptr->howto = ppc64_elf_howto_table[type];
2460 }
2461
2462 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2463
2464 static bfd_reloc_status_type
2465 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2466                     void *data, asection *input_section,
2467                     bfd *output_bfd, char **error_message)
2468 {
2469   /* If this is a relocatable link (output_bfd test tells us), just
2470      call the generic function.  Any adjustment will be done at final
2471      link time.  */
2472   if (output_bfd != NULL)
2473     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2474                                   input_section, output_bfd, error_message);
2475
2476   /* Adjust the addend for sign extension of the low 16 bits.
2477      We won't actually be using the low 16 bits, so trashing them
2478      doesn't matter.  */
2479   reloc_entry->addend += 0x8000;
2480   return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485                         void *data, asection *input_section,
2486                         bfd *output_bfd, char **error_message)
2487 {
2488   if (output_bfd != NULL)
2489     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2490                                   input_section, output_bfd, error_message);
2491
2492   if (strcmp (symbol->section->name, ".opd") == 0
2493       && (symbol->section->owner->flags & DYNAMIC) == 0)
2494     {
2495       bfd_vma dest = opd_entry_value (symbol->section,
2496                                       symbol->value + reloc_entry->addend,
2497                                       NULL, NULL, FALSE);
2498       if (dest != (bfd_vma) -1)
2499         reloc_entry->addend = dest - (symbol->value
2500                                       + symbol->section->output_section->vma
2501                                       + symbol->section->output_offset);
2502     }
2503   else
2504     {
2505       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2506
2507       if (symbol->section->owner != abfd
2508           && abiversion (symbol->section->owner) >= 2)
2509         {
2510           unsigned int i;
2511
2512           for (i = 0; i < symbol->section->owner->symcount; ++i)
2513             {
2514               asymbol *symdef = symbol->section->owner->outsymbols[i];
2515
2516               if (strcmp (symdef->name, symbol->name) == 0)
2517                 {
2518                   elfsym = (elf_symbol_type *) symdef;
2519                   break;
2520                 }
2521             }
2522         }
2523       reloc_entry->addend
2524         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2525     }
2526   return bfd_reloc_continue;
2527 }
2528
2529 static bfd_reloc_status_type
2530 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2531                          void *data, asection *input_section,
2532                          bfd *output_bfd, char **error_message)
2533 {
2534   long insn;
2535   enum elf_ppc64_reloc_type r_type;
2536   bfd_size_type octets;
2537   /* Assume 'at' branch hints.  */
2538   bfd_boolean is_isa_v2 = TRUE;
2539
2540   /* If this is a relocatable link (output_bfd test tells us), just
2541      call the generic function.  Any adjustment will be done at final
2542      link time.  */
2543   if (output_bfd != NULL)
2544     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2545                                   input_section, output_bfd, error_message);
2546
2547   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2548   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2549   insn &= ~(0x01 << 21);
2550   r_type = reloc_entry->howto->type;
2551   if (r_type == R_PPC64_ADDR14_BRTAKEN
2552       || r_type == R_PPC64_REL14_BRTAKEN)
2553     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2554
2555   if (is_isa_v2)
2556     {
2557       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2558          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2559          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2560       if ((insn & (0x14 << 21)) == (0x04 << 21))
2561         insn |= 0x02 << 21;
2562       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2563         insn |= 0x08 << 21;
2564       else
2565         goto out;
2566     }
2567   else
2568     {
2569       bfd_vma target = 0;
2570       bfd_vma from;
2571
2572       if (!bfd_is_com_section (symbol->section))
2573         target = symbol->value;
2574       target += symbol->section->output_section->vma;
2575       target += symbol->section->output_offset;
2576       target += reloc_entry->addend;
2577
2578       from = (reloc_entry->address
2579               + input_section->output_offset
2580               + input_section->output_section->vma);
2581
2582       /* Invert 'y' bit if not the default.  */
2583       if ((bfd_signed_vma) (target - from) < 0)
2584         insn ^= 0x01 << 21;
2585     }
2586   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2587  out:
2588   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2589                                  input_section, output_bfd, error_message);
2590 }
2591
2592 static bfd_reloc_status_type
2593 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2594                          void *data, asection *input_section,
2595                          bfd *output_bfd, char **error_message)
2596 {
2597   /* If this is a relocatable link (output_bfd test tells us), just
2598      call the generic function.  Any adjustment will be done at final
2599      link time.  */
2600   if (output_bfd != NULL)
2601     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2602                                   input_section, output_bfd, error_message);
2603
2604   /* Subtract the symbol section base address.  */
2605   reloc_entry->addend -= symbol->section->output_section->vma;
2606   return bfd_reloc_continue;
2607 }
2608
2609 static bfd_reloc_status_type
2610 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2611                             void *data, asection *input_section,
2612                             bfd *output_bfd, char **error_message)
2613 {
2614   /* If this is a relocatable link (output_bfd test tells us), just
2615      call the generic function.  Any adjustment will be done at final
2616      link time.  */
2617   if (output_bfd != NULL)
2618     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2619                                   input_section, output_bfd, error_message);
2620
2621   /* Subtract the symbol section base address.  */
2622   reloc_entry->addend -= symbol->section->output_section->vma;
2623
2624   /* Adjust the addend for sign extension of the low 16 bits.  */
2625   reloc_entry->addend += 0x8000;
2626   return bfd_reloc_continue;
2627 }
2628
2629 static bfd_reloc_status_type
2630 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2631                      void *data, asection *input_section,
2632                      bfd *output_bfd, char **error_message)
2633 {
2634   bfd_vma TOCstart;
2635
2636   /* If this is a relocatable link (output_bfd test tells us), just
2637      call the generic function.  Any adjustment will be done at final
2638      link time.  */
2639   if (output_bfd != NULL)
2640     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2641                                   input_section, output_bfd, error_message);
2642
2643   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2644   if (TOCstart == 0)
2645     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2646
2647   /* Subtract the TOC base address.  */
2648   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2649   return bfd_reloc_continue;
2650 }
2651
2652 static bfd_reloc_status_type
2653 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2654                         void *data, asection *input_section,
2655                         bfd *output_bfd, char **error_message)
2656 {
2657   bfd_vma TOCstart;
2658
2659   /* If this is a relocatable link (output_bfd test tells us), just
2660      call the generic function.  Any adjustment will be done at final
2661      link time.  */
2662   if (output_bfd != NULL)
2663     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2664                                   input_section, output_bfd, error_message);
2665
2666   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2667   if (TOCstart == 0)
2668     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2669
2670   /* Subtract the TOC base address.  */
2671   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2672
2673   /* Adjust the addend for sign extension of the low 16 bits.  */
2674   reloc_entry->addend += 0x8000;
2675   return bfd_reloc_continue;
2676 }
2677
2678 static bfd_reloc_status_type
2679 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2680                        void *data, asection *input_section,
2681                        bfd *output_bfd, char **error_message)
2682 {
2683   bfd_vma TOCstart;
2684   bfd_size_type octets;
2685
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2694   if (TOCstart == 0)
2695     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2696
2697   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2698   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2699   return bfd_reloc_ok;
2700 }
2701
2702 static bfd_reloc_status_type
2703 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2704                            void *data, asection *input_section,
2705                            bfd *output_bfd, char **error_message)
2706 {
2707   /* If this is a relocatable link (output_bfd test tells us), just
2708      call the generic function.  Any adjustment will be done at final
2709      link time.  */
2710   if (output_bfd != NULL)
2711     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2712                                   input_section, output_bfd, error_message);
2713
2714   if (error_message != NULL)
2715     {
2716       static char buf[60];
2717       sprintf (buf, "generic linker can't handle %s",
2718                reloc_entry->howto->name);
2719       *error_message = buf;
2720     }
2721   return bfd_reloc_dangerous;
2722 }
2723
2724 /* Track GOT entries needed for a given symbol.  We might need more
2725    than one got entry per symbol.  */
2726 struct got_entry
2727 {
2728   struct got_entry *next;
2729
2730   /* The symbol addend that we'll be placing in the GOT.  */
2731   bfd_vma addend;
2732
2733   /* Unlike other ELF targets, we use separate GOT entries for the same
2734      symbol referenced from different input files.  This is to support
2735      automatic multiple TOC/GOT sections, where the TOC base can vary
2736      from one input file to another.  After partitioning into TOC groups
2737      we merge entries within the group.
2738
2739      Point to the BFD owning this GOT entry.  */
2740   bfd *owner;
2741
2742   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2743      TLS_TPREL or TLS_DTPREL for tls entries.  */
2744   unsigned char tls_type;
2745
2746   /* Non-zero if got.ent points to real entry.  */
2747   unsigned char is_indirect;
2748
2749   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2750   union
2751     {
2752       bfd_signed_vma refcount;
2753       bfd_vma offset;
2754       struct got_entry *ent;
2755     } got;
2756 };
2757
2758 /* The same for PLT.  */
2759 struct plt_entry
2760 {
2761   struct plt_entry *next;
2762
2763   bfd_vma addend;
2764
2765   union
2766     {
2767       bfd_signed_vma refcount;
2768       bfd_vma offset;
2769     } plt;
2770 };
2771
2772 struct ppc64_elf_obj_tdata
2773 {
2774   struct elf_obj_tdata elf;
2775
2776   /* Shortcuts to dynamic linker sections.  */
2777   asection *got;
2778   asection *relgot;
2779
2780   /* Used during garbage collection.  We attach global symbols defined
2781      on removed .opd entries to this section so that the sym is removed.  */
2782   asection *deleted_section;
2783
2784   /* TLS local dynamic got entry handling.  Support for multiple GOT
2785      sections means we potentially need one of these for each input bfd.  */
2786   struct got_entry tlsld_got;
2787
2788   union {
2789     /* A copy of relocs before they are modified for --emit-relocs.  */
2790     Elf_Internal_Rela *relocs;
2791
2792     /* Section contents.  */
2793     bfd_byte *contents;
2794   } opd;
2795
2796   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2797      the reloc to be in the range -32768 to 32767.  */
2798   unsigned int has_small_toc_reloc : 1;
2799
2800   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2801      instruction not one we handle.  */
2802   unsigned int unexpected_toc_insn : 1;
2803 };
2804
2805 #define ppc64_elf_tdata(bfd) \
2806   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2807
2808 #define ppc64_tlsld_got(bfd) \
2809   (&ppc64_elf_tdata (bfd)->tlsld_got)
2810
2811 #define is_ppc64_elf(bfd) \
2812   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2813    && elf_object_id (bfd) == PPC64_ELF_DATA)
2814
2815 /* Override the generic function because we store some extras.  */
2816
2817 static bfd_boolean
2818 ppc64_elf_mkobject (bfd *abfd)
2819 {
2820   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2821                                   PPC64_ELF_DATA);
2822 }
2823
2824 /* Fix bad default arch selected for a 64 bit input bfd when the
2825    default is 32 bit.  */
2826
2827 static bfd_boolean
2828 ppc64_elf_object_p (bfd *abfd)
2829 {
2830   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2831     {
2832       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2833
2834       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2835         {
2836           /* Relies on arch after 32 bit default being 64 bit default.  */
2837           abfd->arch_info = abfd->arch_info->next;
2838           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2839         }
2840     }
2841   return TRUE;
2842 }
2843
2844 /* Support for core dump NOTE sections.  */
2845
2846 static bfd_boolean
2847 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2848 {
2849   size_t offset, size;
2850
2851   if (note->descsz != 504)
2852     return FALSE;
2853
2854   /* pr_cursig */
2855   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2856
2857   /* pr_pid */
2858   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2859
2860   /* pr_reg */
2861   offset = 112;
2862   size = 384;
2863
2864   /* Make a ".reg/999" section.  */
2865   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2866                                           size, note->descpos + offset);
2867 }
2868
2869 static bfd_boolean
2870 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2871 {
2872   if (note->descsz != 136)
2873     return FALSE;
2874
2875   elf_tdata (abfd)->core->pid
2876     = bfd_get_32 (abfd, note->descdata + 24);
2877   elf_tdata (abfd)->core->program
2878     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2879   elf_tdata (abfd)->core->command
2880     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2881
2882   return TRUE;
2883 }
2884
2885 static char *
2886 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2887                            ...)
2888 {
2889   switch (note_type)
2890     {
2891     default:
2892       return NULL;
2893
2894     case NT_PRPSINFO:
2895       {
2896         char data[136];
2897         va_list ap;
2898
2899         va_start (ap, note_type);
2900         memset (data, 0, sizeof (data));
2901         strncpy (data + 40, va_arg (ap, const char *), 16);
2902         strncpy (data + 56, va_arg (ap, const char *), 80);
2903         va_end (ap);
2904         return elfcore_write_note (abfd, buf, bufsiz,
2905                                    "CORE", note_type, data, sizeof (data));
2906       }
2907
2908     case NT_PRSTATUS:
2909       {
2910         char data[504];
2911         va_list ap;
2912         long pid;
2913         int cursig;
2914         const void *greg;
2915
2916         va_start (ap, note_type);
2917         memset (data, 0, 112);
2918         pid = va_arg (ap, long);
2919         bfd_put_32 (abfd, pid, data + 32);
2920         cursig = va_arg (ap, int);
2921         bfd_put_16 (abfd, cursig, data + 12);
2922         greg = va_arg (ap, const void *);
2923         memcpy (data + 112, greg, 384);
2924         memset (data + 496, 0, 8);
2925         va_end (ap);
2926         return elfcore_write_note (abfd, buf, bufsiz,
2927                                    "CORE", note_type, data, sizeof (data));
2928       }
2929     }
2930 }
2931
2932 /* Add extra PPC sections.  */
2933
2934 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2935 {
2936   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2937   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2938   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2939   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2940   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2941   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2942   { NULL,                     0,  0, 0,            0 }
2943 };
2944
2945 enum _ppc64_sec_type {
2946   sec_normal = 0,
2947   sec_opd = 1,
2948   sec_toc = 2
2949 };
2950
2951 struct _ppc64_elf_section_data
2952 {
2953   struct bfd_elf_section_data elf;
2954
2955   union
2956   {
2957     /* An array with one entry for each opd function descriptor.  */
2958     struct _opd_sec_data
2959     {
2960       /* Points to the function code section for local opd entries.  */
2961       asection **func_sec;
2962
2963       /* After editing .opd, adjust references to opd local syms.  */
2964       long *adjust;
2965     } opd;
2966
2967     /* An array for toc sections, indexed by offset/8.  */
2968     struct _toc_sec_data
2969     {
2970       /* Specifies the relocation symbol index used at a given toc offset.  */
2971       unsigned *symndx;
2972
2973       /* And the relocation addend.  */
2974       bfd_vma *add;
2975     } toc;
2976   } u;
2977
2978   enum _ppc64_sec_type sec_type:2;
2979
2980   /* Flag set when small branches are detected.  Used to
2981      select suitable defaults for the stub group size.  */
2982   unsigned int has_14bit_branch:1;
2983 };
2984
2985 #define ppc64_elf_section_data(sec) \
2986   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2987
2988 static bfd_boolean
2989 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2990 {
2991   if (!sec->used_by_bfd)
2992     {
2993       struct _ppc64_elf_section_data *sdata;
2994       bfd_size_type amt = sizeof (*sdata);
2995
2996       sdata = bfd_zalloc (abfd, amt);
2997       if (sdata == NULL)
2998         return FALSE;
2999       sec->used_by_bfd = sdata;
3000     }
3001
3002   return _bfd_elf_new_section_hook (abfd, sec);
3003 }
3004
3005 static struct _opd_sec_data *
3006 get_opd_info (asection * sec)
3007 {
3008   if (sec != NULL
3009       && ppc64_elf_section_data (sec) != NULL
3010       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3011     return &ppc64_elf_section_data (sec)->u.opd;
3012   return NULL;
3013 }
3014 \f
3015 /* Parameters for the qsort hook.  */
3016 static bfd_boolean synthetic_relocatable;
3017
3018 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3019
3020 static int
3021 compare_symbols (const void *ap, const void *bp)
3022 {
3023   const asymbol *a = * (const asymbol **) ap;
3024   const asymbol *b = * (const asymbol **) bp;
3025
3026   /* Section symbols first.  */
3027   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3028     return -1;
3029   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3030     return 1;
3031
3032   /* then .opd symbols.  */
3033   if (strcmp (a->section->name, ".opd") == 0
3034       && strcmp (b->section->name, ".opd") != 0)
3035     return -1;
3036   if (strcmp (a->section->name, ".opd") != 0
3037       && strcmp (b->section->name, ".opd") == 0)
3038     return 1;
3039
3040   /* then other code symbols.  */
3041   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3042       == (SEC_CODE | SEC_ALLOC)
3043       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3044          != (SEC_CODE | SEC_ALLOC))
3045     return -1;
3046
3047   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3048       != (SEC_CODE | SEC_ALLOC)
3049       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3050          == (SEC_CODE | SEC_ALLOC))
3051     return 1;
3052
3053   if (synthetic_relocatable)
3054     {
3055       if (a->section->id < b->section->id)
3056         return -1;
3057
3058       if (a->section->id > b->section->id)
3059         return 1;
3060     }
3061
3062   if (a->value + a->section->vma < b->value + b->section->vma)
3063     return -1;
3064
3065   if (a->value + a->section->vma > b->value + b->section->vma)
3066     return 1;
3067
3068   /* For syms with the same value, prefer strong dynamic global function
3069      syms over other syms.  */
3070   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3071     return -1;
3072
3073   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3074     return 1;
3075
3076   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3077     return -1;
3078
3079   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3080     return 1;
3081
3082   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3083     return -1;
3084
3085   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3086     return 1;
3087
3088   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3089     return -1;
3090
3091   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3092     return 1;
3093
3094   return 0;
3095 }
3096
3097 /* Search SYMS for a symbol of the given VALUE.  */
3098
3099 static asymbol *
3100 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3101 {
3102   long mid;
3103
3104   if (id == -1)
3105     {
3106       while (lo < hi)
3107         {
3108           mid = (lo + hi) >> 1;
3109           if (syms[mid]->value + syms[mid]->section->vma < value)
3110             lo = mid + 1;
3111           else if (syms[mid]->value + syms[mid]->section->vma > value)
3112             hi = mid;
3113           else
3114             return syms[mid];
3115         }
3116     }
3117   else
3118     {
3119       while (lo < hi)
3120         {
3121           mid = (lo + hi) >> 1;
3122           if (syms[mid]->section->id < id)
3123             lo = mid + 1;
3124           else if (syms[mid]->section->id > id)
3125             hi = mid;
3126           else if (syms[mid]->value < value)
3127             lo = mid + 1;
3128           else if (syms[mid]->value > value)
3129             hi = mid;
3130           else
3131             return syms[mid];
3132         }
3133     }
3134   return NULL;
3135 }
3136
3137 static bfd_boolean
3138 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3139 {
3140   bfd_vma vma = *(bfd_vma *) ptr;
3141   return ((section->flags & SEC_ALLOC) != 0
3142           && section->vma <= vma
3143           && vma < section->vma + section->size);
3144 }
3145
3146 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3147    entry syms.  Also generate @plt symbols for the glink branch table.  */
3148
3149 static long
3150 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3151                                 long static_count, asymbol **static_syms,
3152                                 long dyn_count, asymbol **dyn_syms,
3153                                 asymbol **ret)
3154 {
3155   asymbol *s;
3156   long i;
3157   long count;
3158   char *names;
3159   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3160   asection *opd = NULL;
3161   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3162   asymbol **syms;
3163   int abi = abiversion (abfd);
3164
3165   *ret = NULL;
3166
3167   if (abi < 2)
3168     {
3169       opd = bfd_get_section_by_name (abfd, ".opd");
3170       if (opd == NULL && abi == 1)
3171         return 0;
3172     }
3173
3174   symcount = static_count;
3175   if (!relocatable)
3176     symcount += dyn_count;
3177   if (symcount == 0)
3178     return 0;
3179
3180   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3181   if (syms == NULL)
3182     return -1;
3183
3184   if (!relocatable && static_count != 0 && dyn_count != 0)
3185     {
3186       /* Use both symbol tables.  */
3187       memcpy (syms, static_syms, static_count * sizeof (*syms));
3188       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3189     }
3190   else if (!relocatable && static_count == 0)
3191     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3192   else
3193     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3194
3195   synthetic_relocatable = relocatable;
3196   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3197
3198   if (!relocatable && symcount > 1)
3199     {
3200       long j;
3201       /* Trim duplicate syms, since we may have merged the normal and
3202          dynamic symbols.  Actually, we only care about syms that have
3203          different values, so trim any with the same value.  */
3204       for (i = 1, j = 1; i < symcount; ++i)
3205         if (syms[i - 1]->value + syms[i - 1]->section->vma
3206             != syms[i]->value + syms[i]->section->vma)
3207           syms[j++] = syms[i];
3208       symcount = j;
3209     }
3210
3211   i = 0;
3212   if (strcmp (syms[i]->section->name, ".opd") == 0)
3213     ++i;
3214   codesecsym = i;
3215
3216   for (; i < symcount; ++i)
3217     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3218          != (SEC_CODE | SEC_ALLOC))
3219         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3220       break;
3221   codesecsymend = i;
3222
3223   for (; i < symcount; ++i)
3224     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3225       break;
3226   secsymend = i;
3227
3228   for (; i < symcount; ++i)
3229     if (strcmp (syms[i]->section->name, ".opd") != 0)
3230       break;
3231   opdsymend = i;
3232
3233   for (; i < symcount; ++i)
3234     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3235         != (SEC_CODE | SEC_ALLOC))
3236       break;
3237   symcount = i;
3238
3239   count = 0;
3240
3241   if (relocatable)
3242     {
3243       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3244       arelent *r;
3245       size_t size;
3246       long relcount;
3247
3248       if (opdsymend == secsymend)
3249         goto done;
3250
3251       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3252       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3253       if (relcount == 0)
3254         goto done;
3255
3256       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3257         {
3258           count = -1;
3259           goto done;
3260         }
3261
3262       size = 0;
3263       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3264         {
3265           asymbol *sym;
3266
3267           while (r < opd->relocation + relcount
3268                  && r->address < syms[i]->value + opd->vma)
3269             ++r;
3270
3271           if (r == opd->relocation + relcount)
3272             break;
3273
3274           if (r->address != syms[i]->value + opd->vma)
3275             continue;
3276
3277           if (r->howto->type != R_PPC64_ADDR64)
3278             continue;
3279
3280           sym = *r->sym_ptr_ptr;
3281           if (!sym_exists_at (syms, opdsymend, symcount,
3282                               sym->section->id, sym->value + r->addend))
3283             {
3284               ++count;
3285               size += sizeof (asymbol);
3286               size += strlen (syms[i]->name) + 2;
3287             }
3288         }
3289
3290       s = *ret = bfd_malloc (size);
3291       if (s == NULL)
3292         {
3293           count = -1;
3294           goto done;
3295         }
3296
3297       names = (char *) (s + count);
3298
3299       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3300         {
3301           asymbol *sym;
3302
3303           while (r < opd->relocation + relcount
3304                  && r->address < syms[i]->value + opd->vma)
3305             ++r;
3306
3307           if (r == opd->relocation + relcount)
3308             break;
3309
3310           if (r->address != syms[i]->value + opd->vma)
3311             continue;
3312
3313           if (r->howto->type != R_PPC64_ADDR64)
3314             continue;
3315
3316           sym = *r->sym_ptr_ptr;
3317           if (!sym_exists_at (syms, opdsymend, symcount,
3318                               sym->section->id, sym->value + r->addend))
3319             {
3320               size_t len;
3321
3322               *s = *syms[i];
3323               s->flags |= BSF_SYNTHETIC;
3324               s->section = sym->section;
3325               s->value = sym->value + r->addend;
3326               s->name = names;
3327               *names++ = '.';
3328               len = strlen (syms[i]->name);
3329               memcpy (names, syms[i]->name, len + 1);
3330               names += len + 1;
3331               /* Have udata.p point back to the original symbol this
3332                  synthetic symbol was derived from.  */
3333               s->udata.p = syms[i];
3334               s++;
3335             }
3336         }
3337     }
3338   else
3339     {
3340       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3341       bfd_byte *contents = NULL;
3342       size_t size;
3343       long plt_count = 0;
3344       bfd_vma glink_vma = 0, resolv_vma = 0;
3345       asection *dynamic, *glink = NULL, *relplt = NULL;
3346       arelent *p;
3347
3348       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3349         {
3350         free_contents_and_exit:
3351           if (contents)
3352             free (contents);
3353           count = -1;
3354           goto done;
3355         }
3356
3357       size = 0;
3358       for (i = secsymend; i < opdsymend; ++i)
3359         {
3360           bfd_vma ent;
3361
3362           /* Ignore bogus symbols.  */
3363           if (syms[i]->value > opd->size - 8)
3364             continue;
3365
3366           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3367           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3368             {
3369               ++count;
3370               size += sizeof (asymbol);
3371               size += strlen (syms[i]->name) + 2;
3372             }
3373         }
3374
3375       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3376       if (dyn_count != 0
3377           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3378         {
3379           bfd_byte *dynbuf, *extdyn, *extdynend;
3380           size_t extdynsize;
3381           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3382
3383           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3384             goto free_contents_and_exit;
3385
3386           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3387           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3388
3389           extdyn = dynbuf;
3390           extdynend = extdyn + dynamic->size;
3391           for (; extdyn < extdynend; extdyn += extdynsize)
3392             {
3393               Elf_Internal_Dyn dyn;
3394               (*swap_dyn_in) (abfd, extdyn, &dyn);
3395
3396               if (dyn.d_tag == DT_NULL)
3397                 break;
3398
3399               if (dyn.d_tag == DT_PPC64_GLINK)
3400                 {
3401                   /* The first glink stub starts at offset 32; see
3402                      comment in ppc64_elf_finish_dynamic_sections. */
3403                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3404                   /* The .glink section usually does not survive the final
3405                      link; search for the section (usually .text) where the
3406                      glink stubs now reside.  */
3407                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3408                                                 &glink_vma);
3409                   break;
3410                 }
3411             }
3412
3413           free (dynbuf);
3414         }
3415
3416       if (glink != NULL)
3417         {
3418           /* Determine __glink trampoline by reading the relative branch
3419              from the first glink stub.  */
3420           bfd_byte buf[4];
3421           unsigned int off = 0;
3422
3423           while (bfd_get_section_contents (abfd, glink, buf,
3424                                            glink_vma + off - glink->vma, 4))
3425             {
3426               unsigned int insn = bfd_get_32 (abfd, buf);
3427               insn ^= B_DOT;
3428               if ((insn & ~0x3fffffc) == 0)
3429                 {
3430                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3431                   break;
3432                 }
3433               off += 4;
3434               if (off > 4)
3435                 break;
3436             }
3437
3438           if (resolv_vma)
3439             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3440
3441           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3442           if (relplt != NULL)
3443             {
3444               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3445               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3446                 goto free_contents_and_exit;
3447
3448               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3449               size += plt_count * sizeof (asymbol);
3450
3451               p = relplt->relocation;
3452               for (i = 0; i < plt_count; i++, p++)
3453                 {
3454                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3455                   if (p->addend != 0)
3456                     size += sizeof ("+0x") - 1 + 16;
3457                 }
3458             }
3459         }
3460
3461       s = *ret = bfd_malloc (size);
3462       if (s == NULL)
3463         goto free_contents_and_exit;
3464
3465       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3466
3467       for (i = secsymend; i < opdsymend; ++i)
3468         {
3469           bfd_vma ent;
3470
3471           if (syms[i]->value > opd->size - 8)
3472             continue;
3473
3474           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476             {
3477               long lo, hi;
3478               size_t len;
3479               asection *sec = abfd->sections;
3480
3481               *s = *syms[i];
3482               lo = codesecsym;
3483               hi = codesecsymend;
3484               while (lo < hi)
3485                 {
3486                   long mid = (lo + hi) >> 1;
3487                   if (syms[mid]->section->vma < ent)
3488                     lo = mid + 1;
3489                   else if (syms[mid]->section->vma > ent)
3490                     hi = mid;
3491                   else
3492                     {
3493                       sec = syms[mid]->section;
3494                       break;
3495                     }
3496                 }
3497
3498               if (lo >= hi && lo > codesecsym)
3499                 sec = syms[lo - 1]->section;
3500
3501               for (; sec != NULL; sec = sec->next)
3502                 {
3503                   if (sec->vma > ent)
3504                     break;
3505                   /* SEC_LOAD may not be set if SEC is from a separate debug
3506                      info file.  */
3507                   if ((sec->flags & SEC_ALLOC) == 0)
3508                     break;
3509                   if ((sec->flags & SEC_CODE) != 0)
3510                     s->section = sec;
3511                 }
3512               s->flags |= BSF_SYNTHETIC;
3513               s->value = ent - s->section->vma;
3514               s->name = names;
3515               *names++ = '.';
3516               len = strlen (syms[i]->name);
3517               memcpy (names, syms[i]->name, len + 1);
3518               names += len + 1;
3519               /* Have udata.p point back to the original symbol this
3520                  synthetic symbol was derived from.  */
3521               s->udata.p = syms[i];
3522               s++;
3523             }
3524         }
3525       free (contents);
3526
3527       if (glink != NULL && relplt != NULL)
3528         {
3529           if (resolv_vma)
3530             {
3531               /* Add a symbol for the main glink trampoline.  */
3532               memset (s, 0, sizeof *s);
3533               s->the_bfd = abfd;
3534               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3535               s->section = glink;
3536               s->value = resolv_vma - glink->vma;
3537               s->name = names;
3538               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3539               names += sizeof ("__glink_PLTresolve");
3540               s++;
3541               count++;
3542             }
3543
3544           /* FIXME: It would be very much nicer to put sym@plt on the
3545              stub rather than on the glink branch table entry.  The
3546              objdump disassembler would then use a sensible symbol
3547              name on plt calls.  The difficulty in doing so is
3548              a) finding the stubs, and,
3549              b) matching stubs against plt entries, and,
3550              c) there can be multiple stubs for a given plt entry.
3551
3552              Solving (a) could be done by code scanning, but older
3553              ppc64 binaries used different stubs to current code.
3554              (b) is the tricky one since you need to known the toc
3555              pointer for at least one function that uses a pic stub to
3556              be able to calculate the plt address referenced.
3557              (c) means gdb would need to set multiple breakpoints (or
3558              find the glink branch itself) when setting breakpoints
3559              for pending shared library loads.  */
3560           p = relplt->relocation;
3561           for (i = 0; i < plt_count; i++, p++)
3562             {
3563               size_t len;
3564
3565               *s = **p->sym_ptr_ptr;
3566               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3567                  we are defining a symbol, ensure one of them is set.  */
3568               if ((s->flags & BSF_LOCAL) == 0)
3569                 s->flags |= BSF_GLOBAL;
3570               s->flags |= BSF_SYNTHETIC;
3571               s->section = glink;
3572               s->value = glink_vma - glink->vma;
3573               s->name = names;
3574               s->udata.p = NULL;
3575               len = strlen ((*p->sym_ptr_ptr)->name);
3576               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3577               names += len;
3578               if (p->addend != 0)
3579                 {
3580                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3581                   names += sizeof ("+0x") - 1;
3582                   bfd_sprintf_vma (abfd, names, p->addend);
3583                   names += strlen (names);
3584                 }
3585               memcpy (names, "@plt", sizeof ("@plt"));
3586               names += sizeof ("@plt");
3587               s++;
3588               if (abi < 2)
3589                 {
3590                   glink_vma += 8;
3591                   if (i >= 0x8000)
3592                     glink_vma += 4;
3593                 }
3594               else
3595                 glink_vma += 4;
3596             }
3597           count += plt_count;
3598         }
3599     }
3600
3601  done:
3602   free (syms);
3603   return count;
3604 }
3605 \f
3606 /* The following functions are specific to the ELF linker, while
3607    functions above are used generally.  Those named ppc64_elf_* are
3608    called by the main ELF linker code.  They appear in this file more
3609    or less in the order in which they are called.  eg.
3610    ppc64_elf_check_relocs is called early in the link process,
3611    ppc64_elf_finish_dynamic_sections is one of the last functions
3612    called.
3613
3614    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3615    functions have both a function code symbol and a function descriptor
3616    symbol.  A call to foo in a relocatable object file looks like:
3617
3618    .            .text
3619    .    x:
3620    .            bl      .foo
3621    .            nop
3622
3623    The function definition in another object file might be:
3624
3625    .            .section .opd
3626    .    foo:    .quad   .foo
3627    .            .quad   .TOC.@tocbase
3628    .            .quad   0
3629    .
3630    .            .text
3631    .    .foo:   blr
3632
3633    When the linker resolves the call during a static link, the branch
3634    unsurprisingly just goes to .foo and the .opd information is unused.
3635    If the function definition is in a shared library, things are a little
3636    different:  The call goes via a plt call stub, the opd information gets
3637    copied to the plt, and the linker patches the nop.
3638
3639    .    x:
3640    .            bl      .foo_stub
3641    .            ld      2,40(1)
3642    .
3643    .
3644    .    .foo_stub:
3645    .            std     2,40(1)                 # in practice, the call stub
3646    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3647    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3648    .            ld      12,0(11)
3649    .            ld      2,8(11)
3650    .            mtctr   12
3651    .            ld      11,16(11)
3652    .            bctr
3653    .
3654    .            .section .plt
3655    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3656
3657    The "reloc ()" notation is supposed to indicate that the linker emits
3658    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3659    copying.
3660
3661    What are the difficulties here?  Well, firstly, the relocations
3662    examined by the linker in check_relocs are against the function code
3663    sym .foo, while the dynamic relocation in the plt is emitted against
3664    the function descriptor symbol, foo.  Somewhere along the line, we need
3665    to carefully copy dynamic link information from one symbol to the other.
3666    Secondly, the generic part of the elf linker will make .foo a dynamic
3667    symbol as is normal for most other backends.  We need foo dynamic
3668    instead, at least for an application final link.  However, when
3669    creating a shared library containing foo, we need to have both symbols
3670    dynamic so that references to .foo are satisfied during the early
3671    stages of linking.  Otherwise the linker might decide to pull in a
3672    definition from some other object, eg. a static library.
3673
3674    Update: As of August 2004, we support a new convention.  Function
3675    calls may use the function descriptor symbol, ie. "bl foo".  This
3676    behaves exactly as "bl .foo".  */
3677
3678 /* Of those relocs that might be copied as dynamic relocs, this function
3679    selects those that must be copied when linking a shared library,
3680    even when the symbol is local.  */
3681
3682 static int
3683 must_be_dyn_reloc (struct bfd_link_info *info,
3684                    enum elf_ppc64_reloc_type r_type)
3685 {
3686   switch (r_type)
3687     {
3688     default:
3689       return 1;
3690
3691     case R_PPC64_REL32:
3692     case R_PPC64_REL64:
3693     case R_PPC64_REL30:
3694       return 0;
3695
3696     case R_PPC64_TPREL16:
3697     case R_PPC64_TPREL16_LO:
3698     case R_PPC64_TPREL16_HI:
3699     case R_PPC64_TPREL16_HA:
3700     case R_PPC64_TPREL16_DS:
3701     case R_PPC64_TPREL16_LO_DS:
3702     case R_PPC64_TPREL16_HIGH:
3703     case R_PPC64_TPREL16_HIGHA:
3704     case R_PPC64_TPREL16_HIGHER:
3705     case R_PPC64_TPREL16_HIGHERA:
3706     case R_PPC64_TPREL16_HIGHEST:
3707     case R_PPC64_TPREL16_HIGHESTA:
3708     case R_PPC64_TPREL64:
3709       return !info->executable;
3710     }
3711 }
3712
3713 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3714    copying dynamic variables from a shared lib into an app's dynbss
3715    section, and instead use a dynamic relocation to point into the
3716    shared lib.  With code that gcc generates, it's vital that this be
3717    enabled;  In the PowerPC64 ABI, the address of a function is actually
3718    the address of a function descriptor, which resides in the .opd
3719    section.  gcc uses the descriptor directly rather than going via the
3720    GOT as some other ABI's do, which means that initialized function
3721    pointers must reference the descriptor.  Thus, a function pointer
3722    initialized to the address of a function in a shared library will
3723    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3724    redefines the function descriptor symbol to point to the copy.  This
3725    presents a problem as a plt entry for that function is also
3726    initialized from the function descriptor symbol and the copy reloc
3727    may not be initialized first.  */
3728 #define ELIMINATE_COPY_RELOCS 1
3729
3730 /* Section name for stubs is the associated section name plus this
3731    string.  */
3732 #define STUB_SUFFIX ".stub"
3733
3734 /* Linker stubs.
3735    ppc_stub_long_branch:
3736    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3737    destination, but a 24 bit branch in a stub section will reach.
3738    .    b       dest
3739
3740    ppc_stub_plt_branch:
3741    Similar to the above, but a 24 bit branch in the stub section won't
3742    reach its destination.
3743    .    addis   %r11,%r2,xxx@toc@ha
3744    .    ld      %r12,xxx@toc@l(%r11)
3745    .    mtctr   %r12
3746    .    bctr
3747
3748    ppc_stub_plt_call:
3749    Used to call a function in a shared library.  If it so happens that
3750    the plt entry referenced crosses a 64k boundary, then an extra
3751    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3752    .    std     %r2,40(%r1)
3753    .    addis   %r11,%r2,xxx@toc@ha
3754    .    ld      %r12,xxx+0@toc@l(%r11)
3755    .    mtctr   %r12
3756    .    ld      %r2,xxx+8@toc@l(%r11)
3757    .    ld      %r11,xxx+16@toc@l(%r11)
3758    .    bctr
3759
3760    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3761    code to adjust the value and save r2 to support multiple toc sections.
3762    A ppc_stub_long_branch with an r2 offset looks like:
3763    .    std     %r2,40(%r1)
3764    .    addis   %r2,%r2,off@ha
3765    .    addi    %r2,%r2,off@l
3766    .    b       dest
3767
3768    A ppc_stub_plt_branch with an r2 offset looks like:
3769    .    std     %r2,40(%r1)
3770    .    addis   %r11,%r2,xxx@toc@ha
3771    .    ld      %r12,xxx@toc@l(%r11)
3772    .    addis   %r2,%r2,off@ha
3773    .    addi    %r2,%r2,off@l
3774    .    mtctr   %r12
3775    .    bctr
3776
3777    In cases where the "addis" instruction would add zero, the "addis" is
3778    omitted and following instructions modified slightly in some cases.
3779 */
3780
3781 enum ppc_stub_type {
3782   ppc_stub_none,
3783   ppc_stub_long_branch,
3784   ppc_stub_long_branch_r2off,
3785   ppc_stub_plt_branch,
3786   ppc_stub_plt_branch_r2off,
3787   ppc_stub_plt_call,
3788   ppc_stub_plt_call_r2save,
3789   ppc_stub_global_entry
3790 };
3791
3792 struct ppc_stub_hash_entry {
3793
3794   /* Base hash table entry structure.  */
3795   struct bfd_hash_entry root;
3796
3797   enum ppc_stub_type stub_type;
3798
3799   /* The stub section.  */
3800   asection *stub_sec;
3801
3802   /* Offset within stub_sec of the beginning of this stub.  */
3803   bfd_vma stub_offset;
3804
3805   /* Given the symbol's value and its section we can determine its final
3806      value when building the stubs (so the stub knows where to jump.  */
3807   bfd_vma target_value;
3808   asection *target_section;
3809
3810   /* The symbol table entry, if any, that this was derived from.  */
3811   struct ppc_link_hash_entry *h;
3812   struct plt_entry *plt_ent;
3813
3814   /* Where this stub is being called from, or, in the case of combined
3815      stub sections, the first input section in the group.  */
3816   asection *id_sec;
3817
3818   /* Symbol st_other.  */
3819   unsigned char other;
3820 };
3821
3822 struct ppc_branch_hash_entry {
3823
3824   /* Base hash table entry structure.  */
3825   struct bfd_hash_entry root;
3826
3827   /* Offset within branch lookup table.  */
3828   unsigned int offset;
3829
3830   /* Generation marker.  */
3831   unsigned int iter;
3832 };
3833
3834 /* Used to track dynamic relocations for local symbols.  */
3835 struct ppc_dyn_relocs
3836 {
3837   struct ppc_dyn_relocs *next;
3838
3839   /* The input section of the reloc.  */
3840   asection *sec;
3841
3842   /* Total number of relocs copied for the input section.  */
3843   unsigned int count : 31;
3844
3845   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3846   unsigned int ifunc : 1;
3847 };
3848
3849 struct ppc_link_hash_entry
3850 {
3851   struct elf_link_hash_entry elf;
3852
3853   union {
3854     /* A pointer to the most recently used stub hash entry against this
3855        symbol.  */
3856     struct ppc_stub_hash_entry *stub_cache;
3857
3858     /* A pointer to the next symbol starting with a '.'  */
3859     struct ppc_link_hash_entry *next_dot_sym;
3860   } u;
3861
3862   /* Track dynamic relocs copied for this symbol.  */
3863   struct elf_dyn_relocs *dyn_relocs;
3864
3865   /* Link between function code and descriptor symbols.  */
3866   struct ppc_link_hash_entry *oh;
3867
3868   /* Flag function code and descriptor symbols.  */
3869   unsigned int is_func:1;
3870   unsigned int is_func_descriptor:1;
3871   unsigned int fake:1;
3872
3873   /* Whether global opd/toc sym has been adjusted or not.
3874      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3875      should be set for all globals defined in any opd/toc section.  */
3876   unsigned int adjust_done:1;
3877
3878   /* Set if we twiddled this symbol to weak at some stage.  */
3879   unsigned int was_undefined:1;
3880
3881   /* Contexts in which symbol is used in the GOT (or TOC).
3882      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3883      corresponding relocs are encountered during check_relocs.
3884      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3885      indicate the corresponding GOT entry type is not needed.
3886      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3887      a TPREL one.  We use a separate flag rather than setting TPREL
3888      just for convenience in distinguishing the two cases.  */
3889 #define TLS_GD           1      /* GD reloc. */
3890 #define TLS_LD           2      /* LD reloc. */
3891 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3892 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3893 #define TLS_TLS         16      /* Any TLS reloc.  */
3894 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3895 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3896 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3897   unsigned char tls_mask;
3898 };
3899
3900 /* ppc64 ELF linker hash table.  */
3901
3902 struct ppc_link_hash_table
3903 {
3904   struct elf_link_hash_table elf;
3905
3906   /* The stub hash table.  */
3907   struct bfd_hash_table stub_hash_table;
3908
3909   /* Another hash table for plt_branch stubs.  */
3910   struct bfd_hash_table branch_hash_table;
3911
3912   /* Hash table for function prologue tocsave.  */
3913   htab_t tocsave_htab;
3914
3915   /* Various options and other info passed from the linker.  */
3916   struct ppc64_elf_params *params;
3917
3918   /* Array to keep track of which stub sections have been created, and
3919      information on stub grouping.  */
3920   struct map_stub {
3921     /* This is the section to which stubs in the group will be attached.  */
3922     asection *link_sec;
3923     /* The stub section.  */
3924     asection *stub_sec;
3925     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3926     bfd_vma toc_off;
3927   } *stub_group;
3928
3929   /* Temp used when calculating TOC pointers.  */
3930   bfd_vma toc_curr;
3931   bfd *toc_bfd;
3932   asection *toc_first_sec;
3933
3934   /* Highest input section id.  */
3935   int top_id;
3936
3937   /* Highest output section index.  */
3938   int top_index;
3939
3940   /* Used when adding symbols.  */
3941   struct ppc_link_hash_entry *dot_syms;
3942
3943   /* List of input sections for each output section.  */
3944   asection **input_list;
3945
3946   /* Shortcuts to get to dynamic linker sections.  */
3947   asection *dynbss;
3948   asection *relbss;
3949   asection *glink;
3950   asection *sfpr;
3951   asection *brlt;
3952   asection *relbrlt;
3953   asection *glink_eh_frame;
3954
3955   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3956   struct ppc_link_hash_entry *tls_get_addr;
3957   struct ppc_link_hash_entry *tls_get_addr_fd;
3958
3959   /* The size of reliplt used by got entry relocs.  */
3960   bfd_size_type got_reli_size;
3961
3962   /* Statistics.  */
3963   unsigned long stub_count[ppc_stub_global_entry];
3964
3965   /* Number of stubs against global syms.  */
3966   unsigned long stub_globals;
3967
3968   /* Set if we're linking code with function descriptors.  */
3969   unsigned int opd_abi:1;
3970
3971   /* Support for multiple toc sections.  */
3972   unsigned int do_multi_toc:1;
3973   unsigned int multi_toc_needed:1;
3974   unsigned int second_toc_pass:1;
3975   unsigned int do_toc_opt:1;
3976
3977   /* Set on error.  */
3978   unsigned int stub_error:1;
3979
3980   /* Temp used by ppc64_elf_before_check_relocs.  */
3981   unsigned int twiddled_syms:1;
3982
3983   /* Incremented every time we size stubs.  */
3984   unsigned int stub_iteration;
3985
3986   /* Small local sym cache.  */
3987   struct sym_cache sym_cache;
3988 };
3989
3990 /* Rename some of the generic section flags to better document how they
3991    are used here.  */
3992
3993 /* Nonzero if this section has TLS related relocations.  */
3994 #define has_tls_reloc sec_flg0
3995
3996 /* Nonzero if this section has a call to __tls_get_addr.  */
3997 #define has_tls_get_addr_call sec_flg1
3998
3999 /* Nonzero if this section has any toc or got relocs.  */
4000 #define has_toc_reloc sec_flg2
4001
4002 /* Nonzero if this section has a call to another section that uses
4003    the toc or got.  */
4004 #define makes_toc_func_call sec_flg3
4005
4006 /* Recursion protection when determining above flag.  */
4007 #define call_check_in_progress sec_flg4
4008 #define call_check_done sec_flg5
4009
4010 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4011
4012 #define ppc_hash_table(p) \
4013   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4014   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4015
4016 #define ppc_stub_hash_lookup(table, string, create, copy) \
4017   ((struct ppc_stub_hash_entry *) \
4018    bfd_hash_lookup ((table), (string), (create), (copy)))
4019
4020 #define ppc_branch_hash_lookup(table, string, create, copy) \
4021   ((struct ppc_branch_hash_entry *) \
4022    bfd_hash_lookup ((table), (string), (create), (copy)))
4023
4024 /* Create an entry in the stub hash table.  */
4025
4026 static struct bfd_hash_entry *
4027 stub_hash_newfunc (struct bfd_hash_entry *entry,
4028                    struct bfd_hash_table *table,
4029                    const char *string)
4030 {
4031   /* Allocate the structure if it has not already been allocated by a
4032      subclass.  */
4033   if (entry == NULL)
4034     {
4035       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4036       if (entry == NULL)
4037         return entry;
4038     }
4039
4040   /* Call the allocation method of the superclass.  */
4041   entry = bfd_hash_newfunc (entry, table, string);
4042   if (entry != NULL)
4043     {
4044       struct ppc_stub_hash_entry *eh;
4045
4046       /* Initialize the local fields.  */
4047       eh = (struct ppc_stub_hash_entry *) entry;
4048       eh->stub_type = ppc_stub_none;
4049       eh->stub_sec = NULL;
4050       eh->stub_offset = 0;
4051       eh->target_value = 0;
4052       eh->target_section = NULL;
4053       eh->h = NULL;
4054       eh->plt_ent = NULL;
4055       eh->id_sec = NULL;
4056       eh->other = 0;
4057     }
4058
4059   return entry;
4060 }
4061
4062 /* Create an entry in the branch hash table.  */
4063
4064 static struct bfd_hash_entry *
4065 branch_hash_newfunc (struct bfd_hash_entry *entry,
4066                      struct bfd_hash_table *table,
4067                      const char *string)
4068 {
4069   /* Allocate the structure if it has not already been allocated by a
4070      subclass.  */
4071   if (entry == NULL)
4072     {
4073       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4074       if (entry == NULL)
4075         return entry;
4076     }
4077
4078   /* Call the allocation method of the superclass.  */
4079   entry = bfd_hash_newfunc (entry, table, string);
4080   if (entry != NULL)
4081     {
4082       struct ppc_branch_hash_entry *eh;
4083
4084       /* Initialize the local fields.  */
4085       eh = (struct ppc_branch_hash_entry *) entry;
4086       eh->offset = 0;
4087       eh->iter = 0;
4088     }
4089
4090   return entry;
4091 }
4092
4093 /* Create an entry in a ppc64 ELF linker hash table.  */
4094
4095 static struct bfd_hash_entry *
4096 link_hash_newfunc (struct bfd_hash_entry *entry,
4097                    struct bfd_hash_table *table,
4098                    const char *string)
4099 {
4100   /* Allocate the structure if it has not already been allocated by a
4101      subclass.  */
4102   if (entry == NULL)
4103     {
4104       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4105       if (entry == NULL)
4106         return entry;
4107     }
4108
4109   /* Call the allocation method of the superclass.  */
4110   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4111   if (entry != NULL)
4112     {
4113       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4114
4115       memset (&eh->u.stub_cache, 0,
4116               (sizeof (struct ppc_link_hash_entry)
4117                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4118
4119       /* When making function calls, old ABI code references function entry
4120          points (dot symbols), while new ABI code references the function
4121          descriptor symbol.  We need to make any combination of reference and
4122          definition work together, without breaking archive linking.
4123
4124          For a defined function "foo" and an undefined call to "bar":
4125          An old object defines "foo" and ".foo", references ".bar" (possibly
4126          "bar" too).
4127          A new object defines "foo" and references "bar".
4128
4129          A new object thus has no problem with its undefined symbols being
4130          satisfied by definitions in an old object.  On the other hand, the
4131          old object won't have ".bar" satisfied by a new object.
4132
4133          Keep a list of newly added dot-symbols.  */
4134
4135       if (string[0] == '.')
4136         {
4137           struct ppc_link_hash_table *htab;
4138
4139           htab = (struct ppc_link_hash_table *) table;
4140           eh->u.next_dot_sym = htab->dot_syms;
4141           htab->dot_syms = eh;
4142         }
4143     }
4144
4145   return entry;
4146 }
4147
4148 struct tocsave_entry {
4149   asection *sec;
4150   bfd_vma offset;
4151 };
4152
4153 static hashval_t
4154 tocsave_htab_hash (const void *p)
4155 {
4156   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4157   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4158 }
4159
4160 static int
4161 tocsave_htab_eq (const void *p1, const void *p2)
4162 {
4163   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4164   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4165   return e1->sec == e2->sec && e1->offset == e2->offset;
4166 }
4167
4168 /* Destroy a ppc64 ELF linker hash table.  */
4169
4170 static void
4171 ppc64_elf_link_hash_table_free (bfd *obfd)
4172 {
4173   struct ppc_link_hash_table *htab;
4174
4175   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4176   if (htab->tocsave_htab)
4177     htab_delete (htab->tocsave_htab);
4178   bfd_hash_table_free (&htab->branch_hash_table);
4179   bfd_hash_table_free (&htab->stub_hash_table);
4180   _bfd_elf_link_hash_table_free (obfd);
4181 }
4182
4183 /* Create a ppc64 ELF linker hash table.  */
4184
4185 static struct bfd_link_hash_table *
4186 ppc64_elf_link_hash_table_create (bfd *abfd)
4187 {
4188   struct ppc_link_hash_table *htab;
4189   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4190
4191   htab = bfd_zmalloc (amt);
4192   if (htab == NULL)
4193     return NULL;
4194
4195   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4196                                       sizeof (struct ppc_link_hash_entry),
4197                                       PPC64_ELF_DATA))
4198     {
4199       free (htab);
4200       return NULL;
4201     }
4202
4203   /* Init the stub hash table too.  */
4204   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4205                             sizeof (struct ppc_stub_hash_entry)))
4206     {
4207       _bfd_elf_link_hash_table_free (abfd);
4208       return NULL;
4209     }
4210
4211   /* And the branch hash table.  */
4212   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4213                             sizeof (struct ppc_branch_hash_entry)))
4214     {
4215       bfd_hash_table_free (&htab->stub_hash_table);
4216       _bfd_elf_link_hash_table_free (abfd);
4217       return NULL;
4218     }
4219
4220   htab->tocsave_htab = htab_try_create (1024,
4221                                         tocsave_htab_hash,
4222                                         tocsave_htab_eq,
4223                                         NULL);
4224   if (htab->tocsave_htab == NULL)
4225     {
4226       ppc64_elf_link_hash_table_free (abfd);
4227       return NULL;
4228     }
4229   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4230
4231   /* Initializing two fields of the union is just cosmetic.  We really
4232      only care about glist, but when compiled on a 32-bit host the
4233      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4234      debugger inspection of these fields look nicer.  */
4235   htab->elf.init_got_refcount.refcount = 0;
4236   htab->elf.init_got_refcount.glist = NULL;
4237   htab->elf.init_plt_refcount.refcount = 0;
4238   htab->elf.init_plt_refcount.glist = NULL;
4239   htab->elf.init_got_offset.offset = 0;
4240   htab->elf.init_got_offset.glist = NULL;
4241   htab->elf.init_plt_offset.offset = 0;
4242   htab->elf.init_plt_offset.glist = NULL;
4243
4244   return &htab->elf.root;
4245 }
4246
4247 /* Create sections for linker generated code.  */
4248
4249 static bfd_boolean
4250 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4251 {
4252   struct ppc_link_hash_table *htab;
4253   flagword flags;
4254
4255   htab = ppc_hash_table (info);
4256
4257   /* Create .sfpr for code to save and restore fp regs.  */
4258   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4259            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4260   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4261                                                    flags);
4262   if (htab->sfpr == NULL
4263       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4264     return FALSE;
4265
4266   /* Create .glink for lazy dynamic linking support.  */
4267   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4268                                                     flags);
4269   if (htab->glink == NULL
4270       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4271     return FALSE;
4272
4273   if (!info->no_ld_generated_unwind_info)
4274     {
4275       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4276                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4277       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4278                                                                  ".eh_frame",
4279                                                                  flags);
4280       if (htab->glink_eh_frame == NULL
4281           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4282         return FALSE;
4283     }
4284
4285   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4286   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4287   if (htab->elf.iplt == NULL
4288       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4289     return FALSE;
4290
4291   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4292            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4293   htab->elf.irelplt
4294     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4295   if (htab->elf.irelplt == NULL
4296       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4297     return FALSE;
4298
4299   /* Create branch lookup table for plt_branch stubs.  */
4300   flags = (SEC_ALLOC | SEC_LOAD
4301            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4302   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4303                                                    flags);
4304   if (htab->brlt == NULL
4305       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4306     return FALSE;
4307
4308   if (!info->shared)
4309     return TRUE;
4310
4311   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4312            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4313   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4314                                                       ".rela.branch_lt",
4315                                                       flags);
4316   if (htab->relbrlt == NULL
4317       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4318     return FALSE;
4319
4320   return TRUE;
4321 }
4322
4323 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4324
4325 bfd_boolean
4326 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4327                          struct ppc64_elf_params *params)
4328 {
4329   struct ppc_link_hash_table *htab;
4330
4331   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4332
4333 /* Always hook our dynamic sections into the first bfd, which is the
4334    linker created stub bfd.  This ensures that the GOT header is at
4335    the start of the output TOC section.  */
4336   htab = ppc_hash_table (info);
4337   if (htab == NULL)
4338     return FALSE;
4339   htab->elf.dynobj = params->stub_bfd;
4340   htab->params = params;
4341
4342   if (info->relocatable)
4343     return TRUE;
4344
4345   return create_linkage_sections (htab->elf.dynobj, info);
4346 }
4347
4348 /* Build a name for an entry in the stub hash table.  */
4349
4350 static char *
4351 ppc_stub_name (const asection *input_section,
4352                const asection *sym_sec,
4353                const struct ppc_link_hash_entry *h,
4354                const Elf_Internal_Rela *rel)
4355 {
4356   char *stub_name;
4357   ssize_t len;
4358
4359   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4360      offsets from a sym as a branch target?  In fact, we could
4361      probably assume the addend is always zero.  */
4362   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4363
4364   if (h)
4365     {
4366       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4367       stub_name = bfd_malloc (len);
4368       if (stub_name == NULL)
4369         return stub_name;
4370
4371       len = sprintf (stub_name, "%08x.%s+%x",
4372                      input_section->id & 0xffffffff,
4373                      h->elf.root.root.string,
4374                      (int) rel->r_addend & 0xffffffff);
4375     }
4376   else
4377     {
4378       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4379       stub_name = bfd_malloc (len);
4380       if (stub_name == NULL)
4381         return stub_name;
4382
4383       len = sprintf (stub_name, "%08x.%x:%x+%x",
4384                      input_section->id & 0xffffffff,
4385                      sym_sec->id & 0xffffffff,
4386                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4387                      (int) rel->r_addend & 0xffffffff);
4388     }
4389   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4390     stub_name[len - 2] = 0;
4391   return stub_name;
4392 }
4393
4394 /* Look up an entry in the stub hash.  Stub entries are cached because
4395    creating the stub name takes a bit of time.  */
4396
4397 static struct ppc_stub_hash_entry *
4398 ppc_get_stub_entry (const asection *input_section,
4399                     const asection *sym_sec,
4400                     struct ppc_link_hash_entry *h,
4401                     const Elf_Internal_Rela *rel,
4402                     struct ppc_link_hash_table *htab)
4403 {
4404   struct ppc_stub_hash_entry *stub_entry;
4405   const asection *id_sec;
4406
4407   /* If this input section is part of a group of sections sharing one
4408      stub section, then use the id of the first section in the group.
4409      Stub names need to include a section id, as there may well be
4410      more than one stub used to reach say, printf, and we need to
4411      distinguish between them.  */
4412   id_sec = htab->stub_group[input_section->id].link_sec;
4413
4414   if (h != NULL && h->u.stub_cache != NULL
4415       && h->u.stub_cache->h == h
4416       && h->u.stub_cache->id_sec == id_sec)
4417     {
4418       stub_entry = h->u.stub_cache;
4419     }
4420   else
4421     {
4422       char *stub_name;
4423
4424       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4425       if (stub_name == NULL)
4426         return NULL;
4427
4428       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4429                                          stub_name, FALSE, FALSE);
4430       if (h != NULL)
4431         h->u.stub_cache = stub_entry;
4432
4433       free (stub_name);
4434     }
4435
4436   return stub_entry;
4437 }
4438
4439 /* Add a new stub entry to the stub hash.  Not all fields of the new
4440    stub entry are initialised.  */
4441
4442 static struct ppc_stub_hash_entry *
4443 ppc_add_stub (const char *stub_name,
4444               asection *section,
4445               struct bfd_link_info *info)
4446 {
4447   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4448   asection *link_sec;
4449   asection *stub_sec;
4450   struct ppc_stub_hash_entry *stub_entry;
4451
4452   link_sec = htab->stub_group[section->id].link_sec;
4453   stub_sec = htab->stub_group[section->id].stub_sec;
4454   if (stub_sec == NULL)
4455     {
4456       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4457       if (stub_sec == NULL)
4458         {
4459           size_t namelen;
4460           bfd_size_type len;
4461           char *s_name;
4462
4463           namelen = strlen (link_sec->name);
4464           len = namelen + sizeof (STUB_SUFFIX);
4465           s_name = bfd_alloc (htab->params->stub_bfd, len);
4466           if (s_name == NULL)
4467             return NULL;
4468
4469           memcpy (s_name, link_sec->name, namelen);
4470           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4471           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4472           if (stub_sec == NULL)
4473             return NULL;
4474           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4475         }
4476       htab->stub_group[section->id].stub_sec = stub_sec;
4477     }
4478
4479   /* Enter this entry into the linker stub hash table.  */
4480   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4481                                      TRUE, FALSE);
4482   if (stub_entry == NULL)
4483     {
4484       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4485                               section->owner, stub_name);
4486       return NULL;
4487     }
4488
4489   stub_entry->stub_sec = stub_sec;
4490   stub_entry->stub_offset = 0;
4491   stub_entry->id_sec = link_sec;
4492   return stub_entry;
4493 }
4494
4495 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4496    not already done.  */
4497
4498 static bfd_boolean
4499 create_got_section (bfd *abfd, struct bfd_link_info *info)
4500 {
4501   asection *got, *relgot;
4502   flagword flags;
4503   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4504
4505   if (!is_ppc64_elf (abfd))
4506     return FALSE;
4507   if (htab == NULL)
4508     return FALSE;
4509
4510   if (!htab->elf.sgot
4511       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4512     return FALSE;
4513
4514   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4515            | SEC_LINKER_CREATED);
4516
4517   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4518   if (!got
4519       || !bfd_set_section_alignment (abfd, got, 3))
4520     return FALSE;
4521
4522   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4523                                                flags | SEC_READONLY);
4524   if (!relgot
4525       || ! bfd_set_section_alignment (abfd, relgot, 3))
4526     return FALSE;
4527
4528   ppc64_elf_tdata (abfd)->got = got;
4529   ppc64_elf_tdata (abfd)->relgot = relgot;
4530   return TRUE;
4531 }
4532
4533 /* Create the dynamic sections, and set up shortcuts.  */
4534
4535 static bfd_boolean
4536 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4537 {
4538   struct ppc_link_hash_table *htab;
4539
4540   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4541     return FALSE;
4542
4543   htab = ppc_hash_table (info);
4544   if (htab == NULL)
4545     return FALSE;
4546
4547   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4548   if (!info->shared)
4549     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4550
4551   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4552       || (!info->shared && !htab->relbss))
4553     abort ();
4554
4555   return TRUE;
4556 }
4557
4558 /* Follow indirect and warning symbol links.  */
4559
4560 static inline struct bfd_link_hash_entry *
4561 follow_link (struct bfd_link_hash_entry *h)
4562 {
4563   while (h->type == bfd_link_hash_indirect
4564          || h->type == bfd_link_hash_warning)
4565     h = h->u.i.link;
4566   return h;
4567 }
4568
4569 static inline struct elf_link_hash_entry *
4570 elf_follow_link (struct elf_link_hash_entry *h)
4571 {
4572   return (struct elf_link_hash_entry *) follow_link (&h->root);
4573 }
4574
4575 static inline struct ppc_link_hash_entry *
4576 ppc_follow_link (struct ppc_link_hash_entry *h)
4577 {
4578   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4579 }
4580
4581 /* Merge PLT info on FROM with that on TO.  */
4582
4583 static void
4584 move_plt_plist (struct ppc_link_hash_entry *from,
4585                 struct ppc_link_hash_entry *to)
4586 {
4587   if (from->elf.plt.plist != NULL)
4588     {
4589       if (to->elf.plt.plist != NULL)
4590         {
4591           struct plt_entry **entp;
4592           struct plt_entry *ent;
4593
4594           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4595             {
4596               struct plt_entry *dent;
4597
4598               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4599                 if (dent->addend == ent->addend)
4600                   {
4601                     dent->plt.refcount += ent->plt.refcount;
4602                     *entp = ent->next;
4603                     break;
4604                   }
4605               if (dent == NULL)
4606                 entp = &ent->next;
4607             }
4608           *entp = to->elf.plt.plist;
4609         }
4610
4611       to->elf.plt.plist = from->elf.plt.plist;
4612       from->elf.plt.plist = NULL;
4613     }
4614 }
4615
4616 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4617
4618 static void
4619 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4620                                 struct elf_link_hash_entry *dir,
4621                                 struct elf_link_hash_entry *ind)
4622 {
4623   struct ppc_link_hash_entry *edir, *eind;
4624
4625   edir = (struct ppc_link_hash_entry *) dir;
4626   eind = (struct ppc_link_hash_entry *) ind;
4627
4628   edir->is_func |= eind->is_func;
4629   edir->is_func_descriptor |= eind->is_func_descriptor;
4630   edir->tls_mask |= eind->tls_mask;
4631   if (eind->oh != NULL)
4632     edir->oh = ppc_follow_link (eind->oh);
4633
4634   /* If called to transfer flags for a weakdef during processing
4635      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4636      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4637   if (!(ELIMINATE_COPY_RELOCS
4638         && eind->elf.root.type != bfd_link_hash_indirect
4639         && edir->elf.dynamic_adjusted))
4640     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4641
4642   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4643   edir->elf.ref_regular |= eind->elf.ref_regular;
4644   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4645   edir->elf.needs_plt |= eind->elf.needs_plt;
4646   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4647
4648   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4649   if (eind->dyn_relocs != NULL)
4650     {
4651       if (edir->dyn_relocs != NULL)
4652         {
4653           struct elf_dyn_relocs **pp;
4654           struct elf_dyn_relocs *p;
4655
4656           /* Add reloc counts against the indirect sym to the direct sym
4657              list.  Merge any entries against the same section.  */
4658           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4659             {
4660               struct elf_dyn_relocs *q;
4661
4662               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4663                 if (q->sec == p->sec)
4664                   {
4665                     q->pc_count += p->pc_count;
4666                     q->count += p->count;
4667                     *pp = p->next;
4668                     break;
4669                   }
4670               if (q == NULL)
4671                 pp = &p->next;
4672             }
4673           *pp = edir->dyn_relocs;
4674         }
4675
4676       edir->dyn_relocs = eind->dyn_relocs;
4677       eind->dyn_relocs = NULL;
4678     }
4679
4680   /* If we were called to copy over info for a weak sym, that's all.
4681      You might think dyn_relocs need not be copied over;  After all,
4682      both syms will be dynamic or both non-dynamic so we're just
4683      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4684      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4685      dyn_relocs in read-only sections, and it does so on what is the
4686      DIR sym here.  */
4687   if (eind->elf.root.type != bfd_link_hash_indirect)
4688     return;
4689
4690   /* Copy over got entries that we may have already seen to the
4691      symbol which just became indirect.  */
4692   if (eind->elf.got.glist != NULL)
4693     {
4694       if (edir->elf.got.glist != NULL)
4695         {
4696           struct got_entry **entp;
4697           struct got_entry *ent;
4698
4699           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4700             {
4701               struct got_entry *dent;
4702
4703               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4704                 if (dent->addend == ent->addend
4705                     && dent->owner == ent->owner
4706                     && dent->tls_type == ent->tls_type)
4707                   {
4708                     dent->got.refcount += ent->got.refcount;
4709                     *entp = ent->next;
4710                     break;
4711                   }
4712               if (dent == NULL)
4713                 entp = &ent->next;
4714             }
4715           *entp = edir->elf.got.glist;
4716         }
4717
4718       edir->elf.got.glist = eind->elf.got.glist;
4719       eind->elf.got.glist = NULL;
4720     }
4721
4722   /* And plt entries.  */
4723   move_plt_plist (eind, edir);
4724
4725   if (eind->elf.dynindx != -1)
4726     {
4727       if (edir->elf.dynindx != -1)
4728         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4729                                 edir->elf.dynstr_index);
4730       edir->elf.dynindx = eind->elf.dynindx;
4731       edir->elf.dynstr_index = eind->elf.dynstr_index;
4732       eind->elf.dynindx = -1;
4733       eind->elf.dynstr_index = 0;
4734     }
4735 }
4736
4737 /* Find the function descriptor hash entry from the given function code
4738    hash entry FH.  Link the entries via their OH fields.  */
4739
4740 static struct ppc_link_hash_entry *
4741 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4742 {
4743   struct ppc_link_hash_entry *fdh = fh->oh;
4744
4745   if (fdh == NULL)
4746     {
4747       const char *fd_name = fh->elf.root.root.string + 1;
4748
4749       fdh = (struct ppc_link_hash_entry *)
4750         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4751       if (fdh == NULL)
4752         return fdh;
4753
4754       fdh->is_func_descriptor = 1;
4755       fdh->oh = fh;
4756       fh->is_func = 1;
4757       fh->oh = fdh;
4758     }
4759
4760   return ppc_follow_link (fdh);
4761 }
4762
4763 /* Make a fake function descriptor sym for the code sym FH.  */
4764
4765 static struct ppc_link_hash_entry *
4766 make_fdh (struct bfd_link_info *info,
4767           struct ppc_link_hash_entry *fh)
4768 {
4769   bfd *abfd;
4770   asymbol *newsym;
4771   struct bfd_link_hash_entry *bh;
4772   struct ppc_link_hash_entry *fdh;
4773
4774   abfd = fh->elf.root.u.undef.abfd;
4775   newsym = bfd_make_empty_symbol (abfd);
4776   newsym->name = fh->elf.root.root.string + 1;
4777   newsym->section = bfd_und_section_ptr;
4778   newsym->value = 0;
4779   newsym->flags = BSF_WEAK;
4780
4781   bh = NULL;
4782   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4783                                          newsym->flags, newsym->section,
4784                                          newsym->value, NULL, FALSE, FALSE,
4785                                          &bh))
4786     return NULL;
4787
4788   fdh = (struct ppc_link_hash_entry *) bh;
4789   fdh->elf.non_elf = 0;
4790   fdh->fake = 1;
4791   fdh->is_func_descriptor = 1;
4792   fdh->oh = fh;
4793   fh->is_func = 1;
4794   fh->oh = fdh;
4795   return fdh;
4796 }
4797
4798 /* Fix function descriptor symbols defined in .opd sections to be
4799    function type.  */
4800
4801 static bfd_boolean
4802 ppc64_elf_add_symbol_hook (bfd *ibfd,
4803                            struct bfd_link_info *info,
4804                            Elf_Internal_Sym *isym,
4805                            const char **name,
4806                            flagword *flags ATTRIBUTE_UNUSED,
4807                            asection **sec,
4808                            bfd_vma *value ATTRIBUTE_UNUSED)
4809 {
4810   if ((ibfd->flags & DYNAMIC) == 0
4811       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4812     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4813
4814   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4815     {
4816       if ((ibfd->flags & DYNAMIC) == 0)
4817         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4818     }
4819   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4820     ;
4821   else if (*sec != NULL
4822            && strcmp ((*sec)->name, ".opd") == 0)
4823     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4824
4825   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4826     {
4827       if (abiversion (ibfd) == 0)
4828         set_abiversion (ibfd, 2);
4829       else if (abiversion (ibfd) == 1)
4830         {
4831           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4832                                     " for ABI version 1\n"), name);
4833           bfd_set_error (bfd_error_bad_value);
4834           return FALSE;
4835         }
4836     }
4837
4838   return TRUE;
4839 }
4840
4841 /* Merge non-visibility st_other attributes: local entry point.  */
4842
4843 static void
4844 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4845                                   const Elf_Internal_Sym *isym,
4846                                   bfd_boolean definition,
4847                                   bfd_boolean dynamic)
4848 {
4849   if (definition && !dynamic)
4850     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4851                 | ELF_ST_VISIBILITY (h->other));
4852 }
4853
4854 /* This function makes an old ABI object reference to ".bar" cause the
4855    inclusion of a new ABI object archive that defines "bar".
4856    NAME is a symbol defined in an archive.  Return a symbol in the hash
4857    table that might be satisfied by the archive symbols.  */
4858
4859 static struct elf_link_hash_entry *
4860 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4861                                  struct bfd_link_info *info,
4862                                  const char *name)
4863 {
4864   struct elf_link_hash_entry *h;
4865   char *dot_name;
4866   size_t len;
4867
4868   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4869   if (h != NULL
4870       /* Don't return this sym if it is a fake function descriptor
4871          created by add_symbol_adjust.  */
4872       && !(h->root.type == bfd_link_hash_undefweak
4873            && ((struct ppc_link_hash_entry *) h)->fake))
4874     return h;
4875
4876   if (name[0] == '.')
4877     return h;
4878
4879   len = strlen (name);
4880   dot_name = bfd_alloc (abfd, len + 2);
4881   if (dot_name == NULL)
4882     return (struct elf_link_hash_entry *) 0 - 1;
4883   dot_name[0] = '.';
4884   memcpy (dot_name + 1, name, len + 1);
4885   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4886   bfd_release (abfd, dot_name);
4887   return h;
4888 }
4889
4890 /* This function satisfies all old ABI object references to ".bar" if a
4891    new ABI object defines "bar".  Well, at least, undefined dot symbols
4892    are made weak.  This stops later archive searches from including an
4893    object if we already have a function descriptor definition.  It also
4894    prevents the linker complaining about undefined symbols.
4895    We also check and correct mismatched symbol visibility here.  The
4896    most restrictive visibility of the function descriptor and the
4897    function entry symbol is used.  */
4898
4899 static bfd_boolean
4900 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4901 {
4902   struct ppc_link_hash_table *htab;
4903   struct ppc_link_hash_entry *fdh;
4904
4905   if (eh->elf.root.type == bfd_link_hash_indirect)
4906     return TRUE;
4907
4908   if (eh->elf.root.type == bfd_link_hash_warning)
4909     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4910
4911   if (eh->elf.root.root.string[0] != '.')
4912     abort ();
4913
4914   htab = ppc_hash_table (info);
4915   if (htab == NULL)
4916     return FALSE;
4917
4918   fdh = lookup_fdh (eh, htab);
4919   if (fdh == NULL)
4920     {
4921       if (!info->relocatable
4922           && (eh->elf.root.type == bfd_link_hash_undefined
4923               || eh->elf.root.type == bfd_link_hash_undefweak)
4924           && eh->elf.ref_regular)
4925         {
4926           /* Make an undefweak function descriptor sym, which is enough to
4927              pull in an --as-needed shared lib, but won't cause link
4928              errors.  Archives are handled elsewhere.  */
4929           fdh = make_fdh (info, eh);
4930           if (fdh == NULL)
4931             return FALSE;
4932           fdh->elf.ref_regular = 1;
4933         }
4934     }
4935   else
4936     {
4937       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4938       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4939       if (entry_vis < descr_vis)
4940         fdh->elf.other += entry_vis - descr_vis;
4941       else if (entry_vis > descr_vis)
4942         eh->elf.other += descr_vis - entry_vis;
4943
4944       if ((fdh->elf.root.type == bfd_link_hash_defined
4945            || fdh->elf.root.type == bfd_link_hash_defweak)
4946           && eh->elf.root.type == bfd_link_hash_undefined)
4947         {
4948           eh->elf.root.type = bfd_link_hash_undefweak;
4949           eh->was_undefined = 1;
4950           htab->twiddled_syms = 1;
4951         }
4952     }
4953
4954   return TRUE;
4955 }
4956
4957 /* Set up opd section info and abiversion for IBFD, and process list
4958    of dot-symbols we made in link_hash_newfunc.  */
4959
4960 static bfd_boolean
4961 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4962 {
4963   struct ppc_link_hash_table *htab;
4964   struct ppc_link_hash_entry **p, *eh;
4965
4966   if (!is_ppc64_elf (info->output_bfd))
4967     return TRUE;
4968   htab = ppc_hash_table (info);
4969   if (htab == NULL)
4970     return FALSE;
4971
4972   if (is_ppc64_elf (ibfd))
4973     {
4974       asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4975
4976       if (opd != NULL && opd->size != 0)
4977         {
4978           if (abiversion (ibfd) == 0)
4979             set_abiversion (ibfd, 1);
4980           else if (abiversion (ibfd) == 2)
4981             {
4982               info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4983                                         " version %d\n"),
4984                                       ibfd, abiversion (ibfd));
4985               bfd_set_error (bfd_error_bad_value);
4986               return FALSE;
4987             }
4988
4989           if ((ibfd->flags & DYNAMIC) == 0
4990               && (opd->flags & SEC_RELOC) != 0
4991               && opd->reloc_count != 0
4992               && !bfd_is_abs_section (opd->output_section))
4993             {
4994               /* Garbage collection needs some extra help with .opd sections.
4995                  We don't want to necessarily keep everything referenced by
4996                  relocs in .opd, as that would keep all functions.  Instead,
4997                  if we reference an .opd symbol (a function descriptor), we
4998                  want to keep the function code symbol's section.  This is
4999                  easy for global symbols, but for local syms we need to keep
5000                  information about the associated function section.  */
5001               bfd_size_type amt;
5002               asection **opd_sym_map;
5003
5004               amt = opd->size * sizeof (*opd_sym_map) / 8;
5005               opd_sym_map = bfd_zalloc (ibfd, amt);
5006               if (opd_sym_map == NULL)
5007                 return FALSE;
5008               ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5009               BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5010               ppc64_elf_section_data (opd)->sec_type = sec_opd;
5011             }
5012         }
5013
5014       /* For input files without an explicit abiversion in e_flags
5015          we should have flagged any with symbol st_other bits set
5016          as ELFv1 and above flagged those with .opd as ELFv2.
5017          Set the output abiversion if not yet set, and for any input
5018          still ambiguous, take its abiversion from the output.
5019          Differences in ABI are reported later.  */
5020       if (abiversion (info->output_bfd) == 0)
5021         set_abiversion (info->output_bfd, abiversion (ibfd));
5022       else if (abiversion (ibfd) == 0)
5023         set_abiversion (ibfd, abiversion (info->output_bfd));
5024
5025       p = &htab->dot_syms;
5026       while ((eh = *p) != NULL)
5027         {
5028           *p = NULL;
5029           if (&eh->elf == htab->elf.hgot)
5030             ;
5031           else if (htab->elf.hgot == NULL
5032                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5033             htab->elf.hgot = &eh->elf;
5034           else if (!add_symbol_adjust (eh, info))
5035             return FALSE;
5036           p = &eh->u.next_dot_sym;
5037         }
5038     }
5039
5040   /* Clear the list for non-ppc64 input files.  */
5041   p = &htab->dot_syms;
5042   while ((eh = *p) != NULL)
5043     {
5044       *p = NULL;
5045       p = &eh->u.next_dot_sym;
5046     }
5047
5048   /* We need to fix the undefs list for any syms we have twiddled to
5049      undef_weak.  */
5050   if (htab->twiddled_syms)
5051     {
5052       bfd_link_repair_undef_list (&htab->elf.root);
5053       htab->twiddled_syms = 0;
5054     }
5055   return TRUE;
5056 }
5057
5058 /* Undo hash table changes when an --as-needed input file is determined
5059    not to be needed.  */
5060
5061 static bfd_boolean
5062 ppc64_elf_notice_as_needed (bfd *ibfd,
5063                             struct bfd_link_info *info,
5064                             enum notice_asneeded_action act)
5065 {
5066   if (act == notice_not_needed)
5067     {
5068       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5069
5070       if (htab == NULL)
5071         return FALSE;
5072
5073       htab->dot_syms = NULL;
5074     }
5075   return _bfd_elf_notice_as_needed (ibfd, info, act);
5076 }
5077
5078 /* If --just-symbols against a final linked binary, then assume we need
5079    toc adjusting stubs when calling functions defined there.  */
5080
5081 static void
5082 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5083 {
5084   if ((sec->flags & SEC_CODE) != 0
5085       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5086       && is_ppc64_elf (sec->owner))
5087     {
5088       if (abiversion (sec->owner) >= 2
5089           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5090         sec->has_toc_reloc = 1;
5091     }
5092   _bfd_elf_link_just_syms (sec, info);
5093 }
5094
5095 static struct plt_entry **
5096 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5097                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5098 {
5099   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5100   struct plt_entry **local_plt;
5101   unsigned char *local_got_tls_masks;
5102
5103   if (local_got_ents == NULL)
5104     {
5105       bfd_size_type size = symtab_hdr->sh_info;
5106
5107       size *= (sizeof (*local_got_ents)
5108                + sizeof (*local_plt)
5109                + sizeof (*local_got_tls_masks));
5110       local_got_ents = bfd_zalloc (abfd, size);
5111       if (local_got_ents == NULL)
5112         return NULL;
5113       elf_local_got_ents (abfd) = local_got_ents;
5114     }
5115
5116   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5117     {
5118       struct got_entry *ent;
5119
5120       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5121         if (ent->addend == r_addend
5122             && ent->owner == abfd
5123             && ent->tls_type == tls_type)
5124           break;
5125       if (ent == NULL)
5126         {
5127           bfd_size_type amt = sizeof (*ent);
5128           ent = bfd_alloc (abfd, amt);
5129           if (ent == NULL)
5130             return FALSE;
5131           ent->next = local_got_ents[r_symndx];
5132           ent->addend = r_addend;
5133           ent->owner = abfd;
5134           ent->tls_type = tls_type;
5135           ent->is_indirect = FALSE;
5136           ent->got.refcount = 0;
5137           local_got_ents[r_symndx] = ent;
5138         }
5139       ent->got.refcount += 1;
5140     }
5141
5142   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5143   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5144   local_got_tls_masks[r_symndx] |= tls_type;
5145
5146   return local_plt + r_symndx;
5147 }
5148
5149 static bfd_boolean
5150 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5151 {
5152   struct plt_entry *ent;
5153
5154   for (ent = *plist; ent != NULL; ent = ent->next)
5155     if (ent->addend == addend)
5156       break;
5157   if (ent == NULL)
5158     {
5159       bfd_size_type amt = sizeof (*ent);
5160       ent = bfd_alloc (abfd, amt);
5161       if (ent == NULL)
5162         return FALSE;
5163       ent->next = *plist;
5164       ent->addend = addend;
5165       ent->plt.refcount = 0;
5166       *plist = ent;
5167     }
5168   ent->plt.refcount += 1;
5169   return TRUE;
5170 }
5171
5172 static bfd_boolean
5173 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5174 {
5175   return (r_type == R_PPC64_REL24
5176           || r_type == R_PPC64_REL14
5177           || r_type == R_PPC64_REL14_BRTAKEN
5178           || r_type == R_PPC64_REL14_BRNTAKEN
5179           || r_type == R_PPC64_ADDR24
5180           || r_type == R_PPC64_ADDR14
5181           || r_type == R_PPC64_ADDR14_BRTAKEN
5182           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5183 }
5184
5185 /* Look through the relocs for a section during the first phase, and
5186    calculate needed space in the global offset table, procedure
5187    linkage table, and dynamic reloc sections.  */
5188
5189 static bfd_boolean
5190 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5191                         asection *sec, const Elf_Internal_Rela *relocs)
5192 {
5193   struct ppc_link_hash_table *htab;
5194   Elf_Internal_Shdr *symtab_hdr;
5195   struct elf_link_hash_entry **sym_hashes;
5196   const Elf_Internal_Rela *rel;
5197   const Elf_Internal_Rela *rel_end;
5198   asection *sreloc;
5199   asection **opd_sym_map;
5200   struct elf_link_hash_entry *tga, *dottga;
5201
5202   if (info->relocatable)
5203     return TRUE;
5204
5205   /* Don't do anything special with non-loaded, non-alloced sections.
5206      In particular, any relocs in such sections should not affect GOT
5207      and PLT reference counting (ie. we don't allow them to create GOT
5208      or PLT entries), there's no possibility or desire to optimize TLS
5209      relocs, and there's not much point in propagating relocs to shared
5210      libs that the dynamic linker won't relocate.  */
5211   if ((sec->flags & SEC_ALLOC) == 0)
5212     return TRUE;
5213
5214   BFD_ASSERT (is_ppc64_elf (abfd));
5215
5216   htab = ppc_hash_table (info);
5217   if (htab == NULL)
5218     return FALSE;
5219
5220   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5221                               FALSE, FALSE, TRUE);
5222   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5223                                  FALSE, FALSE, TRUE);
5224   symtab_hdr = &elf_symtab_hdr (abfd);
5225   sym_hashes = elf_sym_hashes (abfd);
5226   sreloc = NULL;
5227   opd_sym_map = NULL;
5228   if (ppc64_elf_section_data (sec) != NULL
5229       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5230     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5231
5232   rel_end = relocs + sec->reloc_count;
5233   for (rel = relocs; rel < rel_end; rel++)
5234     {
5235       unsigned long r_symndx;
5236       struct elf_link_hash_entry *h;
5237       enum elf_ppc64_reloc_type r_type;
5238       int tls_type;
5239       struct _ppc64_elf_section_data *ppc64_sec;
5240       struct plt_entry **ifunc;
5241
5242       r_symndx = ELF64_R_SYM (rel->r_info);
5243       if (r_symndx < symtab_hdr->sh_info)
5244         h = NULL;
5245       else
5246         {
5247           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5248           h = elf_follow_link (h);
5249
5250           /* PR15323, ref flags aren't set for references in the same
5251              object.  */
5252           h->root.non_ir_ref = 1;
5253
5254           if (h == htab->elf.hgot)
5255             sec->has_toc_reloc = 1;
5256         }
5257
5258       tls_type = 0;
5259       ifunc = NULL;
5260       if (h != NULL)
5261         {
5262           if (h->type == STT_GNU_IFUNC)
5263             {
5264               h->needs_plt = 1;
5265               ifunc = &h->plt.plist;
5266             }
5267         }
5268       else
5269         {
5270           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5271                                                           abfd, r_symndx);
5272           if (isym == NULL)
5273             return FALSE;
5274
5275           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5276             {
5277               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5278                                              rel->r_addend, PLT_IFUNC);
5279               if (ifunc == NULL)
5280                 return FALSE;
5281             }
5282         }
5283       r_type = ELF64_R_TYPE (rel->r_info);
5284       if (is_branch_reloc (r_type))
5285         {
5286           if (h != NULL && (h == tga || h == dottga))
5287             {
5288               if (rel != relocs
5289                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5290                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5291                 /* We have a new-style __tls_get_addr call with a marker
5292                    reloc.  */
5293                 ;
5294               else
5295                 /* Mark this section as having an old-style call.  */
5296                 sec->has_tls_get_addr_call = 1;
5297             }
5298
5299           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5300           if (ifunc != NULL
5301               && !update_plt_info (abfd, ifunc, rel->r_addend))
5302             return FALSE;
5303         }
5304
5305       switch (r_type)
5306         {
5307         case R_PPC64_TLSGD:
5308         case R_PPC64_TLSLD:
5309           /* These special tls relocs tie a call to __tls_get_addr with
5310              its parameter symbol.  */
5311           break;
5312
5313         case R_PPC64_GOT_TLSLD16:
5314         case R_PPC64_GOT_TLSLD16_LO:
5315         case R_PPC64_GOT_TLSLD16_HI:
5316         case R_PPC64_GOT_TLSLD16_HA:
5317           tls_type = TLS_TLS | TLS_LD;
5318           goto dogottls;
5319
5320         case R_PPC64_GOT_TLSGD16:
5321         case R_PPC64_GOT_TLSGD16_LO:
5322         case R_PPC64_GOT_TLSGD16_HI:
5323         case R_PPC64_GOT_TLSGD16_HA:
5324           tls_type = TLS_TLS | TLS_GD;
5325           goto dogottls;
5326
5327         case R_PPC64_GOT_TPREL16_DS:
5328         case R_PPC64_GOT_TPREL16_LO_DS:
5329         case R_PPC64_GOT_TPREL16_HI:
5330         case R_PPC64_GOT_TPREL16_HA:
5331           if (info->shared)
5332             info->flags |= DF_STATIC_TLS;
5333           tls_type = TLS_TLS | TLS_TPREL;
5334           goto dogottls;
5335
5336         case R_PPC64_GOT_DTPREL16_DS:
5337         case R_PPC64_GOT_DTPREL16_LO_DS:
5338         case R_PPC64_GOT_DTPREL16_HI:
5339         case R_PPC64_GOT_DTPREL16_HA:
5340           tls_type = TLS_TLS | TLS_DTPREL;
5341         dogottls:
5342           sec->has_tls_reloc = 1;
5343           /* Fall thru */
5344
5345         case R_PPC64_GOT16:
5346         case R_PPC64_GOT16_DS:
5347         case R_PPC64_GOT16_HA:
5348         case R_PPC64_GOT16_HI:
5349         case R_PPC64_GOT16_LO:
5350         case R_PPC64_GOT16_LO_DS:
5351           /* This symbol requires a global offset table entry.  */
5352           sec->has_toc_reloc = 1;
5353           if (r_type == R_PPC64_GOT_TLSLD16
5354               || r_type == R_PPC64_GOT_TLSGD16
5355               || r_type == R_PPC64_GOT_TPREL16_DS
5356               || r_type == R_PPC64_GOT_DTPREL16_DS
5357               || r_type == R_PPC64_GOT16
5358               || r_type == R_PPC64_GOT16_DS)
5359             {
5360               htab->do_multi_toc = 1;
5361               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5362             }
5363
5364           if (ppc64_elf_tdata (abfd)->got == NULL
5365               && !create_got_section (abfd, info))
5366             return FALSE;
5367
5368           if (h != NULL)
5369             {
5370               struct ppc_link_hash_entry *eh;
5371               struct got_entry *ent;
5372
5373               eh = (struct ppc_link_hash_entry *) h;
5374               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5375                 if (ent->addend == rel->r_addend
5376                     && ent->owner == abfd
5377                     && ent->tls_type == tls_type)
5378                   break;
5379               if (ent == NULL)
5380                 {
5381                   bfd_size_type amt = sizeof (*ent);
5382                   ent = bfd_alloc (abfd, amt);
5383                   if (ent == NULL)
5384                     return FALSE;
5385                   ent->next = eh->elf.got.glist;
5386                   ent->addend = rel->r_addend;
5387                   ent->owner = abfd;
5388                   ent->tls_type = tls_type;
5389                   ent->is_indirect = FALSE;
5390                   ent->got.refcount = 0;
5391                   eh->elf.got.glist = ent;
5392                 }
5393               ent->got.refcount += 1;
5394               eh->tls_mask |= tls_type;
5395             }
5396           else
5397             /* This is a global offset table entry for a local symbol.  */
5398             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5399                                         rel->r_addend, tls_type))
5400               return FALSE;
5401
5402           /* We may also need a plt entry if the symbol turns out to be
5403              an ifunc.  */
5404           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5405             {
5406               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5407                 return FALSE;
5408             }
5409           break;
5410
5411         case R_PPC64_PLT16_HA:
5412         case R_PPC64_PLT16_HI:
5413         case R_PPC64_PLT16_LO:
5414         case R_PPC64_PLT32:
5415         case R_PPC64_PLT64:
5416           /* This symbol requires a procedure linkage table entry.  We
5417              actually build the entry in adjust_dynamic_symbol,
5418              because this might be a case of linking PIC code without
5419              linking in any dynamic objects, in which case we don't
5420              need to generate a procedure linkage table after all.  */
5421           if (h == NULL)
5422             {
5423               /* It does not make sense to have a procedure linkage
5424                  table entry for a local symbol.  */
5425               bfd_set_error (bfd_error_bad_value);
5426               return FALSE;
5427             }
5428           else
5429             {
5430               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5431                 return FALSE;
5432               h->needs_plt = 1;
5433               if (h->root.root.string[0] == '.'
5434                   && h->root.root.string[1] != '\0')
5435                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5436             }
5437           break;
5438
5439           /* The following relocations don't need to propagate the
5440              relocation if linking a shared object since they are
5441              section relative.  */
5442         case R_PPC64_SECTOFF:
5443         case R_PPC64_SECTOFF_LO:
5444         case R_PPC64_SECTOFF_HI:
5445         case R_PPC64_SECTOFF_HA:
5446         case R_PPC64_SECTOFF_DS:
5447         case R_PPC64_SECTOFF_LO_DS:
5448         case R_PPC64_DTPREL16:
5449         case R_PPC64_DTPREL16_LO:
5450         case R_PPC64_DTPREL16_HI:
5451         case R_PPC64_DTPREL16_HA:
5452         case R_PPC64_DTPREL16_DS:
5453         case R_PPC64_DTPREL16_LO_DS:
5454         case R_PPC64_DTPREL16_HIGH:
5455         case R_PPC64_DTPREL16_HIGHA:
5456         case R_PPC64_DTPREL16_HIGHER:
5457         case R_PPC64_DTPREL16_HIGHERA:
5458         case R_PPC64_DTPREL16_HIGHEST:
5459         case R_PPC64_DTPREL16_HIGHESTA:
5460           break;
5461
5462           /* Nor do these.  */
5463         case R_PPC64_REL16:
5464         case R_PPC64_REL16_LO:
5465         case R_PPC64_REL16_HI:
5466         case R_PPC64_REL16_HA:
5467           break;
5468
5469           /* Not supported as a dynamic relocation.  */
5470         case R_PPC64_ADDR64_LOCAL:
5471           if (info->shared)
5472             {
5473               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5474                 ppc_howto_init ();
5475               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5476                                         "in shared libraries and PIEs.\n"),
5477                                       abfd, sec, rel->r_offset,
5478                                       ppc64_elf_howto_table[r_type]->name);
5479               bfd_set_error (bfd_error_bad_value);
5480               return FALSE;
5481             }
5482           break;
5483
5484         case R_PPC64_TOC16:
5485         case R_PPC64_TOC16_DS:
5486           htab->do_multi_toc = 1;
5487           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5488         case R_PPC64_TOC16_LO:
5489         case R_PPC64_TOC16_HI:
5490         case R_PPC64_TOC16_HA:
5491         case R_PPC64_TOC16_LO_DS:
5492           sec->has_toc_reloc = 1;
5493           break;
5494
5495           /* This relocation describes the C++ object vtable hierarchy.
5496              Reconstruct it for later use during GC.  */
5497         case R_PPC64_GNU_VTINHERIT:
5498           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5499             return FALSE;
5500           break;
5501
5502           /* This relocation describes which C++ vtable entries are actually
5503              used.  Record for later use during GC.  */
5504         case R_PPC64_GNU_VTENTRY:
5505           BFD_ASSERT (h != NULL);
5506           if (h != NULL
5507               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5508             return FALSE;
5509           break;
5510
5511         case R_PPC64_REL14:
5512         case R_PPC64_REL14_BRTAKEN:
5513         case R_PPC64_REL14_BRNTAKEN:
5514           {
5515             asection *dest = NULL;
5516
5517             /* Heuristic: If jumping outside our section, chances are
5518                we are going to need a stub.  */
5519             if (h != NULL)
5520               {
5521                 /* If the sym is weak it may be overridden later, so
5522                    don't assume we know where a weak sym lives.  */
5523                 if (h->root.type == bfd_link_hash_defined)
5524                   dest = h->root.u.def.section;
5525               }
5526             else
5527               {
5528                 Elf_Internal_Sym *isym;
5529
5530                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5531                                               abfd, r_symndx);
5532                 if (isym == NULL)
5533                   return FALSE;
5534
5535                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5536               }
5537
5538             if (dest != sec)
5539               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5540           }
5541           /* Fall through.  */
5542
5543         case R_PPC64_REL24:
5544           if (h != NULL && ifunc == NULL)
5545             {
5546               /* We may need a .plt entry if the function this reloc
5547                  refers to is in a shared lib.  */
5548               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5549                 return FALSE;
5550               h->needs_plt = 1;
5551               if (h->root.root.string[0] == '.'
5552                   && h->root.root.string[1] != '\0')
5553                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5554               if (h == tga || h == dottga)
5555                 sec->has_tls_reloc = 1;
5556             }
5557           break;
5558
5559         case R_PPC64_TPREL64:
5560           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5561           if (info->shared)
5562             info->flags |= DF_STATIC_TLS;
5563           goto dotlstoc;
5564
5565         case R_PPC64_DTPMOD64:
5566           if (rel + 1 < rel_end
5567               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5568               && rel[1].r_offset == rel->r_offset + 8)
5569             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5570           else
5571             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5572           goto dotlstoc;
5573
5574         case R_PPC64_DTPREL64:
5575           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5576           if (rel != relocs
5577               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5578               && rel[-1].r_offset == rel->r_offset - 8)
5579             /* This is the second reloc of a dtpmod, dtprel pair.
5580                Don't mark with TLS_DTPREL.  */
5581             goto dodyn;
5582
5583         dotlstoc:
5584           sec->has_tls_reloc = 1;
5585           if (h != NULL)
5586             {
5587               struct ppc_link_hash_entry *eh;
5588               eh = (struct ppc_link_hash_entry *) h;
5589               eh->tls_mask |= tls_type;
5590             }
5591           else
5592             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5593                                         rel->r_addend, tls_type))
5594               return FALSE;
5595
5596           ppc64_sec = ppc64_elf_section_data (sec);
5597           if (ppc64_sec->sec_type != sec_toc)
5598             {
5599               bfd_size_type amt;
5600
5601               /* One extra to simplify get_tls_mask.  */
5602               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5603               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5604               if (ppc64_sec->u.toc.symndx == NULL)
5605                 return FALSE;
5606               amt = sec->size * sizeof (bfd_vma) / 8;
5607               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5608               if (ppc64_sec->u.toc.add == NULL)
5609                 return FALSE;
5610               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5611               ppc64_sec->sec_type = sec_toc;
5612             }
5613           BFD_ASSERT (rel->r_offset % 8 == 0);
5614           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5615           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5616
5617           /* Mark the second slot of a GD or LD entry.
5618              -1 to indicate GD and -2 to indicate LD.  */
5619           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5620             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5621           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5622             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5623           goto dodyn;
5624
5625         case R_PPC64_TPREL16:
5626         case R_PPC64_TPREL16_LO:
5627         case R_PPC64_TPREL16_HI:
5628         case R_PPC64_TPREL16_HA:
5629         case R_PPC64_TPREL16_DS:
5630         case R_PPC64_TPREL16_LO_DS:
5631         case R_PPC64_TPREL16_HIGH:
5632         case R_PPC64_TPREL16_HIGHA:
5633         case R_PPC64_TPREL16_HIGHER:
5634         case R_PPC64_TPREL16_HIGHERA:
5635         case R_PPC64_TPREL16_HIGHEST:
5636         case R_PPC64_TPREL16_HIGHESTA:
5637           if (info->shared)
5638             {
5639               info->flags |= DF_STATIC_TLS;
5640               goto dodyn;
5641             }
5642           break;
5643
5644         case R_PPC64_ADDR64:
5645           if (opd_sym_map != NULL
5646               && rel + 1 < rel_end
5647               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5648             {
5649               if (h != NULL)
5650                 {
5651                   if (h->root.root.string[0] == '.'
5652                       && h->root.root.string[1] != 0
5653                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5654                     ;
5655                   else
5656                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5657                 }
5658               else
5659                 {
5660                   asection *s;
5661                   Elf_Internal_Sym *isym;
5662
5663                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5664                                                 abfd, r_symndx);
5665                   if (isym == NULL)
5666                     return FALSE;
5667
5668                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5669                   if (s != NULL && s != sec)
5670                     opd_sym_map[rel->r_offset / 8] = s;
5671                 }
5672             }
5673           /* Fall through.  */
5674
5675         case R_PPC64_ADDR16:
5676         case R_PPC64_ADDR16_DS:
5677         case R_PPC64_ADDR16_HA:
5678         case R_PPC64_ADDR16_HI:
5679         case R_PPC64_ADDR16_HIGH:
5680         case R_PPC64_ADDR16_HIGHA:
5681         case R_PPC64_ADDR16_HIGHER:
5682         case R_PPC64_ADDR16_HIGHERA:
5683         case R_PPC64_ADDR16_HIGHEST:
5684         case R_PPC64_ADDR16_HIGHESTA:
5685         case R_PPC64_ADDR16_LO:
5686         case R_PPC64_ADDR16_LO_DS:
5687           if (h != NULL && !info->shared && abiversion (abfd) != 1
5688               && rel->r_addend == 0)
5689             {
5690               /* We may need a .plt entry if this reloc refers to a
5691                  function in a shared lib.  */
5692               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5693                 return FALSE;
5694               h->pointer_equality_needed = 1;
5695             }
5696           /* Fall through.  */
5697
5698         case R_PPC64_REL30:
5699         case R_PPC64_REL32:
5700         case R_PPC64_REL64:
5701         case R_PPC64_ADDR14:
5702         case R_PPC64_ADDR14_BRNTAKEN:
5703         case R_PPC64_ADDR14_BRTAKEN:
5704         case R_PPC64_ADDR24:
5705         case R_PPC64_ADDR32:
5706         case R_PPC64_UADDR16:
5707         case R_PPC64_UADDR32:
5708         case R_PPC64_UADDR64:
5709         case R_PPC64_TOC:
5710           if (h != NULL && !info->shared)
5711             /* We may need a copy reloc.  */
5712             h->non_got_ref = 1;
5713
5714           /* Don't propagate .opd relocs.  */
5715           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5716             break;
5717
5718           /* If we are creating a shared library, and this is a reloc
5719              against a global symbol, or a non PC relative reloc
5720              against a local symbol, then we need to copy the reloc
5721              into the shared library.  However, if we are linking with
5722              -Bsymbolic, we do not need to copy a reloc against a
5723              global symbol which is defined in an object we are
5724              including in the link (i.e., DEF_REGULAR is set).  At
5725              this point we have not seen all the input files, so it is
5726              possible that DEF_REGULAR is not set now but will be set
5727              later (it is never cleared).  In case of a weak definition,
5728              DEF_REGULAR may be cleared later by a strong definition in
5729              a shared library.  We account for that possibility below by
5730              storing information in the dyn_relocs field of the hash
5731              table entry.  A similar situation occurs when creating
5732              shared libraries and symbol visibility changes render the
5733              symbol local.
5734
5735              If on the other hand, we are creating an executable, we
5736              may need to keep relocations for symbols satisfied by a
5737              dynamic library if we manage to avoid copy relocs for the
5738              symbol.  */
5739         dodyn:
5740           if ((info->shared
5741                && (must_be_dyn_reloc (info, r_type)
5742                    || (h != NULL
5743                        && (!SYMBOLIC_BIND (info, h)
5744                            || h->root.type == bfd_link_hash_defweak
5745                            || !h->def_regular))))
5746               || (ELIMINATE_COPY_RELOCS
5747                   && !info->shared
5748                   && h != NULL
5749                   && (h->root.type == bfd_link_hash_defweak
5750                       || !h->def_regular))
5751               || (!info->shared
5752                   && ifunc != NULL))
5753             {
5754               /* We must copy these reloc types into the output file.
5755                  Create a reloc section in dynobj and make room for
5756                  this reloc.  */
5757               if (sreloc == NULL)
5758                 {
5759                   sreloc = _bfd_elf_make_dynamic_reloc_section
5760                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5761
5762                   if (sreloc == NULL)
5763                     return FALSE;
5764                 }
5765
5766               /* If this is a global symbol, we count the number of
5767                  relocations we need for this symbol.  */
5768               if (h != NULL)
5769                 {
5770                   struct elf_dyn_relocs *p;
5771                   struct elf_dyn_relocs **head;
5772
5773                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5774                   p = *head;
5775                   if (p == NULL || p->sec != sec)
5776                     {
5777                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5778                       if (p == NULL)
5779                         return FALSE;
5780                       p->next = *head;
5781                       *head = p;
5782                       p->sec = sec;
5783                       p->count = 0;
5784                       p->pc_count = 0;
5785                     }
5786                   p->count += 1;
5787                   if (!must_be_dyn_reloc (info, r_type))
5788                     p->pc_count += 1;
5789                 }
5790               else
5791                 {
5792                   /* Track dynamic relocs needed for local syms too.
5793                      We really need local syms available to do this
5794                      easily.  Oh well.  */
5795                   struct ppc_dyn_relocs *p;
5796                   struct ppc_dyn_relocs **head;
5797                   bfd_boolean is_ifunc;
5798                   asection *s;
5799                   void *vpp;
5800                   Elf_Internal_Sym *isym;
5801
5802                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5803                                                 abfd, r_symndx);
5804                   if (isym == NULL)
5805                     return FALSE;
5806
5807                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5808                   if (s == NULL)
5809                     s = sec;
5810
5811                   vpp = &elf_section_data (s)->local_dynrel;
5812                   head = (struct ppc_dyn_relocs **) vpp;
5813                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5814                   p = *head;
5815                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5816                     p = p->next;
5817                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5818                     {
5819                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5820                       if (p == NULL)
5821                         return FALSE;
5822                       p->next = *head;
5823                       *head = p;
5824                       p->sec = sec;
5825                       p->ifunc = is_ifunc;
5826                       p->count = 0;
5827                     }
5828                   p->count += 1;
5829                 }
5830             }
5831           break;
5832
5833         default:
5834           break;
5835         }
5836     }
5837
5838   return TRUE;
5839 }
5840
5841 /* Merge backend specific data from an object file to the output
5842    object file when linking.  */
5843
5844 static bfd_boolean
5845 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5846 {
5847   unsigned long iflags, oflags;
5848
5849   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5850     return TRUE;
5851
5852   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5853     return TRUE;
5854
5855   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5856     return FALSE;
5857
5858   iflags = elf_elfheader (ibfd)->e_flags;
5859   oflags = elf_elfheader (obfd)->e_flags;
5860
5861   if (iflags & ~EF_PPC64_ABI)
5862     {
5863       (*_bfd_error_handler)
5864         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5865       bfd_set_error (bfd_error_bad_value);
5866       return FALSE;
5867     }
5868   else if (iflags != oflags && iflags != 0)
5869     {
5870       (*_bfd_error_handler)
5871         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5872          ibfd, iflags, oflags);
5873       bfd_set_error (bfd_error_bad_value);
5874       return FALSE;
5875     }
5876
5877   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5878   _bfd_elf_merge_object_attributes (ibfd, obfd);
5879
5880   return TRUE;
5881 }
5882
5883 static bfd_boolean
5884 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5885 {
5886   /* Print normal ELF private data.  */
5887   _bfd_elf_print_private_bfd_data (abfd, ptr);
5888
5889   if (elf_elfheader (abfd)->e_flags != 0)
5890     {
5891       FILE *file = ptr;
5892
5893       /* xgettext:c-format */
5894       fprintf (file, _("private flags = 0x%lx:"),
5895                elf_elfheader (abfd)->e_flags);
5896
5897       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5898         fprintf (file, _(" [abiv%ld]"),
5899                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5900       fputc ('\n', file);
5901     }
5902
5903   return TRUE;
5904 }
5905
5906 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5907    of the code entry point, and its section.  */
5908
5909 static bfd_vma
5910 opd_entry_value (asection *opd_sec,
5911                  bfd_vma offset,
5912                  asection **code_sec,
5913                  bfd_vma *code_off,
5914                  bfd_boolean in_code_sec)
5915 {
5916   bfd *opd_bfd = opd_sec->owner;
5917   Elf_Internal_Rela *relocs;
5918   Elf_Internal_Rela *lo, *hi, *look;
5919   bfd_vma val;
5920
5921   /* No relocs implies we are linking a --just-symbols object, or looking
5922      at a final linked executable with addr2line or somesuch.  */
5923   if (opd_sec->reloc_count == 0)
5924     {
5925       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5926
5927       if (contents == NULL)
5928         {
5929           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5930             return (bfd_vma) -1;
5931           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5932         }
5933
5934       val = bfd_get_64 (opd_bfd, contents + offset);
5935       if (code_sec != NULL)
5936         {
5937           asection *sec, *likely = NULL;
5938
5939           if (in_code_sec)
5940             {
5941               sec = *code_sec;
5942               if (sec->vma <= val
5943                   && val < sec->vma + sec->size)
5944                 likely = sec;
5945               else
5946                 val = -1;
5947             }
5948           else
5949             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5950               if (sec->vma <= val
5951                   && (sec->flags & SEC_LOAD) != 0
5952                   && (sec->flags & SEC_ALLOC) != 0)
5953                 likely = sec;
5954           if (likely != NULL)
5955             {
5956               *code_sec = likely;
5957               if (code_off != NULL)
5958                 *code_off = val - likely->vma;
5959             }
5960         }
5961       return val;
5962     }
5963
5964   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5965
5966   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5967   if (relocs == NULL)
5968     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5969
5970   /* Go find the opd reloc at the sym address.  */
5971   lo = relocs;
5972   BFD_ASSERT (lo != NULL);
5973   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5974   val = (bfd_vma) -1;
5975   while (lo < hi)
5976     {
5977       look = lo + (hi - lo) / 2;
5978       if (look->r_offset < offset)
5979         lo = look + 1;
5980       else if (look->r_offset > offset)
5981         hi = look;
5982       else
5983         {
5984           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5985
5986           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5987               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5988             {
5989               unsigned long symndx = ELF64_R_SYM (look->r_info);
5990               asection *sec;
5991
5992               if (symndx < symtab_hdr->sh_info
5993                   || elf_sym_hashes (opd_bfd) == NULL)
5994                 {
5995                   Elf_Internal_Sym *sym;
5996
5997                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5998                   if (sym == NULL)
5999                     {
6000                       size_t symcnt = symtab_hdr->sh_info;
6001                       if (elf_sym_hashes (opd_bfd) == NULL)
6002                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
6003                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
6004                                                   0, NULL, NULL, NULL);
6005                       if (sym == NULL)
6006                         break;
6007                       symtab_hdr->contents = (bfd_byte *) sym;
6008                     }
6009
6010                   sym += symndx;
6011                   val = sym->st_value;
6012                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6013                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6014                 }
6015               else
6016                 {
6017                   struct elf_link_hash_entry **sym_hashes;
6018                   struct elf_link_hash_entry *rh;
6019
6020                   sym_hashes = elf_sym_hashes (opd_bfd);
6021                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6022                   if (rh != NULL)
6023                     {
6024                       rh = elf_follow_link (rh);
6025                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6026                                   || rh->root.type == bfd_link_hash_defweak);
6027                       val = rh->root.u.def.value;
6028                       sec = rh->root.u.def.section;
6029                     }
6030                   else
6031                     {
6032                       /* Handle the odd case where we can be called
6033                          during bfd_elf_link_add_symbols before the
6034                          symbol hashes have been fully populated.  */
6035                       Elf_Internal_Sym *sym;
6036
6037                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6038                                                   symndx, NULL, NULL, NULL);
6039                       if (sym == NULL)
6040                         break;
6041
6042                       val = sym->st_value;
6043                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6044                       free (sym);
6045                     }
6046                 }
6047               val += look->r_addend;
6048               if (code_off != NULL)
6049                 *code_off = val;
6050               if (code_sec != NULL)
6051                 {
6052                   if (in_code_sec && *code_sec != sec)
6053                     return -1;
6054                   else
6055                     *code_sec = sec;
6056                 }
6057               if (sec != NULL && sec->output_section != NULL)
6058                 val += sec->output_section->vma + sec->output_offset;
6059             }
6060           break;
6061         }
6062     }
6063
6064   return val;
6065 }
6066
6067 /* If the ELF symbol SYM might be a function in SEC, return the
6068    function size and set *CODE_OFF to the function's entry point,
6069    otherwise return zero.  */
6070
6071 static bfd_size_type
6072 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6073                               bfd_vma *code_off)
6074 {
6075   bfd_size_type size;
6076
6077   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6078                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6079     return 0;
6080
6081   size = 0;
6082   if (!(sym->flags & BSF_SYNTHETIC))
6083     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6084
6085   if (strcmp (sym->section->name, ".opd") == 0)
6086     {
6087       if (opd_entry_value (sym->section, sym->value,
6088                            &sec, code_off, TRUE) == (bfd_vma) -1)
6089         return 0;
6090       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6091          symbol.  This size has nothing to do with the code size of the
6092          function, which is what we're supposed to return, but the
6093          code size isn't available without looking up the dot-sym.
6094          However, doing that would be a waste of time particularly
6095          since elf_find_function will look at the dot-sym anyway.
6096          Now, elf_find_function will keep the largest size of any
6097          function sym found at the code address of interest, so return
6098          1 here to avoid it incorrectly caching a larger function size
6099          for a small function.  This does mean we return the wrong
6100          size for a new-ABI function of size 24, but all that does is
6101          disable caching for such functions.  */
6102       if (size == 24)
6103         size = 1;
6104     }
6105   else
6106     {
6107       if (sym->section != sec)
6108         return 0;
6109       *code_off = sym->value;
6110     }
6111   if (size == 0)
6112     size = 1;
6113   return size;
6114 }
6115
6116 /* Return true if symbol is defined in a regular object file.  */
6117
6118 static bfd_boolean
6119 is_static_defined (struct elf_link_hash_entry *h)
6120 {
6121   return ((h->root.type == bfd_link_hash_defined
6122            || h->root.type == bfd_link_hash_defweak)
6123           && h->root.u.def.section != NULL
6124           && h->root.u.def.section->output_section != NULL);
6125 }
6126
6127 /* If FDH is a function descriptor symbol, return the associated code
6128    entry symbol if it is defined.  Return NULL otherwise.  */
6129
6130 static struct ppc_link_hash_entry *
6131 defined_code_entry (struct ppc_link_hash_entry *fdh)
6132 {
6133   if (fdh->is_func_descriptor)
6134     {
6135       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6136       if (fh->elf.root.type == bfd_link_hash_defined
6137           || fh->elf.root.type == bfd_link_hash_defweak)
6138         return fh;
6139     }
6140   return NULL;
6141 }
6142
6143 /* If FH is a function code entry symbol, return the associated
6144    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6145
6146 static struct ppc_link_hash_entry *
6147 defined_func_desc (struct ppc_link_hash_entry *fh)
6148 {
6149   if (fh->oh != NULL
6150       && fh->oh->is_func_descriptor)
6151     {
6152       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6153       if (fdh->elf.root.type == bfd_link_hash_defined
6154           || fdh->elf.root.type == bfd_link_hash_defweak)
6155         return fdh;
6156     }
6157   return NULL;
6158 }
6159
6160 /* Mark all our entry sym sections, both opd and code section.  */
6161
6162 static void
6163 ppc64_elf_gc_keep (struct bfd_link_info *info)
6164 {
6165   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6166   struct bfd_sym_chain *sym;
6167
6168   if (htab == NULL)
6169     return;
6170
6171   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6172     {
6173       struct ppc_link_hash_entry *eh, *fh;
6174       asection *sec;
6175
6176       eh = (struct ppc_link_hash_entry *)
6177         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6178       if (eh == NULL)
6179         continue;
6180       if (eh->elf.root.type != bfd_link_hash_defined
6181           && eh->elf.root.type != bfd_link_hash_defweak)
6182         continue;
6183
6184       fh = defined_code_entry (eh);
6185       if (fh != NULL)
6186         {
6187           sec = fh->elf.root.u.def.section;
6188           sec->flags |= SEC_KEEP;
6189         }
6190       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6191                && opd_entry_value (eh->elf.root.u.def.section,
6192                                    eh->elf.root.u.def.value,
6193                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6194         sec->flags |= SEC_KEEP;
6195
6196       sec = eh->elf.root.u.def.section;
6197       sec->flags |= SEC_KEEP;
6198     }
6199 }
6200
6201 /* Mark sections containing dynamically referenced symbols.  When
6202    building shared libraries, we must assume that any visible symbol is
6203    referenced.  */
6204
6205 static bfd_boolean
6206 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6207 {
6208   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6209   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6210   struct ppc_link_hash_entry *fdh;
6211   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6212
6213   /* Dynamic linking info is on the func descriptor sym.  */
6214   fdh = defined_func_desc (eh);
6215   if (fdh != NULL)
6216     eh = fdh;
6217
6218   if ((eh->elf.root.type == bfd_link_hash_defined
6219        || eh->elf.root.type == bfd_link_hash_defweak)
6220       && (eh->elf.ref_dynamic
6221           || (eh->elf.def_regular
6222               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6223               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6224               && (!info->executable
6225                   || info->export_dynamic
6226                   || (eh->elf.dynamic
6227                       && d != NULL
6228                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6229               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6230                   || !bfd_hide_sym_by_version (info->version_info,
6231                                                eh->elf.root.root.string)))))
6232     {
6233       asection *code_sec;
6234       struct ppc_link_hash_entry *fh;
6235
6236       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6237
6238       /* Function descriptor syms cause the associated
6239          function code sym section to be marked.  */
6240       fh = defined_code_entry (eh);
6241       if (fh != NULL)
6242         {
6243           code_sec = fh->elf.root.u.def.section;
6244           code_sec->flags |= SEC_KEEP;
6245         }
6246       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6247                && opd_entry_value (eh->elf.root.u.def.section,
6248                                    eh->elf.root.u.def.value,
6249                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6250         code_sec->flags |= SEC_KEEP;
6251     }
6252
6253   return TRUE;
6254 }
6255
6256 /* Return the section that should be marked against GC for a given
6257    relocation.  */
6258
6259 static asection *
6260 ppc64_elf_gc_mark_hook (asection *sec,
6261                         struct bfd_link_info *info,
6262                         Elf_Internal_Rela *rel,
6263                         struct elf_link_hash_entry *h,
6264                         Elf_Internal_Sym *sym)
6265 {
6266   asection *rsec;
6267
6268   /* Syms return NULL if we're marking .opd, so we avoid marking all
6269      function sections, as all functions are referenced in .opd.  */
6270   rsec = NULL;
6271   if (get_opd_info (sec) != NULL)
6272     return rsec;
6273
6274   if (h != NULL)
6275     {
6276       enum elf_ppc64_reloc_type r_type;
6277       struct ppc_link_hash_entry *eh, *fh, *fdh;
6278
6279       r_type = ELF64_R_TYPE (rel->r_info);
6280       switch (r_type)
6281         {
6282         case R_PPC64_GNU_VTINHERIT:
6283         case R_PPC64_GNU_VTENTRY:
6284           break;
6285
6286         default:
6287           switch (h->root.type)
6288             {
6289             case bfd_link_hash_defined:
6290             case bfd_link_hash_defweak:
6291               eh = (struct ppc_link_hash_entry *) h;
6292               fdh = defined_func_desc (eh);
6293               if (fdh != NULL)
6294                 eh = fdh;
6295
6296               /* Function descriptor syms cause the associated
6297                  function code sym section to be marked.  */
6298               fh = defined_code_entry (eh);
6299               if (fh != NULL)
6300                 {
6301                   /* They also mark their opd section.  */
6302                   eh->elf.root.u.def.section->gc_mark = 1;
6303
6304                   rsec = fh->elf.root.u.def.section;
6305                 }
6306               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6307                        && opd_entry_value (eh->elf.root.u.def.section,
6308                                            eh->elf.root.u.def.value,
6309                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6310                 eh->elf.root.u.def.section->gc_mark = 1;
6311               else
6312                 rsec = h->root.u.def.section;
6313               break;
6314
6315             case bfd_link_hash_common:
6316               rsec = h->root.u.c.p->section;
6317               break;
6318
6319             default:
6320               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6321             }
6322         }
6323     }
6324   else
6325     {
6326       struct _opd_sec_data *opd;
6327
6328       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6329       opd = get_opd_info (rsec);
6330       if (opd != NULL && opd->func_sec != NULL)
6331         {
6332           rsec->gc_mark = 1;
6333
6334           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6335         }
6336     }
6337
6338   return rsec;
6339 }
6340
6341 /* Update the .got, .plt. and dynamic reloc reference counts for the
6342    section being removed.  */
6343
6344 static bfd_boolean
6345 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6346                          asection *sec, const Elf_Internal_Rela *relocs)
6347 {
6348   struct ppc_link_hash_table *htab;
6349   Elf_Internal_Shdr *symtab_hdr;
6350   struct elf_link_hash_entry **sym_hashes;
6351   struct got_entry **local_got_ents;
6352   const Elf_Internal_Rela *rel, *relend;
6353
6354   if (info->relocatable)
6355     return TRUE;
6356
6357   if ((sec->flags & SEC_ALLOC) == 0)
6358     return TRUE;
6359
6360   elf_section_data (sec)->local_dynrel = NULL;
6361
6362   htab = ppc_hash_table (info);
6363   if (htab == NULL)
6364     return FALSE;
6365
6366   symtab_hdr = &elf_symtab_hdr (abfd);
6367   sym_hashes = elf_sym_hashes (abfd);
6368   local_got_ents = elf_local_got_ents (abfd);
6369
6370   relend = relocs + sec->reloc_count;
6371   for (rel = relocs; rel < relend; rel++)
6372     {
6373       unsigned long r_symndx;
6374       enum elf_ppc64_reloc_type r_type;
6375       struct elf_link_hash_entry *h = NULL;
6376       unsigned char tls_type = 0;
6377
6378       r_symndx = ELF64_R_SYM (rel->r_info);
6379       r_type = ELF64_R_TYPE (rel->r_info);
6380       if (r_symndx >= symtab_hdr->sh_info)
6381         {
6382           struct ppc_link_hash_entry *eh;
6383           struct elf_dyn_relocs **pp;
6384           struct elf_dyn_relocs *p;
6385
6386           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6387           h = elf_follow_link (h);
6388           eh = (struct ppc_link_hash_entry *) h;
6389
6390           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6391             if (p->sec == sec)
6392               {
6393                 /* Everything must go for SEC.  */
6394                 *pp = p->next;
6395                 break;
6396               }
6397         }
6398
6399       if (is_branch_reloc (r_type))
6400         {
6401           struct plt_entry **ifunc = NULL;
6402           if (h != NULL)
6403             {
6404               if (h->type == STT_GNU_IFUNC)
6405                 ifunc = &h->plt.plist;
6406             }
6407           else if (local_got_ents != NULL)
6408             {
6409               struct plt_entry **local_plt = (struct plt_entry **)
6410                 (local_got_ents + symtab_hdr->sh_info);
6411               unsigned char *local_got_tls_masks = (unsigned char *)
6412                 (local_plt + symtab_hdr->sh_info);
6413               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6414                 ifunc = local_plt + r_symndx;
6415             }
6416           if (ifunc != NULL)
6417             {
6418               struct plt_entry *ent;
6419
6420               for (ent = *ifunc; ent != NULL; ent = ent->next)
6421                 if (ent->addend == rel->r_addend)
6422                   break;
6423               if (ent == NULL)
6424                 abort ();
6425               if (ent->plt.refcount > 0)
6426                 ent->plt.refcount -= 1;
6427               continue;
6428             }
6429         }
6430
6431       switch (r_type)
6432         {
6433         case R_PPC64_GOT_TLSLD16:
6434         case R_PPC64_GOT_TLSLD16_LO:
6435         case R_PPC64_GOT_TLSLD16_HI:
6436         case R_PPC64_GOT_TLSLD16_HA:
6437           tls_type = TLS_TLS | TLS_LD;
6438           goto dogot;
6439
6440         case R_PPC64_GOT_TLSGD16:
6441         case R_PPC64_GOT_TLSGD16_LO:
6442         case R_PPC64_GOT_TLSGD16_HI:
6443         case R_PPC64_GOT_TLSGD16_HA:
6444           tls_type = TLS_TLS | TLS_GD;
6445           goto dogot;
6446
6447         case R_PPC64_GOT_TPREL16_DS:
6448         case R_PPC64_GOT_TPREL16_LO_DS:
6449         case R_PPC64_GOT_TPREL16_HI:
6450         case R_PPC64_GOT_TPREL16_HA:
6451           tls_type = TLS_TLS | TLS_TPREL;
6452           goto dogot;
6453
6454         case R_PPC64_GOT_DTPREL16_DS:
6455         case R_PPC64_GOT_DTPREL16_LO_DS:
6456         case R_PPC64_GOT_DTPREL16_HI:
6457         case R_PPC64_GOT_DTPREL16_HA:
6458           tls_type = TLS_TLS | TLS_DTPREL;
6459           goto dogot;
6460
6461         case R_PPC64_GOT16:
6462         case R_PPC64_GOT16_DS:
6463         case R_PPC64_GOT16_HA:
6464         case R_PPC64_GOT16_HI:
6465         case R_PPC64_GOT16_LO:
6466         case R_PPC64_GOT16_LO_DS:
6467         dogot:
6468           {
6469             struct got_entry *ent;
6470
6471             if (h != NULL)
6472               ent = h->got.glist;
6473             else
6474               ent = local_got_ents[r_symndx];
6475
6476             for (; ent != NULL; ent = ent->next)
6477               if (ent->addend == rel->r_addend
6478                   && ent->owner == abfd
6479                   && ent->tls_type == tls_type)
6480                 break;
6481             if (ent == NULL)
6482               abort ();
6483             if (ent->got.refcount > 0)
6484               ent->got.refcount -= 1;
6485           }
6486           break;
6487
6488         case R_PPC64_PLT16_HA:
6489         case R_PPC64_PLT16_HI:
6490         case R_PPC64_PLT16_LO:
6491         case R_PPC64_PLT32:
6492         case R_PPC64_PLT64:
6493         case R_PPC64_REL14:
6494         case R_PPC64_REL14_BRNTAKEN:
6495         case R_PPC64_REL14_BRTAKEN:
6496         case R_PPC64_REL24:
6497           if (h != NULL)
6498             {
6499               struct plt_entry *ent;
6500
6501               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6502                 if (ent->addend == rel->r_addend)
6503                   break;
6504               if (ent != NULL && ent->plt.refcount > 0)
6505                 ent->plt.refcount -= 1;
6506             }
6507           break;
6508
6509         default:
6510           break;
6511         }
6512     }
6513   return TRUE;
6514 }
6515
6516 /* The maximum size of .sfpr.  */
6517 #define SFPR_MAX (218*4)
6518
6519 struct sfpr_def_parms
6520 {
6521   const char name[12];
6522   unsigned char lo, hi;
6523   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6524   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6525 };
6526
6527 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6528
6529 static bfd_boolean
6530 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6531 {
6532   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6533   unsigned int i;
6534   size_t len = strlen (parm->name);
6535   bfd_boolean writing = FALSE;
6536   char sym[16];
6537
6538   if (htab == NULL)
6539     return FALSE;
6540
6541   memcpy (sym, parm->name, len);
6542   sym[len + 2] = 0;
6543
6544   for (i = parm->lo; i <= parm->hi; i++)
6545     {
6546       struct elf_link_hash_entry *h;
6547
6548       sym[len + 0] = i / 10 + '0';
6549       sym[len + 1] = i % 10 + '0';
6550       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6551       if (h != NULL
6552           && !h->def_regular)
6553         {
6554           h->root.type = bfd_link_hash_defined;
6555           h->root.u.def.section = htab->sfpr;
6556           h->root.u.def.value = htab->sfpr->size;
6557           h->type = STT_FUNC;
6558           h->def_regular = 1;
6559           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6560           writing = TRUE;
6561           if (htab->sfpr->contents == NULL)
6562             {
6563               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6564               if (htab->sfpr->contents == NULL)
6565                 return FALSE;
6566             }
6567         }
6568       if (writing)
6569         {
6570           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6571           if (i != parm->hi)
6572             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6573           else
6574             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6575           htab->sfpr->size = p - htab->sfpr->contents;
6576         }
6577     }
6578
6579   return TRUE;
6580 }
6581
6582 static bfd_byte *
6583 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6584 {
6585   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6586   return p + 4;
6587 }
6588
6589 static bfd_byte *
6590 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6591 {
6592   p = savegpr0 (abfd, p, r);
6593   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6594   p = p + 4;
6595   bfd_put_32 (abfd, BLR, p);
6596   return p + 4;
6597 }
6598
6599 static bfd_byte *
6600 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6601 {
6602   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6603   return p + 4;
6604 }
6605
6606 static bfd_byte *
6607 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6608 {
6609   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6610   p = p + 4;
6611   p = restgpr0 (abfd, p, r);
6612   bfd_put_32 (abfd, MTLR_R0, p);
6613   p = p + 4;
6614   if (r == 29)
6615     {
6616       p = restgpr0 (abfd, p, 30);
6617       p = restgpr0 (abfd, p, 31);
6618     }
6619   bfd_put_32 (abfd, BLR, p);
6620   return p + 4;
6621 }
6622
6623 static bfd_byte *
6624 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6625 {
6626   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6627   return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   p = savegpr1 (abfd, p, r);
6634   bfd_put_32 (abfd, BLR, p);
6635   return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6640 {
6641   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6642   return p + 4;
6643 }
6644
6645 static bfd_byte *
6646 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6647 {
6648   p = restgpr1 (abfd, p, r);
6649   bfd_put_32 (abfd, BLR, p);
6650   return p + 4;
6651 }
6652
6653 static bfd_byte *
6654 savefpr (bfd *abfd, bfd_byte *p, int r)
6655 {
6656   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6657   return p + 4;
6658 }
6659
6660 static bfd_byte *
6661 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6662 {
6663   p = savefpr (abfd, p, r);
6664   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6665   p = p + 4;
6666   bfd_put_32 (abfd, BLR, p);
6667   return p + 4;
6668 }
6669
6670 static bfd_byte *
6671 restfpr (bfd *abfd, bfd_byte *p, int r)
6672 {
6673   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6674   return p + 4;
6675 }
6676
6677 static bfd_byte *
6678 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6679 {
6680   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6681   p = p + 4;
6682   p = restfpr (abfd, p, r);
6683   bfd_put_32 (abfd, MTLR_R0, p);
6684   p = p + 4;
6685   if (r == 29)
6686     {
6687       p = restfpr (abfd, p, 30);
6688       p = restfpr (abfd, p, 31);
6689     }
6690   bfd_put_32 (abfd, BLR, p);
6691   return p + 4;
6692 }
6693
6694 static bfd_byte *
6695 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6696 {
6697   p = savefpr (abfd, p, r);
6698   bfd_put_32 (abfd, BLR, p);
6699   return p + 4;
6700 }
6701
6702 static bfd_byte *
6703 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6704 {
6705   p = restfpr (abfd, p, r);
6706   bfd_put_32 (abfd, BLR, p);
6707   return p + 4;
6708 }
6709
6710 static bfd_byte *
6711 savevr (bfd *abfd, bfd_byte *p, int r)
6712 {
6713   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6714   p = p + 4;
6715   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6716   return p + 4;
6717 }
6718
6719 static bfd_byte *
6720 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6721 {
6722   p = savevr (abfd, p, r);
6723   bfd_put_32 (abfd, BLR, p);
6724   return p + 4;
6725 }
6726
6727 static bfd_byte *
6728 restvr (bfd *abfd, bfd_byte *p, int r)
6729 {
6730   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6731   p = p + 4;
6732   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6733   return p + 4;
6734 }
6735
6736 static bfd_byte *
6737 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6738 {
6739   p = restvr (abfd, p, r);
6740   bfd_put_32 (abfd, BLR, p);
6741   return p + 4;
6742 }
6743
6744 /* Called via elf_link_hash_traverse to transfer dynamic linking
6745    information on function code symbol entries to their corresponding
6746    function descriptor symbol entries.  */
6747
6748 static bfd_boolean
6749 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6750 {
6751   struct bfd_link_info *info;
6752   struct ppc_link_hash_table *htab;
6753   struct plt_entry *ent;
6754   struct ppc_link_hash_entry *fh;
6755   struct ppc_link_hash_entry *fdh;
6756   bfd_boolean force_local;
6757
6758   fh = (struct ppc_link_hash_entry *) h;
6759   if (fh->elf.root.type == bfd_link_hash_indirect)
6760     return TRUE;
6761
6762   info = inf;
6763   htab = ppc_hash_table (info);
6764   if (htab == NULL)
6765     return FALSE;
6766
6767   /* Resolve undefined references to dot-symbols as the value
6768      in the function descriptor, if we have one in a regular object.
6769      This is to satisfy cases like ".quad .foo".  Calls to functions
6770      in dynamic objects are handled elsewhere.  */
6771   if (fh->elf.root.type == bfd_link_hash_undefweak
6772       && fh->was_undefined
6773       && (fdh = defined_func_desc (fh)) != NULL
6774       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6775       && opd_entry_value (fdh->elf.root.u.def.section,
6776                           fdh->elf.root.u.def.value,
6777                           &fh->elf.root.u.def.section,
6778                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6779     {
6780       fh->elf.root.type = fdh->elf.root.type;
6781       fh->elf.forced_local = 1;
6782       fh->elf.def_regular = fdh->elf.def_regular;
6783       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6784     }
6785
6786   /* If this is a function code symbol, transfer dynamic linking
6787      information to the function descriptor symbol.  */
6788   if (!fh->is_func)
6789     return TRUE;
6790
6791   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6792     if (ent->plt.refcount > 0)
6793       break;
6794   if (ent == NULL
6795       || fh->elf.root.root.string[0] != '.'
6796       || fh->elf.root.root.string[1] == '\0')
6797     return TRUE;
6798
6799   /* Find the corresponding function descriptor symbol.  Create it
6800      as undefined if necessary.  */
6801
6802   fdh = lookup_fdh (fh, htab);
6803   if (fdh == NULL
6804       && !info->executable
6805       && (fh->elf.root.type == bfd_link_hash_undefined
6806           || fh->elf.root.type == bfd_link_hash_undefweak))
6807     {
6808       fdh = make_fdh (info, fh);
6809       if (fdh == NULL)
6810         return FALSE;
6811     }
6812
6813   /* Fake function descriptors are made undefweak.  If the function
6814      code symbol is strong undefined, make the fake sym the same.
6815      If the function code symbol is defined, then force the fake
6816      descriptor local;  We can't support overriding of symbols in a
6817      shared library on a fake descriptor.  */
6818
6819   if (fdh != NULL
6820       && fdh->fake
6821       && fdh->elf.root.type == bfd_link_hash_undefweak)
6822     {
6823       if (fh->elf.root.type == bfd_link_hash_undefined)
6824         {
6825           fdh->elf.root.type = bfd_link_hash_undefined;
6826           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6827         }
6828       else if (fh->elf.root.type == bfd_link_hash_defined
6829                || fh->elf.root.type == bfd_link_hash_defweak)
6830         {
6831           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6832         }
6833     }
6834
6835   if (fdh != NULL
6836       && !fdh->elf.forced_local
6837       && (!info->executable
6838           || fdh->elf.def_dynamic
6839           || fdh->elf.ref_dynamic
6840           || (fdh->elf.root.type == bfd_link_hash_undefweak
6841               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6842     {
6843       if (fdh->elf.dynindx == -1)
6844         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6845           return FALSE;
6846       fdh->elf.ref_regular |= fh->elf.ref_regular;
6847       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6848       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6849       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6850       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6851         {
6852           move_plt_plist (fh, fdh);
6853           fdh->elf.needs_plt = 1;
6854         }
6855       fdh->is_func_descriptor = 1;
6856       fdh->oh = fh;
6857       fh->oh = fdh;
6858     }
6859
6860   /* Now that the info is on the function descriptor, clear the
6861      function code sym info.  Any function code syms for which we
6862      don't have a definition in a regular file, we force local.
6863      This prevents a shared library from exporting syms that have
6864      been imported from another library.  Function code syms that
6865      are really in the library we must leave global to prevent the
6866      linker dragging in a definition from a static library.  */
6867   force_local = (!fh->elf.def_regular
6868                  || fdh == NULL
6869                  || !fdh->elf.def_regular
6870                  || fdh->elf.forced_local);
6871   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6872
6873   return TRUE;
6874 }
6875
6876 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6877    this hook to a) provide some gcc support functions, and b) transfer
6878    dynamic linking information gathered so far on function code symbol
6879    entries, to their corresponding function descriptor symbol entries.  */
6880
6881 static bfd_boolean
6882 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6883                             struct bfd_link_info *info)
6884 {
6885   struct ppc_link_hash_table *htab;
6886   unsigned int i;
6887   static const struct sfpr_def_parms funcs[] =
6888     {
6889       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6890       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6891       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6892       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6893       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6894       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6895       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6896       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6897       { "._savef", 14, 31, savefpr, savefpr1_tail },
6898       { "._restf", 14, 31, restfpr, restfpr1_tail },
6899       { "_savevr_", 20, 31, savevr, savevr_tail },
6900       { "_restvr_", 20, 31, restvr, restvr_tail }
6901     };
6902
6903   htab = ppc_hash_table (info);
6904   if (htab == NULL)
6905     return FALSE;
6906
6907   if (!info->relocatable
6908       && htab->elf.hgot != NULL)
6909     {
6910       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6911       /* Make .TOC. defined so as to prevent it being made dynamic.
6912          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6913       htab->elf.hgot->type = STT_OBJECT;
6914       htab->elf.hgot->root.type = bfd_link_hash_defined;
6915       htab->elf.hgot->root.u.def.value = 0;
6916       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6917       htab->elf.hgot->def_regular = 1;
6918       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6919                                | STV_HIDDEN);
6920     }
6921
6922   if (htab->sfpr == NULL)
6923     /* We don't have any relocs.  */
6924     return TRUE;
6925
6926   /* Provide any missing _save* and _rest* functions.  */
6927   htab->sfpr->size = 0;
6928   if (htab->params->save_restore_funcs)
6929     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6930       if (!sfpr_define (info, &funcs[i]))
6931         return FALSE;
6932
6933   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6934
6935   if (htab->sfpr->size == 0)
6936     htab->sfpr->flags |= SEC_EXCLUDE;
6937
6938   return TRUE;
6939 }
6940
6941 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6942
6943 static bfd_boolean
6944 readonly_dynrelocs (struct elf_link_hash_entry *h)
6945 {
6946   struct ppc_link_hash_entry *eh;
6947   struct elf_dyn_relocs *p;
6948
6949   eh = (struct ppc_link_hash_entry *) h;
6950   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6951     {
6952       asection *s = p->sec->output_section;
6953
6954       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6955         return TRUE;
6956     }
6957   return FALSE;
6958 }
6959
6960 /* Adjust a symbol defined by a dynamic object and referenced by a
6961    regular object.  The current definition is in some section of the
6962    dynamic object, but we're not including those sections.  We have to
6963    change the definition to something the rest of the link can
6964    understand.  */
6965
6966 static bfd_boolean
6967 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6968                                  struct elf_link_hash_entry *h)
6969 {
6970   struct ppc_link_hash_table *htab;
6971   asection *s;
6972
6973   htab = ppc_hash_table (info);
6974   if (htab == NULL)
6975     return FALSE;
6976
6977   /* Deal with function syms.  */
6978   if (h->type == STT_FUNC
6979       || h->type == STT_GNU_IFUNC
6980       || h->needs_plt)
6981     {
6982       /* Clear procedure linkage table information for any symbol that
6983          won't need a .plt entry.  */
6984       struct plt_entry *ent;
6985       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6986         if (ent->plt.refcount > 0)
6987           break;
6988       if (ent == NULL
6989           || (h->type != STT_GNU_IFUNC
6990               && (SYMBOL_CALLS_LOCAL (info, h)
6991                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6992                       && h->root.type == bfd_link_hash_undefweak))))
6993         {
6994           h->plt.plist = NULL;
6995           h->needs_plt = 0;
6996           h->pointer_equality_needed = 0;
6997         }
6998       else if (abiversion (info->output_bfd) == 2)
6999         {
7000           /* Taking a function's address in a read/write section
7001              doesn't require us to define the function symbol in the
7002              executable on a global entry stub.  A dynamic reloc can
7003              be used instead.  */
7004           if (h->pointer_equality_needed
7005               && !readonly_dynrelocs (h))
7006             {
7007               h->pointer_equality_needed = 0;
7008               h->non_got_ref = 0;
7009             }
7010
7011           /* After adjust_dynamic_symbol, non_got_ref set in the
7012              non-shared case means that we have allocated space in
7013              .dynbss for the symbol and thus dyn_relocs for this
7014              symbol should be discarded.
7015              If we get here we know we are making a PLT entry for this
7016              symbol, and in an executable we'd normally resolve
7017              relocations against this symbol to the PLT entry.  Allow
7018              dynamic relocs if the reference is weak, and the dynamic
7019              relocs will not cause text relocation.  */
7020           else if (!h->ref_regular_nonweak
7021                    && h->non_got_ref
7022                    && h->type != STT_GNU_IFUNC
7023                    && !readonly_dynrelocs (h))
7024             h->non_got_ref = 0;
7025
7026           /* If making a plt entry, then we don't need copy relocs.  */
7027           return TRUE;
7028         }
7029     }
7030   else
7031     h->plt.plist = NULL;
7032
7033   /* If this is a weak symbol, and there is a real definition, the
7034      processor independent code will have arranged for us to see the
7035      real definition first, and we can just use the same value.  */
7036   if (h->u.weakdef != NULL)
7037     {
7038       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7039                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7040       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7041       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7042       if (ELIMINATE_COPY_RELOCS)
7043         h->non_got_ref = h->u.weakdef->non_got_ref;
7044       return TRUE;
7045     }
7046
7047   /* If we are creating a shared library, we must presume that the
7048      only references to the symbol are via the global offset table.
7049      For such cases we need not do anything here; the relocations will
7050      be handled correctly by relocate_section.  */
7051   if (info->shared)
7052     return TRUE;
7053
7054   /* If there are no references to this symbol that do not use the
7055      GOT, we don't need to generate a copy reloc.  */
7056   if (!h->non_got_ref)
7057     return TRUE;
7058
7059   /* Don't generate a copy reloc for symbols defined in the executable.  */
7060   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7061     return TRUE;
7062
7063   /* If we didn't find any dynamic relocs in read-only sections, then
7064      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7065   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7066     {
7067       h->non_got_ref = 0;
7068       return TRUE;
7069     }
7070
7071   if (h->plt.plist != NULL)
7072     {
7073       /* We should never get here, but unfortunately there are versions
7074          of gcc out there that improperly (for this ABI) put initialized
7075          function pointers, vtable refs and suchlike in read-only
7076          sections.  Allow them to proceed, but warn that this might
7077          break at runtime.  */
7078       info->callbacks->einfo
7079         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7080            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7081          h->root.root.string);
7082     }
7083
7084   /* This is a reference to a symbol defined by a dynamic object which
7085      is not a function.  */
7086
7087   /* We must allocate the symbol in our .dynbss section, which will
7088      become part of the .bss section of the executable.  There will be
7089      an entry for this symbol in the .dynsym section.  The dynamic
7090      object will contain position independent code, so all references
7091      from the dynamic object to this symbol will go through the global
7092      offset table.  The dynamic linker will use the .dynsym entry to
7093      determine the address it must put in the global offset table, so
7094      both the dynamic object and the regular object will refer to the
7095      same memory location for the variable.  */
7096
7097   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7098      to copy the initial value out of the dynamic object and into the
7099      runtime process image.  We need to remember the offset into the
7100      .rela.bss section we are going to use.  */
7101   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7102     {
7103       htab->relbss->size += sizeof (Elf64_External_Rela);
7104       h->needs_copy = 1;
7105     }
7106
7107   s = htab->dynbss;
7108
7109   return _bfd_elf_adjust_dynamic_copy (h, s);
7110 }
7111
7112 /* If given a function descriptor symbol, hide both the function code
7113    sym and the descriptor.  */
7114 static void
7115 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7116                        struct elf_link_hash_entry *h,
7117                        bfd_boolean force_local)
7118 {
7119   struct ppc_link_hash_entry *eh;
7120   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7121
7122   eh = (struct ppc_link_hash_entry *) h;
7123   if (eh->is_func_descriptor)
7124     {
7125       struct ppc_link_hash_entry *fh = eh->oh;
7126
7127       if (fh == NULL)
7128         {
7129           const char *p, *q;
7130           struct ppc_link_hash_table *htab;
7131           char save;
7132
7133           /* We aren't supposed to use alloca in BFD because on
7134              systems which do not have alloca the version in libiberty
7135              calls xmalloc, which might cause the program to crash
7136              when it runs out of memory.  This function doesn't have a
7137              return status, so there's no way to gracefully return an
7138              error.  So cheat.  We know that string[-1] can be safely
7139              accessed;  It's either a string in an ELF string table,
7140              or allocated in an objalloc structure.  */
7141
7142           p = eh->elf.root.root.string - 1;
7143           save = *p;
7144           *(char *) p = '.';
7145           htab = ppc_hash_table (info);
7146           if (htab == NULL)
7147             return;
7148
7149           fh = (struct ppc_link_hash_entry *)
7150             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7151           *(char *) p = save;
7152
7153           /* Unfortunately, if it so happens that the string we were
7154              looking for was allocated immediately before this string,
7155              then we overwrote the string terminator.  That's the only
7156              reason the lookup should fail.  */
7157           if (fh == NULL)
7158             {
7159               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7160               while (q >= eh->elf.root.root.string && *q == *p)
7161                 --q, --p;
7162               if (q < eh->elf.root.root.string && *p == '.')
7163                 fh = (struct ppc_link_hash_entry *)
7164                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7165             }
7166           if (fh != NULL)
7167             {
7168               eh->oh = fh;
7169               fh->oh = eh;
7170             }
7171         }
7172       if (fh != NULL)
7173         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7174     }
7175 }
7176
7177 static bfd_boolean
7178 get_sym_h (struct elf_link_hash_entry **hp,
7179            Elf_Internal_Sym **symp,
7180            asection **symsecp,
7181            unsigned char **tls_maskp,
7182            Elf_Internal_Sym **locsymsp,
7183            unsigned long r_symndx,
7184            bfd *ibfd)
7185 {
7186   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7187
7188   if (r_symndx >= symtab_hdr->sh_info)
7189     {
7190       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7191       struct elf_link_hash_entry *h;
7192
7193       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7194       h = elf_follow_link (h);
7195
7196       if (hp != NULL)
7197         *hp = h;
7198
7199       if (symp != NULL)
7200         *symp = NULL;
7201
7202       if (symsecp != NULL)
7203         {
7204           asection *symsec = NULL;
7205           if (h->root.type == bfd_link_hash_defined
7206               || h->root.type == bfd_link_hash_defweak)
7207             symsec = h->root.u.def.section;
7208           *symsecp = symsec;
7209         }
7210
7211       if (tls_maskp != NULL)
7212         {
7213           struct ppc_link_hash_entry *eh;
7214
7215           eh = (struct ppc_link_hash_entry *) h;
7216           *tls_maskp = &eh->tls_mask;
7217         }
7218     }
7219   else
7220     {
7221       Elf_Internal_Sym *sym;
7222       Elf_Internal_Sym *locsyms = *locsymsp;
7223
7224       if (locsyms == NULL)
7225         {
7226           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7227           if (locsyms == NULL)
7228             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7229                                             symtab_hdr->sh_info,
7230                                             0, NULL, NULL, NULL);
7231           if (locsyms == NULL)
7232             return FALSE;
7233           *locsymsp = locsyms;
7234         }
7235       sym = locsyms + r_symndx;
7236
7237       if (hp != NULL)
7238         *hp = NULL;
7239
7240       if (symp != NULL)
7241         *symp = sym;
7242
7243       if (symsecp != NULL)
7244         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7245
7246       if (tls_maskp != NULL)
7247         {
7248           struct got_entry **lgot_ents;
7249           unsigned char *tls_mask;
7250
7251           tls_mask = NULL;
7252           lgot_ents = elf_local_got_ents (ibfd);
7253           if (lgot_ents != NULL)
7254             {
7255               struct plt_entry **local_plt = (struct plt_entry **)
7256                 (lgot_ents + symtab_hdr->sh_info);
7257               unsigned char *lgot_masks = (unsigned char *)
7258                 (local_plt + symtab_hdr->sh_info);
7259               tls_mask = &lgot_masks[r_symndx];
7260             }
7261           *tls_maskp = tls_mask;
7262         }
7263     }
7264   return TRUE;
7265 }
7266
7267 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7268    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7269    type suitable for optimization, and 1 otherwise.  */
7270
7271 static int
7272 get_tls_mask (unsigned char **tls_maskp,
7273               unsigned long *toc_symndx,
7274               bfd_vma *toc_addend,
7275               Elf_Internal_Sym **locsymsp,
7276               const Elf_Internal_Rela *rel,
7277               bfd *ibfd)
7278 {
7279   unsigned long r_symndx;
7280   int next_r;
7281   struct elf_link_hash_entry *h;
7282   Elf_Internal_Sym *sym;
7283   asection *sec;
7284   bfd_vma off;
7285
7286   r_symndx = ELF64_R_SYM (rel->r_info);
7287   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7288     return 0;
7289
7290   if ((*tls_maskp != NULL && **tls_maskp != 0)
7291       || sec == NULL
7292       || ppc64_elf_section_data (sec) == NULL
7293       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7294     return 1;
7295
7296   /* Look inside a TOC section too.  */
7297   if (h != NULL)
7298     {
7299       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7300       off = h->root.u.def.value;
7301     }
7302   else
7303     off = sym->st_value;
7304   off += rel->r_addend;
7305   BFD_ASSERT (off % 8 == 0);
7306   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7307   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7308   if (toc_symndx != NULL)
7309     *toc_symndx = r_symndx;
7310   if (toc_addend != NULL)
7311     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7312   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7313     return 0;
7314   if ((h == NULL || is_static_defined (h))
7315       && (next_r == -1 || next_r == -2))
7316     return 1 - next_r;
7317   return 1;
7318 }
7319
7320 /* Find (or create) an entry in the tocsave hash table.  */
7321
7322 static struct tocsave_entry *
7323 tocsave_find (struct ppc_link_hash_table *htab,
7324               enum insert_option insert,
7325               Elf_Internal_Sym **local_syms,
7326               const Elf_Internal_Rela *irela,
7327               bfd *ibfd)
7328 {
7329   unsigned long r_indx;
7330   struct elf_link_hash_entry *h;
7331   Elf_Internal_Sym *sym;
7332   struct tocsave_entry ent, *p;
7333   hashval_t hash;
7334   struct tocsave_entry **slot;
7335
7336   r_indx = ELF64_R_SYM (irela->r_info);
7337   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7338     return NULL;
7339   if (ent.sec == NULL || ent.sec->output_section == NULL)
7340     {
7341       (*_bfd_error_handler)
7342         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7343       return NULL;
7344     }
7345
7346   if (h != NULL)
7347     ent.offset = h->root.u.def.value;
7348   else
7349     ent.offset = sym->st_value;
7350   ent.offset += irela->r_addend;
7351
7352   hash = tocsave_htab_hash (&ent);
7353   slot = ((struct tocsave_entry **)
7354           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7355   if (slot == NULL)
7356     return NULL;
7357
7358   if (*slot == NULL)
7359     {
7360       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7361       if (p == NULL)
7362         return NULL;
7363       *p = ent;
7364       *slot = p;
7365     }
7366   return *slot;
7367 }
7368
7369 /* Adjust all global syms defined in opd sections.  In gcc generated
7370    code for the old ABI, these will already have been done.  */
7371
7372 static bfd_boolean
7373 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7374 {
7375   struct ppc_link_hash_entry *eh;
7376   asection *sym_sec;
7377   struct _opd_sec_data *opd;
7378
7379   if (h->root.type == bfd_link_hash_indirect)
7380     return TRUE;
7381
7382   if (h->root.type != bfd_link_hash_defined
7383       && h->root.type != bfd_link_hash_defweak)
7384     return TRUE;
7385
7386   eh = (struct ppc_link_hash_entry *) h;
7387   if (eh->adjust_done)
7388     return TRUE;
7389
7390   sym_sec = eh->elf.root.u.def.section;
7391   opd = get_opd_info (sym_sec);
7392   if (opd != NULL && opd->adjust != NULL)
7393     {
7394       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7395       if (adjust == -1)
7396         {
7397           /* This entry has been deleted.  */
7398           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7399           if (dsec == NULL)
7400             {
7401               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7402                 if (discarded_section (dsec))
7403                   {
7404                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7405                     break;
7406                   }
7407             }
7408           eh->elf.root.u.def.value = 0;
7409           eh->elf.root.u.def.section = dsec;
7410         }
7411       else
7412         eh->elf.root.u.def.value += adjust;
7413       eh->adjust_done = 1;
7414     }
7415   return TRUE;
7416 }
7417
7418 /* Handles decrementing dynamic reloc counts for the reloc specified by
7419    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7420    have already been determined.  */
7421
7422 static bfd_boolean
7423 dec_dynrel_count (bfd_vma r_info,
7424                   asection *sec,
7425                   struct bfd_link_info *info,
7426                   Elf_Internal_Sym **local_syms,
7427                   struct elf_link_hash_entry *h,
7428                   Elf_Internal_Sym *sym)
7429 {
7430   enum elf_ppc64_reloc_type r_type;
7431   asection *sym_sec = NULL;
7432
7433   /* Can this reloc be dynamic?  This switch, and later tests here
7434      should be kept in sync with the code in check_relocs.  */
7435   r_type = ELF64_R_TYPE (r_info);
7436   switch (r_type)
7437     {
7438     default:
7439       return TRUE;
7440
7441     case R_PPC64_TPREL16:
7442     case R_PPC64_TPREL16_LO:
7443     case R_PPC64_TPREL16_HI:
7444     case R_PPC64_TPREL16_HA:
7445     case R_PPC64_TPREL16_DS:
7446     case R_PPC64_TPREL16_LO_DS:
7447     case R_PPC64_TPREL16_HIGH:
7448     case R_PPC64_TPREL16_HIGHA:
7449     case R_PPC64_TPREL16_HIGHER:
7450     case R_PPC64_TPREL16_HIGHERA:
7451     case R_PPC64_TPREL16_HIGHEST:
7452     case R_PPC64_TPREL16_HIGHESTA:
7453       if (!info->shared)
7454         return TRUE;
7455
7456     case R_PPC64_TPREL64:
7457     case R_PPC64_DTPMOD64:
7458     case R_PPC64_DTPREL64:
7459     case R_PPC64_ADDR64:
7460     case R_PPC64_REL30:
7461     case R_PPC64_REL32:
7462     case R_PPC64_REL64:
7463     case R_PPC64_ADDR14:
7464     case R_PPC64_ADDR14_BRNTAKEN:
7465     case R_PPC64_ADDR14_BRTAKEN:
7466     case R_PPC64_ADDR16:
7467     case R_PPC64_ADDR16_DS:
7468     case R_PPC64_ADDR16_HA:
7469     case R_PPC64_ADDR16_HI:
7470     case R_PPC64_ADDR16_HIGH:
7471     case R_PPC64_ADDR16_HIGHA:
7472     case R_PPC64_ADDR16_HIGHER:
7473     case R_PPC64_ADDR16_HIGHERA:
7474     case R_PPC64_ADDR16_HIGHEST:
7475     case R_PPC64_ADDR16_HIGHESTA:
7476     case R_PPC64_ADDR16_LO:
7477     case R_PPC64_ADDR16_LO_DS:
7478     case R_PPC64_ADDR24:
7479     case R_PPC64_ADDR32:
7480     case R_PPC64_UADDR16:
7481     case R_PPC64_UADDR32:
7482     case R_PPC64_UADDR64:
7483     case R_PPC64_TOC:
7484       break;
7485     }
7486
7487   if (local_syms != NULL)
7488     {
7489       unsigned long r_symndx;
7490       bfd *ibfd = sec->owner;
7491
7492       r_symndx = ELF64_R_SYM (r_info);
7493       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7494         return FALSE;
7495     }
7496
7497   if ((info->shared
7498        && (must_be_dyn_reloc (info, r_type)
7499            || (h != NULL
7500                && (!SYMBOLIC_BIND (info, h)
7501                    || h->root.type == bfd_link_hash_defweak
7502                    || !h->def_regular))))
7503       || (ELIMINATE_COPY_RELOCS
7504           && !info->shared
7505           && h != NULL
7506           && (h->root.type == bfd_link_hash_defweak
7507               || !h->def_regular)))
7508     ;
7509   else
7510     return TRUE;
7511
7512   if (h != NULL)
7513     {
7514       struct elf_dyn_relocs *p;
7515       struct elf_dyn_relocs **pp;
7516       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7517
7518       /* elf_gc_sweep may have already removed all dyn relocs associated
7519          with local syms for a given section.  Also, symbol flags are
7520          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7521          report a dynreloc miscount.  */
7522       if (*pp == NULL && info->gc_sections)
7523         return TRUE;
7524
7525       while ((p = *pp) != NULL)
7526         {
7527           if (p->sec == sec)
7528             {
7529               if (!must_be_dyn_reloc (info, r_type))
7530                 p->pc_count -= 1;
7531               p->count -= 1;
7532               if (p->count == 0)
7533                 *pp = p->next;
7534               return TRUE;
7535             }
7536           pp = &p->next;
7537         }
7538     }
7539   else
7540     {
7541       struct ppc_dyn_relocs *p;
7542       struct ppc_dyn_relocs **pp;
7543       void *vpp;
7544       bfd_boolean is_ifunc;
7545
7546       if (local_syms == NULL)
7547         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7548       if (sym_sec == NULL)
7549         sym_sec = sec;
7550
7551       vpp = &elf_section_data (sym_sec)->local_dynrel;
7552       pp = (struct ppc_dyn_relocs **) vpp;
7553
7554       if (*pp == NULL && info->gc_sections)
7555         return TRUE;
7556
7557       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7558       while ((p = *pp) != NULL)
7559         {
7560           if (p->sec == sec && p->ifunc == is_ifunc)
7561             {
7562               p->count -= 1;
7563               if (p->count == 0)
7564                 *pp = p->next;
7565               return TRUE;
7566             }
7567           pp = &p->next;
7568         }
7569     }
7570
7571   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7572                           sec->owner, sec);
7573   bfd_set_error (bfd_error_bad_value);
7574   return FALSE;
7575 }
7576
7577 /* Remove unused Official Procedure Descriptor entries.  Currently we
7578    only remove those associated with functions in discarded link-once
7579    sections, or weakly defined functions that have been overridden.  It
7580    would be possible to remove many more entries for statically linked
7581    applications.  */
7582
7583 bfd_boolean
7584 ppc64_elf_edit_opd (struct bfd_link_info *info)
7585 {
7586   bfd *ibfd;
7587   bfd_boolean some_edited = FALSE;
7588   asection *need_pad = NULL;
7589   struct ppc_link_hash_table *htab;
7590
7591   htab = ppc_hash_table (info);
7592   if (htab == NULL)
7593     return FALSE;
7594
7595   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7596     {
7597       asection *sec;
7598       Elf_Internal_Rela *relstart, *rel, *relend;
7599       Elf_Internal_Shdr *symtab_hdr;
7600       Elf_Internal_Sym *local_syms;
7601       bfd_vma offset;
7602       struct _opd_sec_data *opd;
7603       bfd_boolean need_edit, add_aux_fields;
7604       bfd_size_type cnt_16b = 0;
7605
7606       if (!is_ppc64_elf (ibfd))
7607         continue;
7608
7609       sec = bfd_get_section_by_name (ibfd, ".opd");
7610       if (sec == NULL || sec->size == 0)
7611         continue;
7612
7613       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7614         continue;
7615
7616       if (sec->output_section == bfd_abs_section_ptr)
7617         continue;
7618
7619       /* Look through the section relocs.  */
7620       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7621         continue;
7622
7623       local_syms = NULL;
7624       symtab_hdr = &elf_symtab_hdr (ibfd);
7625
7626       /* Read the relocations.  */
7627       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7628                                             info->keep_memory);
7629       if (relstart == NULL)
7630         return FALSE;
7631
7632       /* First run through the relocs to check they are sane, and to
7633          determine whether we need to edit this opd section.  */
7634       need_edit = FALSE;
7635       need_pad = sec;
7636       offset = 0;
7637       relend = relstart + sec->reloc_count;
7638       for (rel = relstart; rel < relend; )
7639         {
7640           enum elf_ppc64_reloc_type r_type;
7641           unsigned long r_symndx;
7642           asection *sym_sec;
7643           struct elf_link_hash_entry *h;
7644           Elf_Internal_Sym *sym;
7645
7646           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7647              only interested in the reloc pointing to a function entry
7648              point.  */
7649           if (rel->r_offset != offset
7650               || rel + 1 >= relend
7651               || (rel + 1)->r_offset != offset + 8)
7652             {
7653               /* If someone messes with .opd alignment then after a
7654                  "ld -r" we might have padding in the middle of .opd.
7655                  Also, there's nothing to prevent someone putting
7656                  something silly in .opd with the assembler.  No .opd
7657                  optimization for them!  */
7658             broken_opd:
7659               (*_bfd_error_handler)
7660                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7661               need_edit = FALSE;
7662               break;
7663             }
7664
7665           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7666               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7667             {
7668               (*_bfd_error_handler)
7669                 (_("%B: unexpected reloc type %u in .opd section"),
7670                  ibfd, r_type);
7671               need_edit = FALSE;
7672               break;
7673             }
7674
7675           r_symndx = ELF64_R_SYM (rel->r_info);
7676           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7677                           r_symndx, ibfd))
7678             goto error_ret;
7679
7680           if (sym_sec == NULL || sym_sec->owner == NULL)
7681             {
7682               const char *sym_name;
7683               if (h != NULL)
7684                 sym_name = h->root.root.string;
7685               else
7686                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7687                                              sym_sec);
7688
7689               (*_bfd_error_handler)
7690                 (_("%B: undefined sym `%s' in .opd section"),
7691                  ibfd, sym_name);
7692               need_edit = FALSE;
7693               break;
7694             }
7695
7696           /* opd entries are always for functions defined in the
7697              current input bfd.  If the symbol isn't defined in the
7698              input bfd, then we won't be using the function in this
7699              bfd;  It must be defined in a linkonce section in another
7700              bfd, or is weak.  It's also possible that we are
7701              discarding the function due to a linker script /DISCARD/,
7702              which we test for via the output_section.  */
7703           if (sym_sec->owner != ibfd
7704               || sym_sec->output_section == bfd_abs_section_ptr)
7705             need_edit = TRUE;
7706
7707           rel += 2;
7708           if (rel == relend
7709               || (rel + 1 == relend && rel->r_offset == offset + 16))
7710             {
7711               if (sec->size == offset + 24)
7712                 {
7713                   need_pad = NULL;
7714                   break;
7715                 }
7716               if (rel == relend && sec->size == offset + 16)
7717                 {
7718                   cnt_16b++;
7719                   break;
7720                 }
7721               goto broken_opd;
7722             }
7723
7724           if (rel->r_offset == offset + 24)
7725             offset += 24;
7726           else if (rel->r_offset != offset + 16)
7727             goto broken_opd;
7728           else if (rel + 1 < relend
7729                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7730                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7731             {
7732               offset += 16;
7733               cnt_16b++;
7734             }
7735           else if (rel + 2 < relend
7736                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7737                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7738             {
7739               offset += 24;
7740               rel += 1;
7741             }
7742           else
7743             goto broken_opd;
7744         }
7745
7746       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7747
7748       if (need_edit || add_aux_fields)
7749         {
7750           Elf_Internal_Rela *write_rel;
7751           Elf_Internal_Shdr *rel_hdr;
7752           bfd_byte *rptr, *wptr;
7753           bfd_byte *new_contents;
7754           bfd_boolean skip;
7755           long opd_ent_size;
7756           bfd_size_type amt;
7757
7758           new_contents = NULL;
7759           amt = sec->size * sizeof (long) / 8;
7760           opd = &ppc64_elf_section_data (sec)->u.opd;
7761           opd->adjust = bfd_zalloc (sec->owner, amt);
7762           if (opd->adjust == NULL)
7763             return FALSE;
7764           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7765
7766           /* This seems a waste of time as input .opd sections are all
7767              zeros as generated by gcc, but I suppose there's no reason
7768              this will always be so.  We might start putting something in
7769              the third word of .opd entries.  */
7770           if ((sec->flags & SEC_IN_MEMORY) == 0)
7771             {
7772               bfd_byte *loc;
7773               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7774                 {
7775                   if (loc != NULL)
7776                     free (loc);
7777                 error_ret:
7778                   if (local_syms != NULL
7779                       && symtab_hdr->contents != (unsigned char *) local_syms)
7780                     free (local_syms);
7781                   if (elf_section_data (sec)->relocs != relstart)
7782                     free (relstart);
7783                   return FALSE;
7784                 }
7785               sec->contents = loc;
7786               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7787             }
7788
7789           elf_section_data (sec)->relocs = relstart;
7790
7791           new_contents = sec->contents;
7792           if (add_aux_fields)
7793             {
7794               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7795               if (new_contents == NULL)
7796                 return FALSE;
7797               need_pad = FALSE;
7798             }
7799           wptr = new_contents;
7800           rptr = sec->contents;
7801
7802           write_rel = relstart;
7803           skip = FALSE;
7804           offset = 0;
7805           opd_ent_size = 0;
7806           for (rel = relstart; rel < relend; rel++)
7807             {
7808               unsigned long r_symndx;
7809               asection *sym_sec;
7810               struct elf_link_hash_entry *h;
7811               Elf_Internal_Sym *sym;
7812
7813               r_symndx = ELF64_R_SYM (rel->r_info);
7814               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7815                               r_symndx, ibfd))
7816                 goto error_ret;
7817
7818               if (rel->r_offset == offset)
7819                 {
7820                   struct ppc_link_hash_entry *fdh = NULL;
7821
7822                   /* See if the .opd entry is full 24 byte or
7823                      16 byte (with fd_aux entry overlapped with next
7824                      fd_func).  */
7825                   opd_ent_size = 24;
7826                   if ((rel + 2 == relend && sec->size == offset + 16)
7827                       || (rel + 3 < relend
7828                           && rel[2].r_offset == offset + 16
7829                           && rel[3].r_offset == offset + 24
7830                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7831                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7832                     opd_ent_size = 16;
7833
7834                   if (h != NULL
7835                       && h->root.root.string[0] == '.')
7836                     {
7837                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7838                       if (fdh != NULL
7839                           && fdh->elf.root.type != bfd_link_hash_defined
7840                           && fdh->elf.root.type != bfd_link_hash_defweak)
7841                         fdh = NULL;
7842                     }
7843
7844                   skip = (sym_sec->owner != ibfd
7845                           || sym_sec->output_section == bfd_abs_section_ptr);
7846                   if (skip)
7847                     {
7848                       if (fdh != NULL && sym_sec->owner == ibfd)
7849                         {
7850                           /* Arrange for the function descriptor sym
7851                              to be dropped.  */
7852                           fdh->elf.root.u.def.value = 0;
7853                           fdh->elf.root.u.def.section = sym_sec;
7854                         }
7855                       opd->adjust[rel->r_offset / 8] = -1;
7856                     }
7857                   else
7858                     {
7859                       /* We'll be keeping this opd entry.  */
7860
7861                       if (fdh != NULL)
7862                         {
7863                           /* Redefine the function descriptor symbol to
7864                              this location in the opd section.  It is
7865                              necessary to update the value here rather
7866                              than using an array of adjustments as we do
7867                              for local symbols, because various places
7868                              in the generic ELF code use the value
7869                              stored in u.def.value.  */
7870                           fdh->elf.root.u.def.value = wptr - new_contents;
7871                           fdh->adjust_done = 1;
7872                         }
7873
7874                       /* Local syms are a bit tricky.  We could
7875                          tweak them as they can be cached, but
7876                          we'd need to look through the local syms
7877                          for the function descriptor sym which we
7878                          don't have at the moment.  So keep an
7879                          array of adjustments.  */
7880                       opd->adjust[rel->r_offset / 8]
7881                         = (wptr - new_contents) - (rptr - sec->contents);
7882
7883                       if (wptr != rptr)
7884                         memcpy (wptr, rptr, opd_ent_size);
7885                       wptr += opd_ent_size;
7886                       if (add_aux_fields && opd_ent_size == 16)
7887                         {
7888                           memset (wptr, '\0', 8);
7889                           wptr += 8;
7890                         }
7891                     }
7892                   rptr += opd_ent_size;
7893                   offset += opd_ent_size;
7894                 }
7895
7896               if (skip)
7897                 {
7898                   if (!NO_OPD_RELOCS
7899                       && !info->relocatable
7900                       && !dec_dynrel_count (rel->r_info, sec, info,
7901                                             NULL, h, sym))
7902                     goto error_ret;
7903                 }
7904               else
7905                 {
7906                   /* We need to adjust any reloc offsets to point to the
7907                      new opd entries.  While we're at it, we may as well
7908                      remove redundant relocs.  */
7909                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7910                   if (write_rel != rel)
7911                     memcpy (write_rel, rel, sizeof (*rel));
7912                   ++write_rel;
7913                 }
7914             }
7915
7916           sec->size = wptr - new_contents;
7917           sec->reloc_count = write_rel - relstart;
7918           if (add_aux_fields)
7919             {
7920               free (sec->contents);
7921               sec->contents = new_contents;
7922             }
7923
7924           /* Fudge the header size too, as this is used later in
7925              elf_bfd_final_link if we are emitting relocs.  */
7926           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7927           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7928           some_edited = TRUE;
7929         }
7930       else if (elf_section_data (sec)->relocs != relstart)
7931         free (relstart);
7932
7933       if (local_syms != NULL
7934           && symtab_hdr->contents != (unsigned char *) local_syms)
7935         {
7936           if (!info->keep_memory)
7937             free (local_syms);
7938           else
7939             symtab_hdr->contents = (unsigned char *) local_syms;
7940         }
7941     }
7942
7943   if (some_edited)
7944     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7945
7946   /* If we are doing a final link and the last .opd entry is just 16 byte
7947      long, add a 8 byte padding after it.  */
7948   if (need_pad != NULL && !info->relocatable)
7949     {
7950       bfd_byte *p;
7951
7952       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7953         {
7954           BFD_ASSERT (need_pad->size > 0);
7955
7956           p = bfd_malloc (need_pad->size + 8);
7957           if (p == NULL)
7958             return FALSE;
7959
7960           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7961                                           p, 0, need_pad->size))
7962             return FALSE;
7963
7964           need_pad->contents = p;
7965           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7966         }
7967       else
7968         {
7969           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7970           if (p == NULL)
7971             return FALSE;
7972
7973           need_pad->contents = p;
7974         }
7975
7976       memset (need_pad->contents + need_pad->size, 0, 8);
7977       need_pad->size += 8;
7978     }
7979
7980   return TRUE;
7981 }
7982
7983 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7984
7985 asection *
7986 ppc64_elf_tls_setup (struct bfd_link_info *info)
7987 {
7988   struct ppc_link_hash_table *htab;
7989
7990   htab = ppc_hash_table (info);
7991   if (htab == NULL)
7992     return NULL;
7993
7994   if (abiversion (info->output_bfd) == 1)
7995     htab->opd_abi = 1;
7996
7997   if (htab->params->no_multi_toc)
7998     htab->do_multi_toc = 0;
7999   else if (!htab->do_multi_toc)
8000     htab->params->no_multi_toc = 1;
8001
8002   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8003                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8004                                               FALSE, FALSE, TRUE));
8005   /* Move dynamic linking info to the function descriptor sym.  */
8006   if (htab->tls_get_addr != NULL)
8007     func_desc_adjust (&htab->tls_get_addr->elf, info);
8008   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8009                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8010                                                  FALSE, FALSE, TRUE));
8011   if (!htab->params->no_tls_get_addr_opt)
8012     {
8013       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8014
8015       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8016                                   FALSE, FALSE, TRUE);
8017       if (opt != NULL)
8018         func_desc_adjust (opt, info);
8019       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8020                                      FALSE, FALSE, TRUE);
8021       if (opt_fd != NULL
8022           && (opt_fd->root.type == bfd_link_hash_defined
8023               || opt_fd->root.type == bfd_link_hash_defweak))
8024         {
8025           /* If glibc supports an optimized __tls_get_addr call stub,
8026              signalled by the presence of __tls_get_addr_opt, and we'll
8027              be calling __tls_get_addr via a plt call stub, then
8028              make __tls_get_addr point to __tls_get_addr_opt.  */
8029           tga_fd = &htab->tls_get_addr_fd->elf;
8030           if (htab->elf.dynamic_sections_created
8031               && tga_fd != NULL
8032               && (tga_fd->type == STT_FUNC
8033                   || tga_fd->needs_plt)
8034               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8035                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8036                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8037             {
8038               struct plt_entry *ent;
8039
8040               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8041                 if (ent->plt.refcount > 0)
8042                   break;
8043               if (ent != NULL)
8044                 {
8045                   tga_fd->root.type = bfd_link_hash_indirect;
8046                   tga_fd->root.u.i.link = &opt_fd->root;
8047                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8048                   if (opt_fd->dynindx != -1)
8049                     {
8050                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8051                       opt_fd->dynindx = -1;
8052                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8053                                               opt_fd->dynstr_index);
8054                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8055                         return NULL;
8056                     }
8057                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8058                   tga = &htab->tls_get_addr->elf;
8059                   if (opt != NULL && tga != NULL)
8060                     {
8061                       tga->root.type = bfd_link_hash_indirect;
8062                       tga->root.u.i.link = &opt->root;
8063                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8064                       _bfd_elf_link_hash_hide_symbol (info, opt,
8065                                                       tga->forced_local);
8066                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8067                     }
8068                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8069                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8070                   if (htab->tls_get_addr != NULL)
8071                     {
8072                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8073                       htab->tls_get_addr->is_func = 1;
8074                     }
8075                 }
8076             }
8077         }
8078       else
8079         htab->params->no_tls_get_addr_opt = TRUE;
8080     }
8081   return _bfd_elf_tls_setup (info->output_bfd, info);
8082 }
8083
8084 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8085    HASH1 or HASH2.  */
8086
8087 static bfd_boolean
8088 branch_reloc_hash_match (const bfd *ibfd,
8089                          const Elf_Internal_Rela *rel,
8090                          const struct ppc_link_hash_entry *hash1,
8091                          const struct ppc_link_hash_entry *hash2)
8092 {
8093   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8094   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8095   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8096
8097   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8098     {
8099       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8100       struct elf_link_hash_entry *h;
8101
8102       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8103       h = elf_follow_link (h);
8104       if (h == &hash1->elf || h == &hash2->elf)
8105         return TRUE;
8106     }
8107   return FALSE;
8108 }
8109
8110 /* Run through all the TLS relocs looking for optimization
8111    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8112    a preliminary section layout so that we know the TLS segment
8113    offsets.  We can't optimize earlier because some optimizations need
8114    to know the tp offset, and we need to optimize before allocating
8115    dynamic relocations.  */
8116
8117 bfd_boolean
8118 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8119 {
8120   bfd *ibfd;
8121   asection *sec;
8122   struct ppc_link_hash_table *htab;
8123   unsigned char *toc_ref;
8124   int pass;
8125
8126   if (info->relocatable || !info->executable)
8127     return TRUE;
8128
8129   htab = ppc_hash_table (info);
8130   if (htab == NULL)
8131     return FALSE;
8132
8133   /* Make two passes over the relocs.  On the first pass, mark toc
8134      entries involved with tls relocs, and check that tls relocs
8135      involved in setting up a tls_get_addr call are indeed followed by
8136      such a call.  If they are not, we can't do any tls optimization.
8137      On the second pass twiddle tls_mask flags to notify
8138      relocate_section that optimization can be done, and adjust got
8139      and plt refcounts.  */
8140   toc_ref = NULL;
8141   for (pass = 0; pass < 2; ++pass)
8142     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8143       {
8144         Elf_Internal_Sym *locsyms = NULL;
8145         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8146
8147         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8148           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8149             {
8150               Elf_Internal_Rela *relstart, *rel, *relend;
8151               bfd_boolean found_tls_get_addr_arg = 0;
8152
8153               /* Read the relocations.  */
8154               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8155                                                     info->keep_memory);
8156               if (relstart == NULL)
8157                 {
8158                   free (toc_ref);
8159                   return FALSE;
8160                 }
8161
8162               relend = relstart + sec->reloc_count;
8163               for (rel = relstart; rel < relend; rel++)
8164                 {
8165                   enum elf_ppc64_reloc_type r_type;
8166                   unsigned long r_symndx;
8167                   struct elf_link_hash_entry *h;
8168                   Elf_Internal_Sym *sym;
8169                   asection *sym_sec;
8170                   unsigned char *tls_mask;
8171                   unsigned char tls_set, tls_clear, tls_type = 0;
8172                   bfd_vma value;
8173                   bfd_boolean ok_tprel, is_local;
8174                   long toc_ref_index = 0;
8175                   int expecting_tls_get_addr = 0;
8176                   bfd_boolean ret = FALSE;
8177
8178                   r_symndx = ELF64_R_SYM (rel->r_info);
8179                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8180                                   r_symndx, ibfd))
8181                     {
8182                     err_free_rel:
8183                       if (elf_section_data (sec)->relocs != relstart)
8184                         free (relstart);
8185                       if (toc_ref != NULL)
8186                         free (toc_ref);
8187                       if (locsyms != NULL
8188                           && (elf_symtab_hdr (ibfd).contents
8189                               != (unsigned char *) locsyms))
8190                         free (locsyms);
8191                       return ret;
8192                     }
8193
8194                   if (h != NULL)
8195                     {
8196                       if (h->root.type == bfd_link_hash_defined
8197                           || h->root.type == bfd_link_hash_defweak)
8198                         value = h->root.u.def.value;
8199                       else if (h->root.type == bfd_link_hash_undefweak)
8200                         value = 0;
8201                       else
8202                         {
8203                           found_tls_get_addr_arg = 0;
8204                           continue;
8205                         }
8206                     }
8207                   else
8208                     /* Symbols referenced by TLS relocs must be of type
8209                        STT_TLS.  So no need for .opd local sym adjust.  */
8210                     value = sym->st_value;
8211
8212                   ok_tprel = FALSE;
8213                   is_local = FALSE;
8214                   if (h == NULL
8215                       || !h->def_dynamic)
8216                     {
8217                       is_local = TRUE;
8218                       if (h != NULL
8219                           && h->root.type == bfd_link_hash_undefweak)
8220                         ok_tprel = TRUE;
8221                       else
8222                         {
8223                           value += sym_sec->output_offset;
8224                           value += sym_sec->output_section->vma;
8225                           value -= htab->elf.tls_sec->vma;
8226                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8227                                       < (bfd_vma) 1 << 32);
8228                         }
8229                     }
8230
8231                   r_type = ELF64_R_TYPE (rel->r_info);
8232                   /* If this section has old-style __tls_get_addr calls
8233                      without marker relocs, then check that each
8234                      __tls_get_addr call reloc is preceded by a reloc
8235                      that conceivably belongs to the __tls_get_addr arg
8236                      setup insn.  If we don't find matching arg setup
8237                      relocs, don't do any tls optimization.  */
8238                   if (pass == 0
8239                       && sec->has_tls_get_addr_call
8240                       && h != NULL
8241                       && (h == &htab->tls_get_addr->elf
8242                           || h == &htab->tls_get_addr_fd->elf)
8243                       && !found_tls_get_addr_arg
8244                       && is_branch_reloc (r_type))
8245                     {
8246                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8247                                                 "TLS optimization disabled\n"),
8248                                               ibfd, sec, rel->r_offset);
8249                       ret = TRUE;
8250                       goto err_free_rel;
8251                     }
8252
8253                   found_tls_get_addr_arg = 0;
8254                   switch (r_type)
8255                     {
8256                     case R_PPC64_GOT_TLSLD16:
8257                     case R_PPC64_GOT_TLSLD16_LO:
8258                       expecting_tls_get_addr = 1;
8259                       found_tls_get_addr_arg = 1;
8260                       /* Fall thru */
8261
8262                     case R_PPC64_GOT_TLSLD16_HI:
8263                     case R_PPC64_GOT_TLSLD16_HA:
8264                       /* These relocs should never be against a symbol
8265                          defined in a shared lib.  Leave them alone if
8266                          that turns out to be the case.  */
8267                       if (!is_local)
8268                         continue;
8269
8270                       /* LD -> LE */
8271                       tls_set = 0;
8272                       tls_clear = TLS_LD;
8273                       tls_type = TLS_TLS | TLS_LD;
8274                       break;
8275
8276                     case R_PPC64_GOT_TLSGD16:
8277                     case R_PPC64_GOT_TLSGD16_LO:
8278                       expecting_tls_get_addr = 1;
8279                       found_tls_get_addr_arg = 1;
8280                       /* Fall thru */
8281
8282                     case R_PPC64_GOT_TLSGD16_HI:
8283                     case R_PPC64_GOT_TLSGD16_HA:
8284                       if (ok_tprel)
8285                         /* GD -> LE */
8286                         tls_set = 0;
8287                       else
8288                         /* GD -> IE */
8289                         tls_set = TLS_TLS | TLS_TPRELGD;
8290                       tls_clear = TLS_GD;
8291                       tls_type = TLS_TLS | TLS_GD;
8292                       break;
8293
8294                     case R_PPC64_GOT_TPREL16_DS:
8295                     case R_PPC64_GOT_TPREL16_LO_DS:
8296                     case R_PPC64_GOT_TPREL16_HI:
8297                     case R_PPC64_GOT_TPREL16_HA:
8298                       if (ok_tprel)
8299                         {
8300                           /* IE -> LE */
8301                           tls_set = 0;
8302                           tls_clear = TLS_TPREL;
8303                           tls_type = TLS_TLS | TLS_TPREL;
8304                           break;
8305                         }
8306                       continue;
8307
8308                     case R_PPC64_TLSGD:
8309                     case R_PPC64_TLSLD:
8310                       found_tls_get_addr_arg = 1;
8311                       /* Fall thru */
8312
8313                     case R_PPC64_TLS:
8314                     case R_PPC64_TOC16:
8315                     case R_PPC64_TOC16_LO:
8316                       if (sym_sec == NULL || sym_sec != toc)
8317                         continue;
8318
8319                       /* Mark this toc entry as referenced by a TLS
8320                          code sequence.  We can do that now in the
8321                          case of R_PPC64_TLS, and after checking for
8322                          tls_get_addr for the TOC16 relocs.  */
8323                       if (toc_ref == NULL)
8324                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8325                       if (toc_ref == NULL)
8326                         goto err_free_rel;
8327
8328                       if (h != NULL)
8329                         value = h->root.u.def.value;
8330                       else
8331                         value = sym->st_value;
8332                       value += rel->r_addend;
8333                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8334                       toc_ref_index = (value + toc->output_offset) / 8;
8335                       if (r_type == R_PPC64_TLS
8336                           || r_type == R_PPC64_TLSGD
8337                           || r_type == R_PPC64_TLSLD)
8338                         {
8339                           toc_ref[toc_ref_index] = 1;
8340                           continue;
8341                         }
8342
8343                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8344                         continue;
8345
8346                       tls_set = 0;
8347                       tls_clear = 0;
8348                       expecting_tls_get_addr = 2;
8349                       break;
8350
8351                     case R_PPC64_TPREL64:
8352                       if (pass == 0
8353                           || sec != toc
8354                           || toc_ref == NULL
8355                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8356                         continue;
8357                       if (ok_tprel)
8358                         {
8359                           /* IE -> LE */
8360                           tls_set = TLS_EXPLICIT;
8361                           tls_clear = TLS_TPREL;
8362                           break;
8363                         }
8364                       continue;
8365
8366                     case R_PPC64_DTPMOD64:
8367                       if (pass == 0
8368                           || sec != toc
8369                           || toc_ref == NULL
8370                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8371                         continue;
8372                       if (rel + 1 < relend
8373                           && (rel[1].r_info
8374                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8375                           && rel[1].r_offset == rel->r_offset + 8)
8376                         {
8377                           if (ok_tprel)
8378                             /* GD -> LE */
8379                             tls_set = TLS_EXPLICIT | TLS_GD;
8380                           else
8381                             /* GD -> IE */
8382                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8383                           tls_clear = TLS_GD;
8384                         }
8385                       else
8386                         {
8387                           if (!is_local)
8388                             continue;
8389
8390                           /* LD -> LE */
8391                           tls_set = TLS_EXPLICIT;
8392                           tls_clear = TLS_LD;
8393                         }
8394                       break;
8395
8396                     default:
8397                       continue;
8398                     }
8399
8400                   if (pass == 0)
8401                     {
8402                       if (!expecting_tls_get_addr
8403                           || !sec->has_tls_get_addr_call)
8404                         continue;
8405
8406                       if (rel + 1 < relend
8407                           && branch_reloc_hash_match (ibfd, rel + 1,
8408                                                       htab->tls_get_addr,
8409                                                       htab->tls_get_addr_fd))
8410                         {
8411                           if (expecting_tls_get_addr == 2)
8412                             {
8413                               /* Check for toc tls entries.  */
8414                               unsigned char *toc_tls;
8415                               int retval;
8416
8417                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8418                                                      &locsyms,
8419                                                      rel, ibfd);
8420                               if (retval == 0)
8421                                 goto err_free_rel;
8422                               if (toc_tls != NULL)
8423                                 {
8424                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8425                                     found_tls_get_addr_arg = 1;
8426                                   if (retval > 1)
8427                                     toc_ref[toc_ref_index] = 1;
8428                                 }
8429                             }
8430                           continue;
8431                         }
8432
8433                       if (expecting_tls_get_addr != 1)
8434                         continue;
8435
8436                       /* Uh oh, we didn't find the expected call.  We
8437                          could just mark this symbol to exclude it
8438                          from tls optimization but it's safer to skip
8439                          the entire optimization.  */
8440                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8441                                                 "TLS optimization disabled\n"),
8442                                               ibfd, sec, rel->r_offset);
8443                       ret = TRUE;
8444                       goto err_free_rel;
8445                     }
8446
8447                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8448                     {
8449                       struct plt_entry *ent;
8450                       for (ent = htab->tls_get_addr->elf.plt.plist;
8451                            ent != NULL;
8452                            ent = ent->next)
8453                         if (ent->addend == 0)
8454                           {
8455                             if (ent->plt.refcount > 0)
8456                               {
8457                                 ent->plt.refcount -= 1;
8458                                 expecting_tls_get_addr = 0;
8459                               }
8460                             break;
8461                           }
8462                     }
8463
8464                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8465                     {
8466                       struct plt_entry *ent;
8467                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8468                            ent != NULL;
8469                            ent = ent->next)
8470                         if (ent->addend == 0)
8471                           {
8472                             if (ent->plt.refcount > 0)
8473                               ent->plt.refcount -= 1;
8474                             break;
8475                           }
8476                     }
8477
8478                   if (tls_clear == 0)
8479                     continue;
8480
8481                   if ((tls_set & TLS_EXPLICIT) == 0)
8482                     {
8483                       struct got_entry *ent;
8484
8485                       /* Adjust got entry for this reloc.  */
8486                       if (h != NULL)
8487                         ent = h->got.glist;
8488                       else
8489                         ent = elf_local_got_ents (ibfd)[r_symndx];
8490
8491                       for (; ent != NULL; ent = ent->next)
8492                         if (ent->addend == rel->r_addend
8493                             && ent->owner == ibfd
8494                             && ent->tls_type == tls_type)
8495                           break;
8496                       if (ent == NULL)
8497                         abort ();
8498
8499                       if (tls_set == 0)
8500                         {
8501                           /* We managed to get rid of a got entry.  */
8502                           if (ent->got.refcount > 0)
8503                             ent->got.refcount -= 1;
8504                         }
8505                     }
8506                   else
8507                     {
8508                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8509                          we'll lose one or two dyn relocs.  */
8510                       if (!dec_dynrel_count (rel->r_info, sec, info,
8511                                              NULL, h, sym))
8512                         return FALSE;
8513
8514                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8515                         {
8516                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8517                                                  NULL, h, sym))
8518                             return FALSE;
8519                         }
8520                     }
8521
8522                   *tls_mask |= tls_set;
8523                   *tls_mask &= ~tls_clear;
8524                 }
8525
8526               if (elf_section_data (sec)->relocs != relstart)
8527                 free (relstart);
8528             }
8529
8530         if (locsyms != NULL
8531             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8532           {
8533             if (!info->keep_memory)
8534               free (locsyms);
8535             else
8536               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8537           }
8538       }
8539
8540   if (toc_ref != NULL)
8541     free (toc_ref);
8542   return TRUE;
8543 }
8544
8545 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8546    the values of any global symbols in a toc section that has been
8547    edited.  Globals in toc sections should be a rarity, so this function
8548    sets a flag if any are found in toc sections other than the one just
8549    edited, so that futher hash table traversals can be avoided.  */
8550
8551 struct adjust_toc_info
8552 {
8553   asection *toc;
8554   unsigned long *skip;
8555   bfd_boolean global_toc_syms;
8556 };
8557
8558 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8559
8560 static bfd_boolean
8561 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8562 {
8563   struct ppc_link_hash_entry *eh;
8564   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8565   unsigned long i;
8566
8567   if (h->root.type != bfd_link_hash_defined
8568       && h->root.type != bfd_link_hash_defweak)
8569     return TRUE;
8570
8571   eh = (struct ppc_link_hash_entry *) h;
8572   if (eh->adjust_done)
8573     return TRUE;
8574
8575   if (eh->elf.root.u.def.section == toc_inf->toc)
8576     {
8577       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8578         i = toc_inf->toc->rawsize >> 3;
8579       else
8580         i = eh->elf.root.u.def.value >> 3;
8581
8582       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8583         {
8584           (*_bfd_error_handler)
8585             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8586           do
8587             ++i;
8588           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8589           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8590         }
8591
8592       eh->elf.root.u.def.value -= toc_inf->skip[i];
8593       eh->adjust_done = 1;
8594     }
8595   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8596     toc_inf->global_toc_syms = TRUE;
8597
8598   return TRUE;
8599 }
8600
8601 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8602
8603 static bfd_boolean
8604 ok_lo_toc_insn (unsigned int insn)
8605 {
8606   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8607           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8608           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8609           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8610           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8611           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8612           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8613           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8614           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8615           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8616           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8617           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8618           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8619           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8620           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8621               && (insn & 3) != 1)
8622           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8623               && ((insn & 3) == 0 || (insn & 3) == 3))
8624           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8625 }
8626
8627 /* Examine all relocs referencing .toc sections in order to remove
8628    unused .toc entries.  */
8629
8630 bfd_boolean
8631 ppc64_elf_edit_toc (struct bfd_link_info *info)
8632 {
8633   bfd *ibfd;
8634   struct adjust_toc_info toc_inf;
8635   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8636
8637   htab->do_toc_opt = 1;
8638   toc_inf.global_toc_syms = TRUE;
8639   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8640     {
8641       asection *toc, *sec;
8642       Elf_Internal_Shdr *symtab_hdr;
8643       Elf_Internal_Sym *local_syms;
8644       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8645       unsigned long *skip, *drop;
8646       unsigned char *used;
8647       unsigned char *keep, last, some_unused;
8648
8649       if (!is_ppc64_elf (ibfd))
8650         continue;
8651
8652       toc = bfd_get_section_by_name (ibfd, ".toc");
8653       if (toc == NULL
8654           || toc->size == 0
8655           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8656           || discarded_section (toc))
8657         continue;
8658
8659       toc_relocs = NULL;
8660       local_syms = NULL;
8661       symtab_hdr = &elf_symtab_hdr (ibfd);
8662
8663       /* Look at sections dropped from the final link.  */
8664       skip = NULL;
8665       relstart = NULL;
8666       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8667         {
8668           if (sec->reloc_count == 0
8669               || !discarded_section (sec)
8670               || get_opd_info (sec)
8671               || (sec->flags & SEC_ALLOC) == 0
8672               || (sec->flags & SEC_DEBUGGING) != 0)
8673             continue;
8674
8675           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8676           if (relstart == NULL)
8677             goto error_ret;
8678
8679           /* Run through the relocs to see which toc entries might be
8680              unused.  */
8681           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8682             {
8683               enum elf_ppc64_reloc_type r_type;
8684               unsigned long r_symndx;
8685               asection *sym_sec;
8686               struct elf_link_hash_entry *h;
8687               Elf_Internal_Sym *sym;
8688               bfd_vma val;
8689
8690               r_type = ELF64_R_TYPE (rel->r_info);
8691               switch (r_type)
8692                 {
8693                 default:
8694                   continue;
8695
8696                 case R_PPC64_TOC16:
8697                 case R_PPC64_TOC16_LO:
8698                 case R_PPC64_TOC16_HI:
8699                 case R_PPC64_TOC16_HA:
8700                 case R_PPC64_TOC16_DS:
8701                 case R_PPC64_TOC16_LO_DS:
8702                   break;
8703                 }
8704
8705               r_symndx = ELF64_R_SYM (rel->r_info);
8706               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8707                               r_symndx, ibfd))
8708                 goto error_ret;
8709
8710               if (sym_sec != toc)
8711                 continue;
8712
8713               if (h != NULL)
8714                 val = h->root.u.def.value;
8715               else
8716                 val = sym->st_value;
8717               val += rel->r_addend;
8718
8719               if (val >= toc->size)
8720                 continue;
8721
8722               /* Anything in the toc ought to be aligned to 8 bytes.
8723                  If not, don't mark as unused.  */
8724               if (val & 7)
8725                 continue;
8726
8727               if (skip == NULL)
8728                 {
8729                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8730                   if (skip == NULL)
8731                     goto error_ret;
8732                 }
8733
8734               skip[val >> 3] = ref_from_discarded;
8735             }
8736
8737           if (elf_section_data (sec)->relocs != relstart)
8738             free (relstart);
8739         }
8740
8741       /* For largetoc loads of address constants, we can convert
8742          .  addis rx,2,addr@got@ha
8743          .  ld ry,addr@got@l(rx)
8744          to
8745          .  addis rx,2,addr@toc@ha
8746          .  addi ry,rx,addr@toc@l
8747          when addr is within 2G of the toc pointer.  This then means
8748          that the word storing "addr" in the toc is no longer needed.  */
8749
8750       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8751           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8752           && toc->reloc_count != 0)
8753         {
8754           /* Read toc relocs.  */
8755           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8756                                                   info->keep_memory);
8757           if (toc_relocs == NULL)
8758             goto error_ret;
8759
8760           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8761             {
8762               enum elf_ppc64_reloc_type r_type;
8763               unsigned long r_symndx;
8764               asection *sym_sec;
8765               struct elf_link_hash_entry *h;
8766               Elf_Internal_Sym *sym;
8767               bfd_vma val, addr;
8768
8769               r_type = ELF64_R_TYPE (rel->r_info);
8770               if (r_type != R_PPC64_ADDR64)
8771                 continue;
8772
8773               r_symndx = ELF64_R_SYM (rel->r_info);
8774               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8775                               r_symndx, ibfd))
8776                 goto error_ret;
8777
8778               if (sym_sec == NULL
8779                   || discarded_section (sym_sec))
8780                 continue;
8781
8782               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8783                 continue;
8784
8785               if (h != NULL)
8786                 {
8787                   if (h->type == STT_GNU_IFUNC)
8788                     continue;
8789                   val = h->root.u.def.value;
8790                 }
8791               else
8792                 {
8793                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8794                     continue;
8795                   val = sym->st_value;
8796                 }
8797               val += rel->r_addend;
8798               val += sym_sec->output_section->vma + sym_sec->output_offset;
8799
8800               /* We don't yet know the exact toc pointer value, but we
8801                  know it will be somewhere in the toc section.  Don't
8802                  optimize if the difference from any possible toc
8803                  pointer is outside [ff..f80008000, 7fff7fff].  */
8804               addr = toc->output_section->vma + TOC_BASE_OFF;
8805               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8806                 continue;
8807
8808               addr = toc->output_section->vma + toc->output_section->rawsize;
8809               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8810                 continue;
8811
8812               if (skip == NULL)
8813                 {
8814                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8815                   if (skip == NULL)
8816                     goto error_ret;
8817                 }
8818
8819               skip[rel->r_offset >> 3]
8820                 |= can_optimize | ((rel - toc_relocs) << 2);
8821             }
8822         }
8823
8824       if (skip == NULL)
8825         continue;
8826
8827       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8828       if (used == NULL)
8829         {
8830         error_ret:
8831           if (local_syms != NULL
8832               && symtab_hdr->contents != (unsigned char *) local_syms)
8833             free (local_syms);
8834           if (sec != NULL
8835               && relstart != NULL
8836               && elf_section_data (sec)->relocs != relstart)
8837             free (relstart);
8838           if (toc_relocs != NULL
8839               && elf_section_data (toc)->relocs != toc_relocs)
8840             free (toc_relocs);
8841           if (skip != NULL)
8842             free (skip);
8843           return FALSE;
8844         }
8845
8846       /* Now check all kept sections that might reference the toc.
8847          Check the toc itself last.  */
8848       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8849                   : ibfd->sections);
8850            sec != NULL;
8851            sec = (sec == toc ? NULL
8852                   : sec->next == NULL ? toc
8853                   : sec->next == toc && toc->next ? toc->next
8854                   : sec->next))
8855         {
8856           int repeat;
8857
8858           if (sec->reloc_count == 0
8859               || discarded_section (sec)
8860               || get_opd_info (sec)
8861               || (sec->flags & SEC_ALLOC) == 0
8862               || (sec->flags & SEC_DEBUGGING) != 0)
8863             continue;
8864
8865           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8866                                                 info->keep_memory);
8867           if (relstart == NULL)
8868             {
8869               free (used);
8870               goto error_ret;
8871             }
8872
8873           /* Mark toc entries referenced as used.  */
8874           do
8875             {
8876               repeat = 0;
8877               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8878                 {
8879                   enum elf_ppc64_reloc_type r_type;
8880                   unsigned long r_symndx;
8881                   asection *sym_sec;
8882                   struct elf_link_hash_entry *h;
8883                   Elf_Internal_Sym *sym;
8884                   bfd_vma val;
8885                   enum {no_check, check_lo, check_ha} insn_check;
8886
8887                   r_type = ELF64_R_TYPE (rel->r_info);
8888                   switch (r_type)
8889                     {
8890                     default:
8891                       insn_check = no_check;
8892                       break;
8893
8894                     case R_PPC64_GOT_TLSLD16_HA:
8895                     case R_PPC64_GOT_TLSGD16_HA:
8896                     case R_PPC64_GOT_TPREL16_HA:
8897                     case R_PPC64_GOT_DTPREL16_HA:
8898                     case R_PPC64_GOT16_HA:
8899                     case R_PPC64_TOC16_HA:
8900                       insn_check = check_ha;
8901                       break;
8902
8903                     case R_PPC64_GOT_TLSLD16_LO:
8904                     case R_PPC64_GOT_TLSGD16_LO:
8905                     case R_PPC64_GOT_TPREL16_LO_DS:
8906                     case R_PPC64_GOT_DTPREL16_LO_DS:
8907                     case R_PPC64_GOT16_LO:
8908                     case R_PPC64_GOT16_LO_DS:
8909                     case R_PPC64_TOC16_LO:
8910                     case R_PPC64_TOC16_LO_DS:
8911                       insn_check = check_lo;
8912                       break;
8913                     }
8914
8915                   if (insn_check != no_check)
8916                     {
8917                       bfd_vma off = rel->r_offset & ~3;
8918                       unsigned char buf[4];
8919                       unsigned int insn;
8920
8921                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8922                         {
8923                           free (used);
8924                           goto error_ret;
8925                         }
8926                       insn = bfd_get_32 (ibfd, buf);
8927                       if (insn_check == check_lo
8928                           ? !ok_lo_toc_insn (insn)
8929                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8930                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8931                         {
8932                           char str[12];
8933
8934                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8935                           sprintf (str, "%#08x", insn);
8936                           info->callbacks->einfo
8937                             (_("%P: %H: toc optimization is not supported for"
8938                                " %s instruction.\n"),
8939                              ibfd, sec, rel->r_offset & ~3, str);
8940                         }
8941                     }
8942
8943                   switch (r_type)
8944                     {
8945                     case R_PPC64_TOC16:
8946                     case R_PPC64_TOC16_LO:
8947                     case R_PPC64_TOC16_HI:
8948                     case R_PPC64_TOC16_HA:
8949                     case R_PPC64_TOC16_DS:
8950                     case R_PPC64_TOC16_LO_DS:
8951                       /* In case we're taking addresses of toc entries.  */
8952                     case R_PPC64_ADDR64:
8953                       break;
8954
8955                     default:
8956                       continue;
8957                     }
8958
8959                   r_symndx = ELF64_R_SYM (rel->r_info);
8960                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8961                                   r_symndx, ibfd))
8962                     {
8963                       free (used);
8964                       goto error_ret;
8965                     }
8966
8967                   if (sym_sec != toc)
8968                     continue;
8969
8970                   if (h != NULL)
8971                     val = h->root.u.def.value;
8972                   else
8973                     val = sym->st_value;
8974                   val += rel->r_addend;
8975
8976                   if (val >= toc->size)
8977                     continue;
8978
8979                   if ((skip[val >> 3] & can_optimize) != 0)
8980                     {
8981                       bfd_vma off;
8982                       unsigned char opc;
8983
8984                       switch (r_type)
8985                         {
8986                         case R_PPC64_TOC16_HA:
8987                           break;
8988
8989                         case R_PPC64_TOC16_LO_DS:
8990                           off = rel->r_offset;
8991                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8992                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8993                                                          off, 1))
8994                             {
8995                               free (used);
8996                               goto error_ret;
8997                             }
8998                           if ((opc & (0x3f << 2)) == (58u << 2))
8999                             break;
9000                           /* Fall thru */
9001
9002                         default:
9003                           /* Wrong sort of reloc, or not a ld.  We may
9004                              as well clear ref_from_discarded too.  */
9005                           skip[val >> 3] = 0;
9006                         }
9007                     }
9008
9009                   if (sec != toc)
9010                     used[val >> 3] = 1;
9011                   /* For the toc section, we only mark as used if this
9012                      entry itself isn't unused.  */
9013                   else if ((used[rel->r_offset >> 3]
9014                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9015                            && !used[val >> 3])
9016                     {
9017                       /* Do all the relocs again, to catch reference
9018                          chains.  */
9019                       repeat = 1;
9020                       used[val >> 3] = 1;
9021                     }
9022                 }
9023             }
9024           while (repeat);
9025
9026           if (elf_section_data (sec)->relocs != relstart)
9027             free (relstart);
9028         }
9029
9030       /* Merge the used and skip arrays.  Assume that TOC
9031          doublewords not appearing as either used or unused belong
9032          to to an entry more than one doubleword in size.  */
9033       for (drop = skip, keep = used, last = 0, some_unused = 0;
9034            drop < skip + (toc->size + 7) / 8;
9035            ++drop, ++keep)
9036         {
9037           if (*keep)
9038             {
9039               *drop &= ~ref_from_discarded;
9040               if ((*drop & can_optimize) != 0)
9041                 some_unused = 1;
9042               last = 0;
9043             }
9044           else if ((*drop & ref_from_discarded) != 0)
9045             {
9046               some_unused = 1;
9047               last = ref_from_discarded;
9048             }
9049           else
9050             *drop = last;
9051         }
9052
9053       free (used);
9054
9055       if (some_unused)
9056         {
9057           bfd_byte *contents, *src;
9058           unsigned long off;
9059           Elf_Internal_Sym *sym;
9060           bfd_boolean local_toc_syms = FALSE;
9061
9062           /* Shuffle the toc contents, and at the same time convert the
9063              skip array from booleans into offsets.  */
9064           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9065             goto error_ret;
9066
9067           elf_section_data (toc)->this_hdr.contents = contents;
9068
9069           for (src = contents, off = 0, drop = skip;
9070                src < contents + toc->size;
9071                src += 8, ++drop)
9072             {
9073               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9074                 off += 8;
9075               else if (off != 0)
9076                 {
9077                   *drop = off;
9078                   memcpy (src - off, src, 8);
9079                 }
9080             }
9081           *drop = off;
9082           toc->rawsize = toc->size;
9083           toc->size = src - contents - off;
9084
9085           /* Adjust addends for relocs against the toc section sym,
9086              and optimize any accesses we can.  */
9087           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9088             {
9089               if (sec->reloc_count == 0
9090                   || discarded_section (sec))
9091                 continue;
9092
9093               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9094                                                     info->keep_memory);
9095               if (relstart == NULL)
9096                 goto error_ret;
9097
9098               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9099                 {
9100                   enum elf_ppc64_reloc_type r_type;
9101                   unsigned long r_symndx;
9102                   asection *sym_sec;
9103                   struct elf_link_hash_entry *h;
9104                   bfd_vma val;
9105
9106                   r_type = ELF64_R_TYPE (rel->r_info);
9107                   switch (r_type)
9108                     {
9109                     default:
9110                       continue;
9111
9112                     case R_PPC64_TOC16:
9113                     case R_PPC64_TOC16_LO:
9114                     case R_PPC64_TOC16_HI:
9115                     case R_PPC64_TOC16_HA:
9116                     case R_PPC64_TOC16_DS:
9117                     case R_PPC64_TOC16_LO_DS:
9118                     case R_PPC64_ADDR64:
9119                       break;
9120                     }
9121
9122                   r_symndx = ELF64_R_SYM (rel->r_info);
9123                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9124                                   r_symndx, ibfd))
9125                     goto error_ret;
9126
9127                   if (sym_sec != toc)
9128                     continue;
9129
9130                   if (h != NULL)
9131                     val = h->root.u.def.value;
9132                   else
9133                     {
9134                       val = sym->st_value;
9135                       if (val != 0)
9136                         local_toc_syms = TRUE;
9137                     }
9138
9139                   val += rel->r_addend;
9140
9141                   if (val > toc->rawsize)
9142                     val = toc->rawsize;
9143                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9144                     continue;
9145                   else if ((skip[val >> 3] & can_optimize) != 0)
9146                     {
9147                       Elf_Internal_Rela *tocrel
9148                         = toc_relocs + (skip[val >> 3] >> 2);
9149                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9150
9151                       switch (r_type)
9152                         {
9153                         case R_PPC64_TOC16_HA:
9154                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9155                           break;
9156
9157                         case R_PPC64_TOC16_LO_DS:
9158                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9159                           break;
9160
9161                         default:
9162                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9163                             ppc_howto_init ();
9164                           info->callbacks->einfo
9165                             (_("%P: %H: %s references "
9166                                "optimized away TOC entry\n"),
9167                              ibfd, sec, rel->r_offset,
9168                              ppc64_elf_howto_table[r_type]->name);
9169                           bfd_set_error (bfd_error_bad_value);
9170                           goto error_ret;
9171                         }
9172                       rel->r_addend = tocrel->r_addend;
9173                       elf_section_data (sec)->relocs = relstart;
9174                       continue;
9175                     }
9176
9177                   if (h != NULL || sym->st_value != 0)
9178                     continue;
9179
9180                   rel->r_addend -= skip[val >> 3];
9181                   elf_section_data (sec)->relocs = relstart;
9182                 }
9183
9184               if (elf_section_data (sec)->relocs != relstart)
9185                 free (relstart);
9186             }
9187
9188           /* We shouldn't have local or global symbols defined in the TOC,
9189              but handle them anyway.  */
9190           if (local_syms != NULL)
9191             for (sym = local_syms;
9192                  sym < local_syms + symtab_hdr->sh_info;
9193                  ++sym)
9194               if (sym->st_value != 0
9195                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9196                 {
9197                   unsigned long i;
9198
9199                   if (sym->st_value > toc->rawsize)
9200                     i = toc->rawsize >> 3;
9201                   else
9202                     i = sym->st_value >> 3;
9203
9204                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9205                     {
9206                       if (local_toc_syms)
9207                         (*_bfd_error_handler)
9208                           (_("%s defined on removed toc entry"),
9209                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9210                       do
9211                         ++i;
9212                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9213                       sym->st_value = (bfd_vma) i << 3;
9214                     }
9215
9216                   sym->st_value -= skip[i];
9217                   symtab_hdr->contents = (unsigned char *) local_syms;
9218                 }
9219
9220           /* Adjust any global syms defined in this toc input section.  */
9221           if (toc_inf.global_toc_syms)
9222             {
9223               toc_inf.toc = toc;
9224               toc_inf.skip = skip;
9225               toc_inf.global_toc_syms = FALSE;
9226               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9227                                       &toc_inf);
9228             }
9229
9230           if (toc->reloc_count != 0)
9231             {
9232               Elf_Internal_Shdr *rel_hdr;
9233               Elf_Internal_Rela *wrel;
9234               bfd_size_type sz;
9235
9236               /* Remove unused toc relocs, and adjust those we keep.  */
9237               if (toc_relocs == NULL)
9238                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9239                                                         info->keep_memory);
9240               if (toc_relocs == NULL)
9241                 goto error_ret;
9242
9243               wrel = toc_relocs;
9244               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9245                 if ((skip[rel->r_offset >> 3]
9246                      & (ref_from_discarded | can_optimize)) == 0)
9247                   {
9248                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9249                     wrel->r_info = rel->r_info;
9250                     wrel->r_addend = rel->r_addend;
9251                     ++wrel;
9252                   }
9253                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9254                                             &local_syms, NULL, NULL))
9255                   goto error_ret;
9256
9257               elf_section_data (toc)->relocs = toc_relocs;
9258               toc->reloc_count = wrel - toc_relocs;
9259               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9260               sz = rel_hdr->sh_entsize;
9261               rel_hdr->sh_size = toc->reloc_count * sz;
9262             }
9263         }
9264       else if (toc_relocs != NULL
9265                && elf_section_data (toc)->relocs != toc_relocs)
9266         free (toc_relocs);
9267
9268       if (local_syms != NULL
9269           && symtab_hdr->contents != (unsigned char *) local_syms)
9270         {
9271           if (!info->keep_memory)
9272             free (local_syms);
9273           else
9274             symtab_hdr->contents = (unsigned char *) local_syms;
9275         }
9276       free (skip);
9277     }
9278
9279   return TRUE;
9280 }
9281
9282 /* Return true iff input section I references the TOC using
9283    instructions limited to +/-32k offsets.  */
9284
9285 bfd_boolean
9286 ppc64_elf_has_small_toc_reloc (asection *i)
9287 {
9288   return (is_ppc64_elf (i->owner)
9289           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9290 }
9291
9292 /* Allocate space for one GOT entry.  */
9293
9294 static void
9295 allocate_got (struct elf_link_hash_entry *h,
9296               struct bfd_link_info *info,
9297               struct got_entry *gent)
9298 {
9299   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9300   bfd_boolean dyn;
9301   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9302   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9303                  ? 16 : 8);
9304   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9305                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9306   asection *got = ppc64_elf_tdata (gent->owner)->got;
9307
9308   gent->got.offset = got->size;
9309   got->size += entsize;
9310
9311   dyn = htab->elf.dynamic_sections_created;
9312   if (h->type == STT_GNU_IFUNC)
9313     {
9314       htab->elf.irelplt->size += rentsize;
9315       htab->got_reli_size += rentsize;
9316     }
9317   else if ((info->shared
9318             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9319            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9320                || h->root.type != bfd_link_hash_undefweak))
9321     {
9322       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9323       relgot->size += rentsize;
9324     }
9325 }
9326
9327 /* This function merges got entries in the same toc group.  */
9328
9329 static void
9330 merge_got_entries (struct got_entry **pent)
9331 {
9332   struct got_entry *ent, *ent2;
9333
9334   for (ent = *pent; ent != NULL; ent = ent->next)
9335     if (!ent->is_indirect)
9336       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9337         if (!ent2->is_indirect
9338             && ent2->addend == ent->addend
9339             && ent2->tls_type == ent->tls_type
9340             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9341           {
9342             ent2->is_indirect = TRUE;
9343             ent2->got.ent = ent;
9344           }
9345 }
9346
9347 /* Allocate space in .plt, .got and associated reloc sections for
9348    dynamic relocs.  */
9349
9350 static bfd_boolean
9351 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9352 {
9353   struct bfd_link_info *info;
9354   struct ppc_link_hash_table *htab;
9355   asection *s;
9356   struct ppc_link_hash_entry *eh;
9357   struct elf_dyn_relocs *p;
9358   struct got_entry **pgent, *gent;
9359
9360   if (h->root.type == bfd_link_hash_indirect)
9361     return TRUE;
9362
9363   info = (struct bfd_link_info *) inf;
9364   htab = ppc_hash_table (info);
9365   if (htab == NULL)
9366     return FALSE;
9367
9368   if ((htab->elf.dynamic_sections_created
9369        && h->dynindx != -1
9370        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9371       || h->type == STT_GNU_IFUNC)
9372     {
9373       struct plt_entry *pent;
9374       bfd_boolean doneone = FALSE;
9375       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9376         if (pent->plt.refcount > 0)
9377           {
9378             if (!htab->elf.dynamic_sections_created
9379                 || h->dynindx == -1)
9380               {
9381                 s = htab->elf.iplt;
9382                 pent->plt.offset = s->size;
9383                 s->size += PLT_ENTRY_SIZE (htab);
9384                 s = htab->elf.irelplt;
9385               }
9386             else
9387               {
9388                 /* If this is the first .plt entry, make room for the special
9389                    first entry.  */
9390                 s = htab->elf.splt;
9391                 if (s->size == 0)
9392                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9393
9394                 pent->plt.offset = s->size;
9395
9396                 /* Make room for this entry.  */
9397                 s->size += PLT_ENTRY_SIZE (htab);
9398
9399                 /* Make room for the .glink code.  */
9400                 s = htab->glink;
9401                 if (s->size == 0)
9402                   s->size += GLINK_CALL_STUB_SIZE;
9403                 if (htab->opd_abi)
9404                   {
9405                     /* We need bigger stubs past index 32767.  */
9406                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9407                       s->size += 4;
9408                     s->size += 2*4;
9409                   }
9410                 else
9411                   s->size += 4;
9412
9413                 /* We also need to make an entry in the .rela.plt section.  */
9414                 s = htab->elf.srelplt;
9415               }
9416             s->size += sizeof (Elf64_External_Rela);
9417             doneone = TRUE;
9418           }
9419         else
9420           pent->plt.offset = (bfd_vma) -1;
9421       if (!doneone)
9422         {
9423           h->plt.plist = NULL;
9424           h->needs_plt = 0;
9425         }
9426     }
9427   else
9428     {
9429       h->plt.plist = NULL;
9430       h->needs_plt = 0;
9431     }
9432
9433   eh = (struct ppc_link_hash_entry *) h;
9434   /* Run through the TLS GD got entries first if we're changing them
9435      to TPREL.  */
9436   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9437     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9438       if (gent->got.refcount > 0
9439           && (gent->tls_type & TLS_GD) != 0)
9440         {
9441           /* This was a GD entry that has been converted to TPREL.  If
9442              there happens to be a TPREL entry we can use that one.  */
9443           struct got_entry *ent;
9444           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9445             if (ent->got.refcount > 0
9446                 && (ent->tls_type & TLS_TPREL) != 0
9447                 && ent->addend == gent->addend
9448                 && ent->owner == gent->owner)
9449               {
9450                 gent->got.refcount = 0;
9451                 break;
9452               }
9453
9454           /* If not, then we'll be using our own TPREL entry.  */
9455           if (gent->got.refcount != 0)
9456             gent->tls_type = TLS_TLS | TLS_TPREL;
9457         }
9458
9459   /* Remove any list entry that won't generate a word in the GOT before
9460      we call merge_got_entries.  Otherwise we risk merging to empty
9461      entries.  */
9462   pgent = &h->got.glist;
9463   while ((gent = *pgent) != NULL)
9464     if (gent->got.refcount > 0)
9465       {
9466         if ((gent->tls_type & TLS_LD) != 0
9467             && !h->def_dynamic)
9468           {
9469             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9470             *pgent = gent->next;
9471           }
9472         else
9473           pgent = &gent->next;
9474       }
9475     else
9476       *pgent = gent->next;
9477
9478   if (!htab->do_multi_toc)
9479     merge_got_entries (&h->got.glist);
9480
9481   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9482     if (!gent->is_indirect)
9483       {
9484         /* Make sure this symbol is output as a dynamic symbol.
9485            Undefined weak syms won't yet be marked as dynamic,
9486            nor will all TLS symbols.  */
9487         if (h->dynindx == -1
9488             && !h->forced_local
9489             && h->type != STT_GNU_IFUNC
9490             && htab->elf.dynamic_sections_created)
9491           {
9492             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9493               return FALSE;
9494           }
9495
9496         if (!is_ppc64_elf (gent->owner))
9497           abort ();
9498
9499         allocate_got (h, info, gent);
9500       }
9501
9502   if (eh->dyn_relocs == NULL
9503       || (!htab->elf.dynamic_sections_created
9504           && h->type != STT_GNU_IFUNC))
9505     return TRUE;
9506
9507   /* In the shared -Bsymbolic case, discard space allocated for
9508      dynamic pc-relative relocs against symbols which turn out to be
9509      defined in regular objects.  For the normal shared case, discard
9510      space for relocs that have become local due to symbol visibility
9511      changes.  */
9512
9513   if (info->shared)
9514     {
9515       /* Relocs that use pc_count are those that appear on a call insn,
9516          or certain REL relocs (see must_be_dyn_reloc) that can be
9517          generated via assembly.  We want calls to protected symbols to
9518          resolve directly to the function rather than going via the plt.
9519          If people want function pointer comparisons to work as expected
9520          then they should avoid writing weird assembly.  */
9521       if (SYMBOL_CALLS_LOCAL (info, h))
9522         {
9523           struct elf_dyn_relocs **pp;
9524
9525           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9526             {
9527               p->count -= p->pc_count;
9528               p->pc_count = 0;
9529               if (p->count == 0)
9530                 *pp = p->next;
9531               else
9532                 pp = &p->next;
9533             }
9534         }
9535
9536       /* Also discard relocs on undefined weak syms with non-default
9537          visibility.  */
9538       if (eh->dyn_relocs != NULL
9539           && h->root.type == bfd_link_hash_undefweak)
9540         {
9541           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9542             eh->dyn_relocs = NULL;
9543
9544           /* Make sure this symbol is output as a dynamic symbol.
9545              Undefined weak syms won't yet be marked as dynamic.  */
9546           else if (h->dynindx == -1
9547                    && !h->forced_local)
9548             {
9549               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9550                 return FALSE;
9551             }
9552         }
9553     }
9554   else if (h->type == STT_GNU_IFUNC)
9555     {
9556       if (!h->non_got_ref)
9557         eh->dyn_relocs = NULL;
9558     }
9559   else if (ELIMINATE_COPY_RELOCS)
9560     {
9561       /* For the non-shared case, discard space for relocs against
9562          symbols which turn out to need copy relocs or are not
9563          dynamic.  */
9564
9565       if (!h->non_got_ref
9566           && !h->def_regular)
9567         {
9568           /* Make sure this symbol is output as a dynamic symbol.
9569              Undefined weak syms won't yet be marked as dynamic.  */
9570           if (h->dynindx == -1
9571               && !h->forced_local)
9572             {
9573               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9574                 return FALSE;
9575             }
9576
9577           /* If that succeeded, we know we'll be keeping all the
9578              relocs.  */
9579           if (h->dynindx != -1)
9580             goto keep;
9581         }
9582
9583       eh->dyn_relocs = NULL;
9584
9585     keep: ;
9586     }
9587
9588   /* Finally, allocate space.  */
9589   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9590     {
9591       asection *sreloc = elf_section_data (p->sec)->sreloc;
9592       if (eh->elf.type == STT_GNU_IFUNC)
9593         sreloc = htab->elf.irelplt;
9594       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9595     }
9596
9597   return TRUE;
9598 }
9599
9600 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9601    to set up space for global entry stubs.  These are put in glink,
9602    after the branch table.  */
9603
9604 static bfd_boolean
9605 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9606 {
9607   struct bfd_link_info *info;
9608   struct ppc_link_hash_table *htab;
9609   struct plt_entry *pent;
9610   asection *s;
9611
9612   if (h->root.type == bfd_link_hash_indirect)
9613     return TRUE;
9614
9615   if (!h->pointer_equality_needed)
9616     return TRUE;
9617
9618   if (h->def_regular)
9619     return TRUE;
9620
9621   info = inf;
9622   htab = ppc_hash_table (info);
9623   if (htab == NULL)
9624     return FALSE;
9625
9626   s = htab->glink;
9627   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9628     if (pent->plt.offset != (bfd_vma) -1
9629         && pent->addend == 0)
9630       {
9631         /* For ELFv2, if this symbol is not defined in a regular file
9632            and we are not generating a shared library or pie, then we
9633            need to define the symbol in the executable on a call stub.
9634            This is to avoid text relocations.  */
9635         s->size = (s->size + 15) & -16;
9636         h->root.u.def.section = s;
9637         h->root.u.def.value = s->size;
9638         s->size += 16;
9639         break;
9640       }
9641   return TRUE;
9642 }
9643
9644 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9645    read-only sections.  */
9646
9647 static bfd_boolean
9648 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9649 {
9650   if (h->root.type == bfd_link_hash_indirect)
9651     return TRUE;
9652
9653   if (readonly_dynrelocs (h))
9654     {
9655       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9656
9657       /* Not an error, just cut short the traversal.  */
9658       return FALSE;
9659     }
9660   return TRUE;
9661 }
9662
9663 /* Set the sizes of the dynamic sections.  */
9664
9665 static bfd_boolean
9666 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9667                                  struct bfd_link_info *info)
9668 {
9669   struct ppc_link_hash_table *htab;
9670   bfd *dynobj;
9671   asection *s;
9672   bfd_boolean relocs;
9673   bfd *ibfd;
9674   struct got_entry *first_tlsld;
9675
9676   htab = ppc_hash_table (info);
9677   if (htab == NULL)
9678     return FALSE;
9679
9680   dynobj = htab->elf.dynobj;
9681   if (dynobj == NULL)
9682     abort ();
9683
9684   if (htab->elf.dynamic_sections_created)
9685     {
9686       /* Set the contents of the .interp section to the interpreter.  */
9687       if (info->executable)
9688         {
9689           s = bfd_get_linker_section (dynobj, ".interp");
9690           if (s == NULL)
9691             abort ();
9692           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9693           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9694         }
9695     }
9696
9697   /* Set up .got offsets for local syms, and space for local dynamic
9698      relocs.  */
9699   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9700     {
9701       struct got_entry **lgot_ents;
9702       struct got_entry **end_lgot_ents;
9703       struct plt_entry **local_plt;
9704       struct plt_entry **end_local_plt;
9705       unsigned char *lgot_masks;
9706       bfd_size_type locsymcount;
9707       Elf_Internal_Shdr *symtab_hdr;
9708
9709       if (!is_ppc64_elf (ibfd))
9710         continue;
9711
9712       for (s = ibfd->sections; s != NULL; s = s->next)
9713         {
9714           struct ppc_dyn_relocs *p;
9715
9716           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9717             {
9718               if (!bfd_is_abs_section (p->sec)
9719                   && bfd_is_abs_section (p->sec->output_section))
9720                 {
9721                   /* Input section has been discarded, either because
9722                      it is a copy of a linkonce section or due to
9723                      linker script /DISCARD/, so we'll be discarding
9724                      the relocs too.  */
9725                 }
9726               else if (p->count != 0)
9727                 {
9728                   asection *srel = elf_section_data (p->sec)->sreloc;
9729                   if (p->ifunc)
9730                     srel = htab->elf.irelplt;
9731                   srel->size += p->count * sizeof (Elf64_External_Rela);
9732                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9733                     info->flags |= DF_TEXTREL;
9734                 }
9735             }
9736         }
9737
9738       lgot_ents = elf_local_got_ents (ibfd);
9739       if (!lgot_ents)
9740         continue;
9741
9742       symtab_hdr = &elf_symtab_hdr (ibfd);
9743       locsymcount = symtab_hdr->sh_info;
9744       end_lgot_ents = lgot_ents + locsymcount;
9745       local_plt = (struct plt_entry **) end_lgot_ents;
9746       end_local_plt = local_plt + locsymcount;
9747       lgot_masks = (unsigned char *) end_local_plt;
9748       s = ppc64_elf_tdata (ibfd)->got;
9749       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9750         {
9751           struct got_entry **pent, *ent;
9752
9753           pent = lgot_ents;
9754           while ((ent = *pent) != NULL)
9755             if (ent->got.refcount > 0)
9756               {
9757                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9758                   {
9759                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9760                     *pent = ent->next;
9761                   }
9762                 else
9763                   {
9764                     unsigned int ent_size = 8;
9765                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9766
9767                     ent->got.offset = s->size;
9768                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9769                       {
9770                         ent_size *= 2;
9771                         rel_size *= 2;
9772                       }
9773                     s->size += ent_size;
9774                     if ((*lgot_masks & PLT_IFUNC) != 0)
9775                       {
9776                         htab->elf.irelplt->size += rel_size;
9777                         htab->got_reli_size += rel_size;
9778                       }
9779                     else if (info->shared)
9780                       {
9781                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9782                         srel->size += rel_size;
9783                       }
9784                     pent = &ent->next;
9785                   }
9786               }
9787             else
9788               *pent = ent->next;
9789         }
9790
9791       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9792       for (; local_plt < end_local_plt; ++local_plt)
9793         {
9794           struct plt_entry *ent;
9795
9796           for (ent = *local_plt; ent != NULL; ent = ent->next)
9797             if (ent->plt.refcount > 0)
9798               {
9799                 s = htab->elf.iplt;
9800                 ent->plt.offset = s->size;
9801                 s->size += PLT_ENTRY_SIZE (htab);
9802
9803                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9804               }
9805             else
9806               ent->plt.offset = (bfd_vma) -1;
9807         }
9808     }
9809
9810   /* Allocate global sym .plt and .got entries, and space for global
9811      sym dynamic relocs.  */
9812   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9813   /* Stash the end of glink branch table.  */
9814   if (htab->glink != NULL)
9815     htab->glink->rawsize = htab->glink->size;
9816
9817   if (!htab->opd_abi && !info->shared)
9818     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9819
9820   first_tlsld = NULL;
9821   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9822     {
9823       struct got_entry *ent;
9824
9825       if (!is_ppc64_elf (ibfd))
9826         continue;
9827
9828       ent = ppc64_tlsld_got (ibfd);
9829       if (ent->got.refcount > 0)
9830         {
9831           if (!htab->do_multi_toc && first_tlsld != NULL)
9832             {
9833               ent->is_indirect = TRUE;
9834               ent->got.ent = first_tlsld;
9835             }
9836           else
9837             {
9838               if (first_tlsld == NULL)
9839                 first_tlsld = ent;
9840               s = ppc64_elf_tdata (ibfd)->got;
9841               ent->got.offset = s->size;
9842               ent->owner = ibfd;
9843               s->size += 16;
9844               if (info->shared)
9845                 {
9846                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9847                   srel->size += sizeof (Elf64_External_Rela);
9848                 }
9849             }
9850         }
9851       else
9852         ent->got.offset = (bfd_vma) -1;
9853     }
9854
9855   /* We now have determined the sizes of the various dynamic sections.
9856      Allocate memory for them.  */
9857   relocs = FALSE;
9858   for (s = dynobj->sections; s != NULL; s = s->next)
9859     {
9860       if ((s->flags & SEC_LINKER_CREATED) == 0)
9861         continue;
9862
9863       if (s == htab->brlt || s == htab->relbrlt)
9864         /* These haven't been allocated yet;  don't strip.  */
9865         continue;
9866       else if (s == htab->elf.sgot
9867                || s == htab->elf.splt
9868                || s == htab->elf.iplt
9869                || s == htab->glink
9870                || s == htab->dynbss)
9871         {
9872           /* Strip this section if we don't need it; see the
9873              comment below.  */
9874         }
9875       else if (s == htab->glink_eh_frame)
9876         {
9877           if (!bfd_is_abs_section (s->output_section))
9878             /* Not sized yet.  */
9879             continue;
9880         }
9881       else if (CONST_STRNEQ (s->name, ".rela"))
9882         {
9883           if (s->size != 0)
9884             {
9885               if (s != htab->elf.srelplt)
9886                 relocs = TRUE;
9887
9888               /* We use the reloc_count field as a counter if we need
9889                  to copy relocs into the output file.  */
9890               s->reloc_count = 0;
9891             }
9892         }
9893       else
9894         {
9895           /* It's not one of our sections, so don't allocate space.  */
9896           continue;
9897         }
9898
9899       if (s->size == 0)
9900         {
9901           /* If we don't need this section, strip it from the
9902              output file.  This is mostly to handle .rela.bss and
9903              .rela.plt.  We must create both sections in
9904              create_dynamic_sections, because they must be created
9905              before the linker maps input sections to output
9906              sections.  The linker does that before
9907              adjust_dynamic_symbol is called, and it is that
9908              function which decides whether anything needs to go
9909              into these sections.  */
9910           s->flags |= SEC_EXCLUDE;
9911           continue;
9912         }
9913
9914       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9915         continue;
9916
9917       /* Allocate memory for the section contents.  We use bfd_zalloc
9918          here in case unused entries are not reclaimed before the
9919          section's contents are written out.  This should not happen,
9920          but this way if it does we get a R_PPC64_NONE reloc in .rela
9921          sections instead of garbage.
9922          We also rely on the section contents being zero when writing
9923          the GOT.  */
9924       s->contents = bfd_zalloc (dynobj, s->size);
9925       if (s->contents == NULL)
9926         return FALSE;
9927     }
9928
9929   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9930     {
9931       if (!is_ppc64_elf (ibfd))
9932         continue;
9933
9934       s = ppc64_elf_tdata (ibfd)->got;
9935       if (s != NULL && s != htab->elf.sgot)
9936         {
9937           if (s->size == 0)
9938             s->flags |= SEC_EXCLUDE;
9939           else
9940             {
9941               s->contents = bfd_zalloc (ibfd, s->size);
9942               if (s->contents == NULL)
9943                 return FALSE;
9944             }
9945         }
9946       s = ppc64_elf_tdata (ibfd)->relgot;
9947       if (s != NULL)
9948         {
9949           if (s->size == 0)
9950             s->flags |= SEC_EXCLUDE;
9951           else
9952             {
9953               s->contents = bfd_zalloc (ibfd, s->size);
9954               if (s->contents == NULL)
9955                 return FALSE;
9956               relocs = TRUE;
9957               s->reloc_count = 0;
9958             }
9959         }
9960     }
9961
9962   if (htab->elf.dynamic_sections_created)
9963     {
9964       bfd_boolean tls_opt;
9965
9966       /* Add some entries to the .dynamic section.  We fill in the
9967          values later, in ppc64_elf_finish_dynamic_sections, but we
9968          must add the entries now so that we get the correct size for
9969          the .dynamic section.  The DT_DEBUG entry is filled in by the
9970          dynamic linker and used by the debugger.  */
9971 #define add_dynamic_entry(TAG, VAL) \
9972   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9973
9974       if (info->executable)
9975         {
9976           if (!add_dynamic_entry (DT_DEBUG, 0))
9977             return FALSE;
9978         }
9979
9980       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9981         {
9982           if (!add_dynamic_entry (DT_PLTGOT, 0)
9983               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9984               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9985               || !add_dynamic_entry (DT_JMPREL, 0)
9986               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9987             return FALSE;
9988         }
9989
9990       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9991         {
9992           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9993               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9994             return FALSE;
9995         }
9996
9997       tls_opt = (!htab->params->no_tls_get_addr_opt
9998                  && htab->tls_get_addr_fd != NULL
9999                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10000       if (tls_opt || !htab->opd_abi)
10001         {
10002           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10003             return FALSE;
10004         }
10005
10006       if (relocs)
10007         {
10008           if (!add_dynamic_entry (DT_RELA, 0)
10009               || !add_dynamic_entry (DT_RELASZ, 0)
10010               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10011             return FALSE;
10012
10013           /* If any dynamic relocs apply to a read-only section,
10014              then we need a DT_TEXTREL entry.  */
10015           if ((info->flags & DF_TEXTREL) == 0)
10016             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10017
10018           if ((info->flags & DF_TEXTREL) != 0)
10019             {
10020               if (!add_dynamic_entry (DT_TEXTREL, 0))
10021                 return FALSE;
10022             }
10023         }
10024     }
10025 #undef add_dynamic_entry
10026
10027   return TRUE;
10028 }
10029
10030 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10031
10032 static bfd_boolean
10033 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10034 {
10035   if (h->plt.plist != NULL
10036       && !h->def_regular
10037       && !h->pointer_equality_needed)
10038     return FALSE;
10039
10040   return _bfd_elf_hash_symbol (h);
10041 }
10042
10043 /* Determine the type of stub needed, if any, for a call.  */
10044
10045 static inline enum ppc_stub_type
10046 ppc_type_of_stub (asection *input_sec,
10047                   const Elf_Internal_Rela *rel,
10048                   struct ppc_link_hash_entry **hash,
10049                   struct plt_entry **plt_ent,
10050                   bfd_vma destination,
10051                   unsigned long local_off)
10052 {
10053   struct ppc_link_hash_entry *h = *hash;
10054   bfd_vma location;
10055   bfd_vma branch_offset;
10056   bfd_vma max_branch_offset;
10057   enum elf_ppc64_reloc_type r_type;
10058
10059   if (h != NULL)
10060     {
10061       struct plt_entry *ent;
10062       struct ppc_link_hash_entry *fdh = h;
10063       if (h->oh != NULL
10064           && h->oh->is_func_descriptor)
10065         {
10066           fdh = ppc_follow_link (h->oh);
10067           *hash = fdh;
10068         }
10069
10070       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10071         if (ent->addend == rel->r_addend
10072             && ent->plt.offset != (bfd_vma) -1)
10073           {
10074             *plt_ent = ent;
10075             return ppc_stub_plt_call;
10076           }
10077
10078       /* Here, we know we don't have a plt entry.  If we don't have a
10079          either a defined function descriptor or a defined entry symbol
10080          in a regular object file, then it is pointless trying to make
10081          any other type of stub.  */
10082       if (!is_static_defined (&fdh->elf)
10083           && !is_static_defined (&h->elf))
10084         return ppc_stub_none;
10085     }
10086   else if (elf_local_got_ents (input_sec->owner) != NULL)
10087     {
10088       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10089       struct plt_entry **local_plt = (struct plt_entry **)
10090         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10091       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10092
10093       if (local_plt[r_symndx] != NULL)
10094         {
10095           struct plt_entry *ent;
10096
10097           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10098             if (ent->addend == rel->r_addend
10099                 && ent->plt.offset != (bfd_vma) -1)
10100               {
10101                 *plt_ent = ent;
10102                 return ppc_stub_plt_call;
10103               }
10104         }
10105     }
10106
10107   /* Determine where the call point is.  */
10108   location = (input_sec->output_offset
10109               + input_sec->output_section->vma
10110               + rel->r_offset);
10111
10112   branch_offset = destination - location;
10113   r_type = ELF64_R_TYPE (rel->r_info);
10114
10115   /* Determine if a long branch stub is needed.  */
10116   max_branch_offset = 1 << 25;
10117   if (r_type != R_PPC64_REL24)
10118     max_branch_offset = 1 << 15;
10119
10120   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10121     /* We need a stub.  Figure out whether a long_branch or plt_branch
10122        is needed later.  */
10123     return ppc_stub_long_branch;
10124
10125   return ppc_stub_none;
10126 }
10127
10128 /* With power7 weakly ordered memory model, it is possible for ld.so
10129    to update a plt entry in one thread and have another thread see a
10130    stale zero toc entry.  To avoid this we need some sort of acquire
10131    barrier in the call stub.  One solution is to make the load of the
10132    toc word seem to appear to depend on the load of the function entry
10133    word.  Another solution is to test for r2 being zero, and branch to
10134    the appropriate glink entry if so.
10135
10136    .    fake dep barrier        compare
10137    .    ld 12,xxx(2)            ld 12,xxx(2)
10138    .    mtctr 12                mtctr 12
10139    .    xor 11,12,12            ld 2,xxx+8(2)
10140    .    add 2,2,11              cmpldi 2,0
10141    .    ld 2,xxx+8(2)           bnectr+
10142    .    bctr                    b <glink_entry>
10143
10144    The solution involving the compare turns out to be faster, so
10145    that's what we use unless the branch won't reach.  */
10146
10147 #define ALWAYS_USE_FAKE_DEP 0
10148 #define ALWAYS_EMIT_R2SAVE 0
10149
10150 #define PPC_LO(v) ((v) & 0xffff)
10151 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10152 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10153
10154 static inline unsigned int
10155 plt_stub_size (struct ppc_link_hash_table *htab,
10156                struct ppc_stub_hash_entry *stub_entry,
10157                bfd_vma off)
10158 {
10159   unsigned size = 12;
10160
10161   if (ALWAYS_EMIT_R2SAVE
10162       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10163     size += 4;
10164   if (PPC_HA (off) != 0)
10165     size += 4;
10166   if (htab->opd_abi)
10167     {
10168       size += 4;
10169       if (htab->params->plt_static_chain)
10170         size += 4;
10171       if (htab->params->plt_thread_safe)
10172         size += 8;
10173       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10174         size += 4;
10175     }
10176   if (stub_entry->h != NULL
10177       && (stub_entry->h == htab->tls_get_addr_fd
10178           || stub_entry->h == htab->tls_get_addr)
10179       && !htab->params->no_tls_get_addr_opt)
10180     size += 13 * 4;
10181   return size;
10182 }
10183
10184 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10185    then return the padding needed to do so.  */
10186 static inline unsigned int
10187 plt_stub_pad (struct ppc_link_hash_table *htab,
10188               struct ppc_stub_hash_entry *stub_entry,
10189               bfd_vma plt_off)
10190 {
10191   int stub_align = 1 << htab->params->plt_stub_align;
10192   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10193   bfd_vma stub_off = stub_entry->stub_sec->size;
10194
10195   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10196       > (stub_size & -stub_align))
10197     return stub_align - (stub_off & (stub_align - 1));
10198   return 0;
10199 }
10200
10201 /* Build a .plt call stub.  */
10202
10203 static inline bfd_byte *
10204 build_plt_stub (struct ppc_link_hash_table *htab,
10205                 struct ppc_stub_hash_entry *stub_entry,
10206                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10207 {
10208   bfd *obfd = htab->params->stub_bfd;
10209   bfd_boolean plt_load_toc = htab->opd_abi;
10210   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10211   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10212   bfd_boolean use_fake_dep = plt_thread_safe;
10213   bfd_vma cmp_branch_off = 0;
10214
10215   if (!ALWAYS_USE_FAKE_DEP
10216       && plt_load_toc
10217       && plt_thread_safe
10218       && !(stub_entry->h != NULL
10219            && (stub_entry->h == htab->tls_get_addr_fd
10220                || stub_entry->h == htab->tls_get_addr)
10221            && !htab->params->no_tls_get_addr_opt))
10222     {
10223       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10224       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10225                           / PLT_ENTRY_SIZE (htab));
10226       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10227       bfd_vma to, from;
10228
10229       if (pltindex > 32768)
10230         glinkoff += (pltindex - 32768) * 4;
10231       to = (glinkoff
10232             + htab->glink->output_offset
10233             + htab->glink->output_section->vma);
10234       from = (p - stub_entry->stub_sec->contents
10235               + 4 * (ALWAYS_EMIT_R2SAVE
10236                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10237               + 4 * (PPC_HA (offset) != 0)
10238               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10239                      != PPC_HA (offset))
10240               + 4 * (plt_static_chain != 0)
10241               + 20
10242               + stub_entry->stub_sec->output_offset
10243               + stub_entry->stub_sec->output_section->vma);
10244       cmp_branch_off = to - from;
10245       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10246     }
10247
10248   if (PPC_HA (offset) != 0)
10249     {
10250       if (r != NULL)
10251         {
10252           if (ALWAYS_EMIT_R2SAVE
10253               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10254             r[0].r_offset += 4;
10255           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10256           r[1].r_offset = r[0].r_offset + 4;
10257           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10258           r[1].r_addend = r[0].r_addend;
10259           if (plt_load_toc)
10260             {
10261               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10262                 {
10263                   r[2].r_offset = r[1].r_offset + 4;
10264                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10265                   r[2].r_addend = r[0].r_addend;
10266                 }
10267               else
10268                 {
10269                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10270                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10271                   r[2].r_addend = r[0].r_addend + 8;
10272                   if (plt_static_chain)
10273                     {
10274                       r[3].r_offset = r[2].r_offset + 4;
10275                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10276                       r[3].r_addend = r[0].r_addend + 16;
10277                     }
10278                 }
10279             }
10280         }
10281       if (ALWAYS_EMIT_R2SAVE
10282           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10283         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10284       if (plt_load_toc)
10285         {
10286           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10287           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10288         }
10289       else
10290         {
10291           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10292           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10293         }
10294       if (plt_load_toc
10295           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10296         {
10297           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10298           offset = 0;
10299         }
10300       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10301       if (plt_load_toc)
10302         {
10303           if (use_fake_dep)
10304             {
10305               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10306               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10307             }
10308           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10309           if (plt_static_chain)
10310             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10311         }
10312     }
10313   else
10314     {
10315       if (r != NULL)
10316         {
10317           if (ALWAYS_EMIT_R2SAVE
10318               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10319             r[0].r_offset += 4;
10320           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10321           if (plt_load_toc)
10322             {
10323               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10324                 {
10325                   r[1].r_offset = r[0].r_offset + 4;
10326                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10327                   r[1].r_addend = r[0].r_addend;
10328                 }
10329               else
10330                 {
10331                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10332                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10333                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10334                   if (plt_static_chain)
10335                     {
10336                       r[2].r_offset = r[1].r_offset + 4;
10337                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10338                       r[2].r_addend = r[0].r_addend + 8;
10339                     }
10340                 }
10341             }
10342         }
10343       if (ALWAYS_EMIT_R2SAVE
10344           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10345         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10346       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10347       if (plt_load_toc
10348           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10349         {
10350           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10351           offset = 0;
10352         }
10353       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10354       if (plt_load_toc)
10355         {
10356           if (use_fake_dep)
10357             {
10358               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10359               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10360             }
10361           if (plt_static_chain)
10362             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10363           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10364         }
10365     }
10366   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10367     {
10368       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10369       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10370       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10371     }
10372   else
10373     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10374   return p;
10375 }
10376
10377 /* Build a special .plt call stub for __tls_get_addr.  */
10378
10379 #define LD_R11_0R3      0xe9630000
10380 #define LD_R12_0R3      0xe9830000
10381 #define MR_R0_R3        0x7c601b78
10382 #define CMPDI_R11_0     0x2c2b0000
10383 #define ADD_R3_R12_R13  0x7c6c6a14
10384 #define BEQLR           0x4d820020
10385 #define MR_R3_R0        0x7c030378
10386 #define STD_R11_0R1     0xf9610000
10387 #define BCTRL           0x4e800421
10388 #define LD_R11_0R1      0xe9610000
10389 #define MTLR_R11        0x7d6803a6
10390
10391 static inline bfd_byte *
10392 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10393                          struct ppc_stub_hash_entry *stub_entry,
10394                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10395 {
10396   bfd *obfd = htab->params->stub_bfd;
10397
10398   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10399   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10400   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10401   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10402   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10403   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10404   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10405   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10406   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10407
10408   if (r != NULL)
10409     r[0].r_offset += 9 * 4;
10410   p = build_plt_stub (htab, stub_entry, p, offset, r);
10411   bfd_put_32 (obfd, BCTRL, p - 4);
10412
10413   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10414   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10415   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10416   bfd_put_32 (obfd, BLR, p),                    p += 4;
10417
10418   return p;
10419 }
10420
10421 static Elf_Internal_Rela *
10422 get_relocs (asection *sec, int count)
10423 {
10424   Elf_Internal_Rela *relocs;
10425   struct bfd_elf_section_data *elfsec_data;
10426
10427   elfsec_data = elf_section_data (sec);
10428   relocs = elfsec_data->relocs;
10429   if (relocs == NULL)
10430     {
10431       bfd_size_type relsize;
10432       relsize = sec->reloc_count * sizeof (*relocs);
10433       relocs = bfd_alloc (sec->owner, relsize);
10434       if (relocs == NULL)
10435         return NULL;
10436       elfsec_data->relocs = relocs;
10437       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10438                                           sizeof (Elf_Internal_Shdr));
10439       if (elfsec_data->rela.hdr == NULL)
10440         return NULL;
10441       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10442                                         * sizeof (Elf64_External_Rela));
10443       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10444       sec->reloc_count = 0;
10445     }
10446   relocs += sec->reloc_count;
10447   sec->reloc_count += count;
10448   return relocs;
10449 }
10450
10451 static bfd_vma
10452 get_r2off (struct bfd_link_info *info,
10453            struct ppc_stub_hash_entry *stub_entry)
10454 {
10455   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10456   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10457
10458   if (r2off == 0)
10459     {
10460       /* Support linking -R objects.  Get the toc pointer from the
10461          opd entry.  */
10462       char buf[8];
10463       if (!htab->opd_abi)
10464         return r2off;
10465       asection *opd = stub_entry->h->elf.root.u.def.section;
10466       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10467
10468       if (strcmp (opd->name, ".opd") != 0
10469           || opd->reloc_count != 0)
10470         {
10471           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10472                                   stub_entry->h->elf.root.root.string);
10473           bfd_set_error (bfd_error_bad_value);
10474           return 0;
10475         }
10476       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10477         return 0;
10478       r2off = bfd_get_64 (opd->owner, buf);
10479       r2off -= elf_gp (info->output_bfd);
10480     }
10481   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10482   return r2off;
10483 }
10484
10485 static bfd_boolean
10486 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10487 {
10488   struct ppc_stub_hash_entry *stub_entry;
10489   struct ppc_branch_hash_entry *br_entry;
10490   struct bfd_link_info *info;
10491   struct ppc_link_hash_table *htab;
10492   bfd_byte *loc;
10493   bfd_byte *p;
10494   bfd_vma dest, off;
10495   int size;
10496   Elf_Internal_Rela *r;
10497   asection *plt;
10498
10499   /* Massage our args to the form they really have.  */
10500   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10501   info = in_arg;
10502
10503   htab = ppc_hash_table (info);
10504   if (htab == NULL)
10505     return FALSE;
10506
10507   /* Make a note of the offset within the stubs for this entry.  */
10508   stub_entry->stub_offset = stub_entry->stub_sec->size;
10509   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10510
10511   htab->stub_count[stub_entry->stub_type - 1] += 1;
10512   switch (stub_entry->stub_type)
10513     {
10514     case ppc_stub_long_branch:
10515     case ppc_stub_long_branch_r2off:
10516       /* Branches are relative.  This is where we are going to.  */
10517       dest = (stub_entry->target_value
10518               + stub_entry->target_section->output_offset
10519               + stub_entry->target_section->output_section->vma);
10520       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10521       off = dest;
10522
10523       /* And this is where we are coming from.  */
10524       off -= (stub_entry->stub_offset
10525               + stub_entry->stub_sec->output_offset
10526               + stub_entry->stub_sec->output_section->vma);
10527
10528       size = 4;
10529       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10530         {
10531           bfd_vma r2off = get_r2off (info, stub_entry);
10532
10533           if (r2off == 0)
10534             {
10535               htab->stub_error = TRUE;
10536               return FALSE;
10537             }
10538           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10539           loc += 4;
10540           size = 12;
10541           if (PPC_HA (r2off) != 0)
10542             {
10543               size = 16;
10544               bfd_put_32 (htab->params->stub_bfd,
10545                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10546               loc += 4;
10547             }
10548           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10549           loc += 4;
10550           off -= size - 4;
10551         }
10552       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10553
10554       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10555         {
10556           info->callbacks->einfo
10557             (_("%P: long branch stub `%s' offset overflow\n"),
10558              stub_entry->root.string);
10559           htab->stub_error = TRUE;
10560           return FALSE;
10561         }
10562
10563       if (info->emitrelocations)
10564         {
10565           r = get_relocs (stub_entry->stub_sec, 1);
10566           if (r == NULL)
10567             return FALSE;
10568           r->r_offset = loc - stub_entry->stub_sec->contents;
10569           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10570           r->r_addend = dest;
10571           if (stub_entry->h != NULL)
10572             {
10573               struct elf_link_hash_entry **hashes;
10574               unsigned long symndx;
10575               struct ppc_link_hash_entry *h;
10576
10577               hashes = elf_sym_hashes (htab->params->stub_bfd);
10578               if (hashes == NULL)
10579                 {
10580                   bfd_size_type hsize;
10581
10582                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10583                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10584                   if (hashes == NULL)
10585                     return FALSE;
10586                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10587                   htab->stub_globals = 1;
10588                 }
10589               symndx = htab->stub_globals++;
10590               h = stub_entry->h;
10591               hashes[symndx] = &h->elf;
10592               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10593               if (h->oh != NULL && h->oh->is_func)
10594                 h = ppc_follow_link (h->oh);
10595               if (h->elf.root.u.def.section != stub_entry->target_section)
10596                 /* H is an opd symbol.  The addend must be zero.  */
10597                 r->r_addend = 0;
10598               else
10599                 {
10600                   off = (h->elf.root.u.def.value
10601                          + h->elf.root.u.def.section->output_offset
10602                          + h->elf.root.u.def.section->output_section->vma);
10603                   r->r_addend -= off;
10604                 }
10605             }
10606         }
10607       break;
10608
10609     case ppc_stub_plt_branch:
10610     case ppc_stub_plt_branch_r2off:
10611       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10612                                          stub_entry->root.string + 9,
10613                                          FALSE, FALSE);
10614       if (br_entry == NULL)
10615         {
10616           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10617                                   stub_entry->root.string);
10618           htab->stub_error = TRUE;
10619           return FALSE;
10620         }
10621
10622       dest = (stub_entry->target_value
10623               + stub_entry->target_section->output_offset
10624               + stub_entry->target_section->output_section->vma);
10625       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10626         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10627
10628       bfd_put_64 (htab->brlt->owner, dest,
10629                   htab->brlt->contents + br_entry->offset);
10630
10631       if (br_entry->iter == htab->stub_iteration)
10632         {
10633           br_entry->iter = 0;
10634
10635           if (htab->relbrlt != NULL)
10636             {
10637               /* Create a reloc for the branch lookup table entry.  */
10638               Elf_Internal_Rela rela;
10639               bfd_byte *rl;
10640
10641               rela.r_offset = (br_entry->offset
10642                                + htab->brlt->output_offset
10643                                + htab->brlt->output_section->vma);
10644               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10645               rela.r_addend = dest;
10646
10647               rl = htab->relbrlt->contents;
10648               rl += (htab->relbrlt->reloc_count++
10649                      * sizeof (Elf64_External_Rela));
10650               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10651             }
10652           else if (info->emitrelocations)
10653             {
10654               r = get_relocs (htab->brlt, 1);
10655               if (r == NULL)
10656                 return FALSE;
10657               /* brlt, being SEC_LINKER_CREATED does not go through the
10658                  normal reloc processing.  Symbols and offsets are not
10659                  translated from input file to output file form, so
10660                  set up the offset per the output file.  */
10661               r->r_offset = (br_entry->offset
10662                              + htab->brlt->output_offset
10663                              + htab->brlt->output_section->vma);
10664               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10665               r->r_addend = dest;
10666             }
10667         }
10668
10669       dest = (br_entry->offset
10670               + htab->brlt->output_offset
10671               + htab->brlt->output_section->vma);
10672
10673       off = (dest
10674              - elf_gp (htab->brlt->output_section->owner)
10675              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10676
10677       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10678         {
10679           info->callbacks->einfo
10680             (_("%P: linkage table error against `%T'\n"),
10681              stub_entry->root.string);
10682           bfd_set_error (bfd_error_bad_value);
10683           htab->stub_error = TRUE;
10684           return FALSE;
10685         }
10686
10687       if (info->emitrelocations)
10688         {
10689           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10690           if (r == NULL)
10691             return FALSE;
10692           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10693           if (bfd_big_endian (info->output_bfd))
10694             r[0].r_offset += 2;
10695           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10696             r[0].r_offset += 4;
10697           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10698           r[0].r_addend = dest;
10699           if (PPC_HA (off) != 0)
10700             {
10701               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10702               r[1].r_offset = r[0].r_offset + 4;
10703               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10704               r[1].r_addend = r[0].r_addend;
10705             }
10706         }
10707
10708       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10709         {
10710           if (PPC_HA (off) != 0)
10711             {
10712               size = 16;
10713               bfd_put_32 (htab->params->stub_bfd,
10714                           ADDIS_R12_R2 | PPC_HA (off), loc);
10715               loc += 4;
10716               bfd_put_32 (htab->params->stub_bfd,
10717                           LD_R12_0R12 | PPC_LO (off), loc);
10718             }
10719           else
10720             {
10721               size = 12;
10722               bfd_put_32 (htab->params->stub_bfd,
10723                           LD_R12_0R2 | PPC_LO (off), loc);
10724             }
10725         }
10726       else
10727         {
10728           bfd_vma r2off = get_r2off (info, stub_entry);
10729
10730           if (r2off == 0 && htab->opd_abi)
10731             {
10732               htab->stub_error = TRUE;
10733               return FALSE;
10734             }
10735
10736           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10737           loc += 4;
10738           size = 16;
10739           if (PPC_HA (off) != 0)
10740             {
10741               size += 4;
10742               bfd_put_32 (htab->params->stub_bfd,
10743                           ADDIS_R12_R2 | PPC_HA (off), loc);
10744               loc += 4;
10745               bfd_put_32 (htab->params->stub_bfd,
10746                           LD_R12_0R12 | PPC_LO (off), loc);
10747             }
10748           else
10749             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10750
10751           if (PPC_HA (r2off) != 0)
10752             {
10753               size += 4;
10754               loc += 4;
10755               bfd_put_32 (htab->params->stub_bfd,
10756                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10757             }
10758           if (PPC_LO (r2off) != 0)
10759             {
10760               size += 4;
10761               loc += 4;
10762               bfd_put_32 (htab->params->stub_bfd,
10763                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10764             }
10765         }
10766       loc += 4;
10767       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10768       loc += 4;
10769       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10770       break;
10771
10772     case ppc_stub_plt_call:
10773     case ppc_stub_plt_call_r2save:
10774       if (stub_entry->h != NULL
10775           && stub_entry->h->is_func_descriptor
10776           && stub_entry->h->oh != NULL)
10777         {
10778           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10779
10780           /* If the old-ABI "dot-symbol" is undefined make it weak so
10781              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10782              FIXME: We used to define the symbol on one of the call
10783              stubs instead, which is why we test symbol section id
10784              against htab->top_id in various places.  Likely all
10785              these checks could now disappear.  */
10786           if (fh->elf.root.type == bfd_link_hash_undefined)
10787             fh->elf.root.type = bfd_link_hash_undefweak;
10788           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10789           fh->was_undefined = 0;
10790         }
10791
10792       /* Now build the stub.  */
10793       dest = stub_entry->plt_ent->plt.offset & ~1;
10794       if (dest >= (bfd_vma) -2)
10795         abort ();
10796
10797       plt = htab->elf.splt;
10798       if (!htab->elf.dynamic_sections_created
10799           || stub_entry->h == NULL
10800           || stub_entry->h->elf.dynindx == -1)
10801         plt = htab->elf.iplt;
10802
10803       dest += plt->output_offset + plt->output_section->vma;
10804
10805       if (stub_entry->h == NULL
10806           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10807         {
10808           Elf_Internal_Rela rela;
10809           bfd_byte *rl;
10810
10811           rela.r_offset = dest;
10812           if (htab->opd_abi)
10813             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10814           else
10815             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10816           rela.r_addend = (stub_entry->target_value
10817                            + stub_entry->target_section->output_offset
10818                            + stub_entry->target_section->output_section->vma);
10819
10820           rl = (htab->elf.irelplt->contents
10821                 + (htab->elf.irelplt->reloc_count++
10822                    * sizeof (Elf64_External_Rela)));
10823           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10824           stub_entry->plt_ent->plt.offset |= 1;
10825         }
10826
10827       off = (dest
10828              - elf_gp (plt->output_section->owner)
10829              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10830
10831       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10832         {
10833           info->callbacks->einfo
10834             (_("%P: linkage table error against `%T'\n"),
10835              stub_entry->h != NULL
10836              ? stub_entry->h->elf.root.root.string
10837              : "<local sym>");
10838           bfd_set_error (bfd_error_bad_value);
10839           htab->stub_error = TRUE;
10840           return FALSE;
10841         }
10842
10843       if (htab->params->plt_stub_align != 0)
10844         {
10845           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10846
10847           stub_entry->stub_sec->size += pad;
10848           stub_entry->stub_offset = stub_entry->stub_sec->size;
10849           loc += pad;
10850         }
10851
10852       r = NULL;
10853       if (info->emitrelocations)
10854         {
10855           r = get_relocs (stub_entry->stub_sec,
10856                           ((PPC_HA (off) != 0)
10857                            + (htab->opd_abi
10858                               ? 2 + (htab->params->plt_static_chain
10859                                      && PPC_HA (off + 16) == PPC_HA (off))
10860                               : 1)));
10861           if (r == NULL)
10862             return FALSE;
10863           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10864           if (bfd_big_endian (info->output_bfd))
10865             r[0].r_offset += 2;
10866           r[0].r_addend = dest;
10867         }
10868       if (stub_entry->h != NULL
10869           && (stub_entry->h == htab->tls_get_addr_fd
10870               || stub_entry->h == htab->tls_get_addr)
10871           && !htab->params->no_tls_get_addr_opt)
10872         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10873       else
10874         p = build_plt_stub (htab, stub_entry, loc, off, r);
10875       size = p - loc;
10876       break;
10877
10878     default:
10879       BFD_FAIL ();
10880       return FALSE;
10881     }
10882
10883   stub_entry->stub_sec->size += size;
10884
10885   if (htab->params->emit_stub_syms)
10886     {
10887       struct elf_link_hash_entry *h;
10888       size_t len1, len2;
10889       char *name;
10890       const char *const stub_str[] = { "long_branch",
10891                                        "long_branch_r2off",
10892                                        "plt_branch",
10893                                        "plt_branch_r2off",
10894                                        "plt_call",
10895                                        "plt_call" };
10896
10897       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10898       len2 = strlen (stub_entry->root.string);
10899       name = bfd_malloc (len1 + len2 + 2);
10900       if (name == NULL)
10901         return FALSE;
10902       memcpy (name, stub_entry->root.string, 9);
10903       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10904       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10905       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10906       if (h == NULL)
10907         return FALSE;
10908       if (h->root.type == bfd_link_hash_new)
10909         {
10910           h->root.type = bfd_link_hash_defined;
10911           h->root.u.def.section = stub_entry->stub_sec;
10912           h->root.u.def.value = stub_entry->stub_offset;
10913           h->ref_regular = 1;
10914           h->def_regular = 1;
10915           h->ref_regular_nonweak = 1;
10916           h->forced_local = 1;
10917           h->non_elf = 0;
10918         }
10919     }
10920
10921   return TRUE;
10922 }
10923
10924 /* As above, but don't actually build the stub.  Just bump offset so
10925    we know stub section sizes, and select plt_branch stubs where
10926    long_branch stubs won't do.  */
10927
10928 static bfd_boolean
10929 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10930 {
10931   struct ppc_stub_hash_entry *stub_entry;
10932   struct bfd_link_info *info;
10933   struct ppc_link_hash_table *htab;
10934   bfd_vma off;
10935   int size;
10936
10937   /* Massage our args to the form they really have.  */
10938   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10939   info = in_arg;
10940
10941   htab = ppc_hash_table (info);
10942   if (htab == NULL)
10943     return FALSE;
10944
10945   if (stub_entry->stub_type == ppc_stub_plt_call
10946       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10947     {
10948       asection *plt;
10949       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10950       if (off >= (bfd_vma) -2)
10951         abort ();
10952       plt = htab->elf.splt;
10953       if (!htab->elf.dynamic_sections_created
10954           || stub_entry->h == NULL
10955           || stub_entry->h->elf.dynindx == -1)
10956         plt = htab->elf.iplt;
10957       off += (plt->output_offset
10958               + plt->output_section->vma
10959               - elf_gp (plt->output_section->owner)
10960               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10961
10962       size = plt_stub_size (htab, stub_entry, off);
10963       if (htab->params->plt_stub_align)
10964         size += plt_stub_pad (htab, stub_entry, off);
10965       if (info->emitrelocations)
10966         {
10967           stub_entry->stub_sec->reloc_count
10968             += ((PPC_HA (off) != 0)
10969                 + (htab->opd_abi
10970                    ? 2 + (htab->params->plt_static_chain
10971                           && PPC_HA (off + 16) == PPC_HA (off))
10972                    : 1));
10973           stub_entry->stub_sec->flags |= SEC_RELOC;
10974         }
10975     }
10976   else
10977     {
10978       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10979          variants.  */
10980       bfd_vma r2off = 0;
10981       bfd_vma local_off = 0;
10982
10983       off = (stub_entry->target_value
10984              + stub_entry->target_section->output_offset
10985              + stub_entry->target_section->output_section->vma);
10986       off -= (stub_entry->stub_sec->size
10987               + stub_entry->stub_sec->output_offset
10988               + stub_entry->stub_sec->output_section->vma);
10989
10990       /* Reset the stub type from the plt variant in case we now
10991          can reach with a shorter stub.  */
10992       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10993         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10994
10995       size = 4;
10996       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10997         {
10998           r2off = get_r2off (info, stub_entry);
10999           if (r2off == 0 && htab->opd_abi)
11000             {
11001               htab->stub_error = TRUE;
11002               return FALSE;
11003             }
11004           size = 12;
11005           if (PPC_HA (r2off) != 0)
11006             size = 16;
11007           off -= size - 4;
11008         }
11009
11010       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11011
11012       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11013          Do the same for -R objects without function descriptors.  */
11014       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11015           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11016               && r2off == 0))
11017         {
11018           struct ppc_branch_hash_entry *br_entry;
11019
11020           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11021                                              stub_entry->root.string + 9,
11022                                              TRUE, FALSE);
11023           if (br_entry == NULL)
11024             {
11025               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11026                                       stub_entry->root.string);
11027               htab->stub_error = TRUE;
11028               return FALSE;
11029             }
11030
11031           if (br_entry->iter != htab->stub_iteration)
11032             {
11033               br_entry->iter = htab->stub_iteration;
11034               br_entry->offset = htab->brlt->size;
11035               htab->brlt->size += 8;
11036
11037               if (htab->relbrlt != NULL)
11038                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11039               else if (info->emitrelocations)
11040                 {
11041                   htab->brlt->reloc_count += 1;
11042                   htab->brlt->flags |= SEC_RELOC;
11043                 }
11044             }
11045
11046           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11047           off = (br_entry->offset
11048                  + htab->brlt->output_offset
11049                  + htab->brlt->output_section->vma
11050                  - elf_gp (htab->brlt->output_section->owner)
11051                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11052
11053           if (info->emitrelocations)
11054             {
11055               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11056               stub_entry->stub_sec->flags |= SEC_RELOC;
11057             }
11058
11059           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11060             {
11061               size = 12;
11062               if (PPC_HA (off) != 0)
11063                 size = 16;
11064             }
11065           else
11066             {
11067               size = 16;
11068               if (PPC_HA (off) != 0)
11069                 size += 4;
11070
11071               if (PPC_HA (r2off) != 0)
11072                 size += 4;
11073               if (PPC_LO (r2off) != 0)
11074                 size += 4;
11075             }
11076         }
11077       else if (info->emitrelocations)
11078         {
11079           stub_entry->stub_sec->reloc_count += 1;
11080           stub_entry->stub_sec->flags |= SEC_RELOC;
11081         }
11082     }
11083
11084   stub_entry->stub_sec->size += size;
11085   return TRUE;
11086 }
11087
11088 /* Set up various things so that we can make a list of input sections
11089    for each output section included in the link.  Returns -1 on error,
11090    0 when no stubs will be needed, and 1 on success.  */
11091
11092 int
11093 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11094 {
11095   bfd *input_bfd;
11096   int top_id, top_index, id;
11097   asection *section;
11098   asection **input_list;
11099   bfd_size_type amt;
11100   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11101
11102   if (htab == NULL)
11103     return -1;
11104
11105   /* Find the top input section id.  */
11106   for (input_bfd = info->input_bfds, top_id = 3;
11107        input_bfd != NULL;
11108        input_bfd = input_bfd->link.next)
11109     {
11110       for (section = input_bfd->sections;
11111            section != NULL;
11112            section = section->next)
11113         {
11114           if (top_id < section->id)
11115             top_id = section->id;
11116         }
11117     }
11118
11119   htab->top_id = top_id;
11120   amt = sizeof (struct map_stub) * (top_id + 1);
11121   htab->stub_group = bfd_zmalloc (amt);
11122   if (htab->stub_group == NULL)
11123     return -1;
11124
11125   /* Set toc_off for com, und, abs and ind sections.  */
11126   for (id = 0; id < 3; id++)
11127     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11128
11129   /* We can't use output_bfd->section_count here to find the top output
11130      section index as some sections may have been removed, and
11131      strip_excluded_output_sections doesn't renumber the indices.  */
11132   for (section = info->output_bfd->sections, top_index = 0;
11133        section != NULL;
11134        section = section->next)
11135     {
11136       if (top_index < section->index)
11137         top_index = section->index;
11138     }
11139
11140   htab->top_index = top_index;
11141   amt = sizeof (asection *) * (top_index + 1);
11142   input_list = bfd_zmalloc (amt);
11143   htab->input_list = input_list;
11144   if (input_list == NULL)
11145     return -1;
11146
11147   return 1;
11148 }
11149
11150 /* Set up for first pass at multitoc partitioning.  */
11151
11152 void
11153 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11154 {
11155   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11156
11157   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11158   htab->toc_bfd = NULL;
11159   htab->toc_first_sec = NULL;
11160 }
11161
11162 /* The linker repeatedly calls this function for each TOC input section
11163    and linker generated GOT section.  Group input bfds such that the toc
11164    within a group is less than 64k in size.  */
11165
11166 bfd_boolean
11167 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11168 {
11169   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11170   bfd_vma addr, off, limit;
11171
11172   if (htab == NULL)
11173     return FALSE;
11174
11175   if (!htab->second_toc_pass)
11176     {
11177       /* Keep track of the first .toc or .got section for this input bfd.  */
11178       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11179
11180       if (new_bfd)
11181         {
11182           htab->toc_bfd = isec->owner;
11183           htab->toc_first_sec = isec;
11184         }
11185
11186       addr = isec->output_offset + isec->output_section->vma;
11187       off = addr - htab->toc_curr;
11188       limit = 0x80008000;
11189       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11190         limit = 0x10000;
11191       if (off + isec->size > limit)
11192         {
11193           addr = (htab->toc_first_sec->output_offset
11194                   + htab->toc_first_sec->output_section->vma);
11195           htab->toc_curr = addr;
11196         }
11197
11198       /* toc_curr is the base address of this toc group.  Set elf_gp
11199          for the input section to be the offset relative to the
11200          output toc base plus 0x8000.  Making the input elf_gp an
11201          offset allows us to move the toc as a whole without
11202          recalculating input elf_gp.  */
11203       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11204       off += TOC_BASE_OFF;
11205
11206       /* Die if someone uses a linker script that doesn't keep input
11207          file .toc and .got together.  */
11208       if (new_bfd
11209           && elf_gp (isec->owner) != 0
11210           && elf_gp (isec->owner) != off)
11211         return FALSE;
11212
11213       elf_gp (isec->owner) = off;
11214       return TRUE;
11215     }
11216
11217   /* During the second pass toc_first_sec points to the start of
11218      a toc group, and toc_curr is used to track the old elf_gp.
11219      We use toc_bfd to ensure we only look at each bfd once.  */
11220   if (htab->toc_bfd == isec->owner)
11221     return TRUE;
11222   htab->toc_bfd = isec->owner;
11223
11224   if (htab->toc_first_sec == NULL
11225       || htab->toc_curr != elf_gp (isec->owner))
11226     {
11227       htab->toc_curr = elf_gp (isec->owner);
11228       htab->toc_first_sec = isec;
11229     }
11230   addr = (htab->toc_first_sec->output_offset
11231           + htab->toc_first_sec->output_section->vma);
11232   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11233   elf_gp (isec->owner) = off;
11234
11235   return TRUE;
11236 }
11237
11238 /* Called via elf_link_hash_traverse to merge GOT entries for global
11239    symbol H.  */
11240
11241 static bfd_boolean
11242 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11243 {
11244   if (h->root.type == bfd_link_hash_indirect)
11245     return TRUE;
11246
11247   merge_got_entries (&h->got.glist);
11248
11249   return TRUE;
11250 }
11251
11252 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11253    symbol H.  */
11254
11255 static bfd_boolean
11256 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11257 {
11258   struct got_entry *gent;
11259
11260   if (h->root.type == bfd_link_hash_indirect)
11261     return TRUE;
11262
11263   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11264     if (!gent->is_indirect)
11265       allocate_got (h, (struct bfd_link_info *) inf, gent);
11266   return TRUE;
11267 }
11268
11269 /* Called on the first multitoc pass after the last call to
11270    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11271    entries.  */
11272
11273 bfd_boolean
11274 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11275 {
11276   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11277   struct bfd *ibfd, *ibfd2;
11278   bfd_boolean done_something;
11279
11280   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11281
11282   if (!htab->do_multi_toc)
11283     return FALSE;
11284
11285   /* Merge global sym got entries within a toc group.  */
11286   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11287
11288   /* And tlsld_got.  */
11289   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11290     {
11291       struct got_entry *ent, *ent2;
11292
11293       if (!is_ppc64_elf (ibfd))
11294         continue;
11295
11296       ent = ppc64_tlsld_got (ibfd);
11297       if (!ent->is_indirect
11298           && ent->got.offset != (bfd_vma) -1)
11299         {
11300           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11301             {
11302               if (!is_ppc64_elf (ibfd2))
11303                 continue;
11304
11305               ent2 = ppc64_tlsld_got (ibfd2);
11306               if (!ent2->is_indirect
11307                   && ent2->got.offset != (bfd_vma) -1
11308                   && elf_gp (ibfd2) == elf_gp (ibfd))
11309                 {
11310                   ent2->is_indirect = TRUE;
11311                   ent2->got.ent = ent;
11312                 }
11313             }
11314         }
11315     }
11316
11317   /* Zap sizes of got sections.  */
11318   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11319   htab->elf.irelplt->size -= htab->got_reli_size;
11320   htab->got_reli_size = 0;
11321
11322   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11323     {
11324       asection *got, *relgot;
11325
11326       if (!is_ppc64_elf (ibfd))
11327         continue;
11328
11329       got = ppc64_elf_tdata (ibfd)->got;
11330       if (got != NULL)
11331         {
11332           got->rawsize = got->size;
11333           got->size = 0;
11334           relgot = ppc64_elf_tdata (ibfd)->relgot;
11335           relgot->rawsize = relgot->size;
11336           relgot->size = 0;
11337         }
11338     }
11339
11340   /* Now reallocate the got, local syms first.  We don't need to
11341      allocate section contents again since we never increase size.  */
11342   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11343     {
11344       struct got_entry **lgot_ents;
11345       struct got_entry **end_lgot_ents;
11346       struct plt_entry **local_plt;
11347       struct plt_entry **end_local_plt;
11348       unsigned char *lgot_masks;
11349       bfd_size_type locsymcount;
11350       Elf_Internal_Shdr *symtab_hdr;
11351       asection *s;
11352
11353       if (!is_ppc64_elf (ibfd))
11354         continue;
11355
11356       lgot_ents = elf_local_got_ents (ibfd);
11357       if (!lgot_ents)
11358         continue;
11359
11360       symtab_hdr = &elf_symtab_hdr (ibfd);
11361       locsymcount = symtab_hdr->sh_info;
11362       end_lgot_ents = lgot_ents + locsymcount;
11363       local_plt = (struct plt_entry **) end_lgot_ents;
11364       end_local_plt = local_plt + locsymcount;
11365       lgot_masks = (unsigned char *) end_local_plt;
11366       s = ppc64_elf_tdata (ibfd)->got;
11367       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11368         {
11369           struct got_entry *ent;
11370
11371           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11372             {
11373               unsigned int ent_size = 8;
11374               unsigned int rel_size = sizeof (Elf64_External_Rela);
11375
11376               ent->got.offset = s->size;
11377               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11378                 {
11379                   ent_size *= 2;
11380                   rel_size *= 2;
11381                 }
11382               s->size += ent_size;
11383               if ((*lgot_masks & PLT_IFUNC) != 0)
11384                 {
11385                   htab->elf.irelplt->size += rel_size;
11386                   htab->got_reli_size += rel_size;
11387                 }
11388               else if (info->shared)
11389                 {
11390                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11391                   srel->size += rel_size;
11392                 }
11393             }
11394         }
11395     }
11396
11397   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11398
11399   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11400     {
11401       struct got_entry *ent;
11402
11403       if (!is_ppc64_elf (ibfd))
11404         continue;
11405
11406       ent = ppc64_tlsld_got (ibfd);
11407       if (!ent->is_indirect
11408           && ent->got.offset != (bfd_vma) -1)
11409         {
11410           asection *s = ppc64_elf_tdata (ibfd)->got;
11411           ent->got.offset = s->size;
11412           s->size += 16;
11413           if (info->shared)
11414             {
11415               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11416               srel->size += sizeof (Elf64_External_Rela);
11417             }
11418         }
11419     }
11420
11421   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11422   if (!done_something)
11423     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11424       {
11425         asection *got;
11426
11427         if (!is_ppc64_elf (ibfd))
11428           continue;
11429
11430         got = ppc64_elf_tdata (ibfd)->got;
11431         if (got != NULL)
11432           {
11433             done_something = got->rawsize != got->size;
11434             if (done_something)
11435               break;
11436           }
11437       }
11438
11439   if (done_something)
11440     (*htab->params->layout_sections_again) ();
11441
11442   /* Set up for second pass over toc sections to recalculate elf_gp
11443      on input sections.  */
11444   htab->toc_bfd = NULL;
11445   htab->toc_first_sec = NULL;
11446   htab->second_toc_pass = TRUE;
11447   return done_something;
11448 }
11449
11450 /* Called after second pass of multitoc partitioning.  */
11451
11452 void
11453 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11454 {
11455   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11456
11457   /* After the second pass, toc_curr tracks the TOC offset used
11458      for code sections below in ppc64_elf_next_input_section.  */
11459   htab->toc_curr = TOC_BASE_OFF;
11460 }
11461
11462 /* No toc references were found in ISEC.  If the code in ISEC makes no
11463    calls, then there's no need to use toc adjusting stubs when branching
11464    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11465    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11466    needed, and 2 if a cyclical call-graph was found but no other reason
11467    for a stub was detected.  If called from the top level, a return of
11468    2 means the same as a return of 0.  */
11469
11470 static int
11471 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11472 {
11473   int ret;
11474
11475   /* Mark this section as checked.  */
11476   isec->call_check_done = 1;
11477
11478   /* We know none of our code bearing sections will need toc stubs.  */
11479   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11480     return 0;
11481
11482   if (isec->size == 0)
11483     return 0;
11484
11485   if (isec->output_section == NULL)
11486     return 0;
11487
11488   ret = 0;
11489   if (isec->reloc_count != 0)
11490     {
11491       Elf_Internal_Rela *relstart, *rel;
11492       Elf_Internal_Sym *local_syms;
11493       struct ppc_link_hash_table *htab;
11494
11495       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11496                                             info->keep_memory);
11497       if (relstart == NULL)
11498         return -1;
11499
11500       /* Look for branches to outside of this section.  */
11501       local_syms = NULL;
11502       htab = ppc_hash_table (info);
11503       if (htab == NULL)
11504         return -1;
11505
11506       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11507         {
11508           enum elf_ppc64_reloc_type r_type;
11509           unsigned long r_symndx;
11510           struct elf_link_hash_entry *h;
11511           struct ppc_link_hash_entry *eh;
11512           Elf_Internal_Sym *sym;
11513           asection *sym_sec;
11514           struct _opd_sec_data *opd;
11515           bfd_vma sym_value;
11516           bfd_vma dest;
11517
11518           r_type = ELF64_R_TYPE (rel->r_info);
11519           if (r_type != R_PPC64_REL24
11520               && r_type != R_PPC64_REL14
11521               && r_type != R_PPC64_REL14_BRTAKEN
11522               && r_type != R_PPC64_REL14_BRNTAKEN)
11523             continue;
11524
11525           r_symndx = ELF64_R_SYM (rel->r_info);
11526           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11527                           isec->owner))
11528             {
11529               ret = -1;
11530               break;
11531             }
11532
11533           /* Calls to dynamic lib functions go through a plt call stub
11534              that uses r2.  */
11535           eh = (struct ppc_link_hash_entry *) h;
11536           if (eh != NULL
11537               && (eh->elf.plt.plist != NULL
11538                   || (eh->oh != NULL
11539                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11540             {
11541               ret = 1;
11542               break;
11543             }
11544
11545           if (sym_sec == NULL)
11546             /* Ignore other undefined symbols.  */
11547             continue;
11548
11549           /* Assume branches to other sections not included in the
11550              link need stubs too, to cover -R and absolute syms.  */
11551           if (sym_sec->output_section == NULL)
11552             {
11553               ret = 1;
11554               break;
11555             }
11556
11557           if (h == NULL)
11558             sym_value = sym->st_value;
11559           else
11560             {
11561               if (h->root.type != bfd_link_hash_defined
11562                   && h->root.type != bfd_link_hash_defweak)
11563                 abort ();
11564               sym_value = h->root.u.def.value;
11565             }
11566           sym_value += rel->r_addend;
11567
11568           /* If this branch reloc uses an opd sym, find the code section.  */
11569           opd = get_opd_info (sym_sec);
11570           if (opd != NULL)
11571             {
11572               if (h == NULL && opd->adjust != NULL)
11573                 {
11574                   long adjust;
11575
11576                   adjust = opd->adjust[sym->st_value / 8];
11577                   if (adjust == -1)
11578                     /* Assume deleted functions won't ever be called.  */
11579                     continue;
11580                   sym_value += adjust;
11581                 }
11582
11583               dest = opd_entry_value (sym_sec, sym_value,
11584                                       &sym_sec, NULL, FALSE);
11585               if (dest == (bfd_vma) -1)
11586                 continue;
11587             }
11588           else
11589             dest = (sym_value
11590                     + sym_sec->output_offset
11591                     + sym_sec->output_section->vma);
11592
11593           /* Ignore branch to self.  */
11594           if (sym_sec == isec)
11595             continue;
11596
11597           /* If the called function uses the toc, we need a stub.  */
11598           if (sym_sec->has_toc_reloc
11599               || sym_sec->makes_toc_func_call)
11600             {
11601               ret = 1;
11602               break;
11603             }
11604
11605           /* Assume any branch that needs a long branch stub might in fact
11606              need a plt_branch stub.  A plt_branch stub uses r2.  */
11607           else if (dest - (isec->output_offset
11608                            + isec->output_section->vma
11609                            + rel->r_offset) + (1 << 25)
11610                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11611                                                              ? h->other
11612                                                              : sym->st_other))
11613             {
11614               ret = 1;
11615               break;
11616             }
11617
11618           /* If calling back to a section in the process of being
11619              tested, we can't say for sure that no toc adjusting stubs
11620              are needed, so don't return zero.  */
11621           else if (sym_sec->call_check_in_progress)
11622             ret = 2;
11623
11624           /* Branches to another section that itself doesn't have any TOC
11625              references are OK.  Recursively call ourselves to check.  */
11626           else if (!sym_sec->call_check_done)
11627             {
11628               int recur;
11629
11630               /* Mark current section as indeterminate, so that other
11631                  sections that call back to current won't be marked as
11632                  known.  */
11633               isec->call_check_in_progress = 1;
11634               recur = toc_adjusting_stub_needed (info, sym_sec);
11635               isec->call_check_in_progress = 0;
11636
11637               if (recur != 0)
11638                 {
11639                   ret = recur;
11640                   if (recur != 2)
11641                     break;
11642                 }
11643             }
11644         }
11645
11646       if (local_syms != NULL
11647           && (elf_symtab_hdr (isec->owner).contents
11648               != (unsigned char *) local_syms))
11649         free (local_syms);
11650       if (elf_section_data (isec)->relocs != relstart)
11651         free (relstart);
11652     }
11653
11654   if ((ret & 1) == 0
11655       && isec->map_head.s != NULL
11656       && (strcmp (isec->output_section->name, ".init") == 0
11657           || strcmp (isec->output_section->name, ".fini") == 0))
11658     {
11659       if (isec->map_head.s->has_toc_reloc
11660           || isec->map_head.s->makes_toc_func_call)
11661         ret = 1;
11662       else if (!isec->map_head.s->call_check_done)
11663         {
11664           int recur;
11665           isec->call_check_in_progress = 1;
11666           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11667           isec->call_check_in_progress = 0;
11668           if (recur != 0)
11669             ret = recur;
11670         }
11671     }
11672
11673   if (ret == 1)
11674     isec->makes_toc_func_call = 1;
11675
11676   return ret;
11677 }
11678
11679 /* The linker repeatedly calls this function for each input section,
11680    in the order that input sections are linked into output sections.
11681    Build lists of input sections to determine groupings between which
11682    we may insert linker stubs.  */
11683
11684 bfd_boolean
11685 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11686 {
11687   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11688
11689   if (htab == NULL)
11690     return FALSE;
11691
11692   if ((isec->output_section->flags & SEC_CODE) != 0
11693       && isec->output_section->index <= htab->top_index)
11694     {
11695       asection **list = htab->input_list + isec->output_section->index;
11696       /* Steal the link_sec pointer for our list.  */
11697 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11698       /* This happens to make the list in reverse order,
11699          which is what we want.  */
11700       PREV_SEC (isec) = *list;
11701       *list = isec;
11702     }
11703
11704   if (htab->multi_toc_needed)
11705     {
11706       /* Analyse sections that aren't already flagged as needing a
11707          valid toc pointer.  Exclude .fixup for the linux kernel.
11708          .fixup contains branches, but only back to the function that
11709          hit an exception.  */
11710       if (!(isec->has_toc_reloc
11711             || (isec->flags & SEC_CODE) == 0
11712             || strcmp (isec->name, ".fixup") == 0
11713             || isec->call_check_done))
11714         {
11715           if (toc_adjusting_stub_needed (info, isec) < 0)
11716             return FALSE;
11717         }
11718       /* Make all sections use the TOC assigned for this object file.
11719          This will be wrong for pasted sections;  We fix that in
11720          check_pasted_section().  */
11721       if (elf_gp (isec->owner) != 0)
11722         htab->toc_curr = elf_gp (isec->owner);
11723     }
11724
11725   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11726   return TRUE;
11727 }
11728
11729 /* Check that all .init and .fini sections use the same toc, if they
11730    have toc relocs.  */
11731
11732 static bfd_boolean
11733 check_pasted_section (struct bfd_link_info *info, const char *name)
11734 {
11735   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11736
11737   if (o != NULL)
11738     {
11739       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11740       bfd_vma toc_off = 0;
11741       asection *i;
11742
11743       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11744         if (i->has_toc_reloc)
11745           {
11746             if (toc_off == 0)
11747               toc_off = htab->stub_group[i->id].toc_off;
11748             else if (toc_off != htab->stub_group[i->id].toc_off)
11749               return FALSE;
11750           }
11751
11752       if (toc_off == 0)
11753         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11754           if (i->makes_toc_func_call)
11755             {
11756               toc_off = htab->stub_group[i->id].toc_off;
11757               break;
11758             }
11759
11760       /* Make sure the whole pasted function uses the same toc offset.  */
11761       if (toc_off != 0)
11762         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11763           htab->stub_group[i->id].toc_off = toc_off;
11764     }
11765   return TRUE;
11766 }
11767
11768 bfd_boolean
11769 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11770 {
11771   return (check_pasted_section (info, ".init")
11772           & check_pasted_section (info, ".fini"));
11773 }
11774
11775 /* See whether we can group stub sections together.  Grouping stub
11776    sections may result in fewer stubs.  More importantly, we need to
11777    put all .init* and .fini* stubs at the beginning of the .init or
11778    .fini output sections respectively, because glibc splits the
11779    _init and _fini functions into multiple parts.  Putting a stub in
11780    the middle of a function is not a good idea.  */
11781
11782 static void
11783 group_sections (struct ppc_link_hash_table *htab,
11784                 bfd_size_type stub_group_size,
11785                 bfd_boolean stubs_always_before_branch)
11786 {
11787   asection **list;
11788   bfd_size_type stub14_group_size;
11789   bfd_boolean suppress_size_errors;
11790
11791   suppress_size_errors = FALSE;
11792   stub14_group_size = stub_group_size;
11793   if (stub_group_size == 1)
11794     {
11795       /* Default values.  */
11796       if (stubs_always_before_branch)
11797         {
11798           stub_group_size = 0x1e00000;
11799           stub14_group_size = 0x7800;
11800         }
11801       else
11802         {
11803           stub_group_size = 0x1c00000;
11804           stub14_group_size = 0x7000;
11805         }
11806       suppress_size_errors = TRUE;
11807     }
11808
11809   list = htab->input_list + htab->top_index;
11810   do
11811     {
11812       asection *tail = *list;
11813       while (tail != NULL)
11814         {
11815           asection *curr;
11816           asection *prev;
11817           bfd_size_type total;
11818           bfd_boolean big_sec;
11819           bfd_vma curr_toc;
11820
11821           curr = tail;
11822           total = tail->size;
11823           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11824                              && ppc64_elf_section_data (tail)->has_14bit_branch
11825                              ? stub14_group_size : stub_group_size);
11826           if (big_sec && !suppress_size_errors)
11827             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11828                                      tail->owner, tail);
11829           curr_toc = htab->stub_group[tail->id].toc_off;
11830
11831           while ((prev = PREV_SEC (curr)) != NULL
11832                  && ((total += curr->output_offset - prev->output_offset)
11833                      < (ppc64_elf_section_data (prev) != NULL
11834                         && ppc64_elf_section_data (prev)->has_14bit_branch
11835                         ? stub14_group_size : stub_group_size))
11836                  && htab->stub_group[prev->id].toc_off == curr_toc)
11837             curr = prev;
11838
11839           /* OK, the size from the start of CURR to the end is less
11840              than stub_group_size and thus can be handled by one stub
11841              section.  (or the tail section is itself larger than
11842              stub_group_size, in which case we may be toast.)  We
11843              should really be keeping track of the total size of stubs
11844              added here, as stubs contribute to the final output
11845              section size.  That's a little tricky, and this way will
11846              only break if stubs added make the total size more than
11847              2^25, ie. for the default stub_group_size, if stubs total
11848              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11849           do
11850             {
11851               prev = PREV_SEC (tail);
11852               /* Set up this stub group.  */
11853               htab->stub_group[tail->id].link_sec = curr;
11854             }
11855           while (tail != curr && (tail = prev) != NULL);
11856
11857           /* But wait, there's more!  Input sections up to stub_group_size
11858              bytes before the stub section can be handled by it too.
11859              Don't do this if we have a really large section after the
11860              stubs, as adding more stubs increases the chance that
11861              branches may not reach into the stub section.  */
11862           if (!stubs_always_before_branch && !big_sec)
11863             {
11864               total = 0;
11865               while (prev != NULL
11866                      && ((total += tail->output_offset - prev->output_offset)
11867                          < (ppc64_elf_section_data (prev) != NULL
11868                             && ppc64_elf_section_data (prev)->has_14bit_branch
11869                             ? stub14_group_size : stub_group_size))
11870                      && htab->stub_group[prev->id].toc_off == curr_toc)
11871                 {
11872                   tail = prev;
11873                   prev = PREV_SEC (tail);
11874                   htab->stub_group[tail->id].link_sec = curr;
11875                 }
11876             }
11877           tail = prev;
11878         }
11879     }
11880   while (list-- != htab->input_list);
11881   free (htab->input_list);
11882 #undef PREV_SEC
11883 }
11884
11885 static const unsigned char glink_eh_frame_cie[] =
11886 {
11887   0, 0, 0, 16,                          /* length.  */
11888   0, 0, 0, 0,                           /* id.  */
11889   1,                                    /* CIE version.  */
11890   'z', 'R', 0,                          /* Augmentation string.  */
11891   4,                                    /* Code alignment.  */
11892   0x78,                                 /* Data alignment.  */
11893   65,                                   /* RA reg.  */
11894   1,                                    /* Augmentation size.  */
11895   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11896   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11897 };
11898
11899 /* Stripping output sections is normally done before dynamic section
11900    symbols have been allocated.  This function is called later, and
11901    handles cases like htab->brlt which is mapped to its own output
11902    section.  */
11903
11904 static void
11905 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11906 {
11907   if (isec->size == 0
11908       && isec->output_section->size == 0
11909       && !(isec->output_section->flags & SEC_KEEP)
11910       && !bfd_section_removed_from_list (info->output_bfd,
11911                                          isec->output_section)
11912       && elf_section_data (isec->output_section)->dynindx == 0)
11913     {
11914       isec->output_section->flags |= SEC_EXCLUDE;
11915       bfd_section_list_remove (info->output_bfd, isec->output_section);
11916       info->output_bfd->section_count--;
11917     }
11918 }
11919
11920 /* Determine and set the size of the stub section for a final link.
11921
11922    The basic idea here is to examine all the relocations looking for
11923    PC-relative calls to a target that is unreachable with a "bl"
11924    instruction.  */
11925
11926 bfd_boolean
11927 ppc64_elf_size_stubs (struct bfd_link_info *info)
11928 {
11929   bfd_size_type stub_group_size;
11930   bfd_boolean stubs_always_before_branch;
11931   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11932
11933   if (htab == NULL)
11934     return FALSE;
11935
11936   if (htab->params->plt_thread_safe == -1 && !info->executable)
11937     htab->params->plt_thread_safe = 1;
11938   if (!htab->opd_abi)
11939     htab->params->plt_thread_safe = 0;
11940   else if (htab->params->plt_thread_safe == -1)
11941     {
11942       static const char *const thread_starter[] =
11943         {
11944           "pthread_create",
11945           /* libstdc++ */
11946           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11947           /* librt */
11948           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11949           "mq_notify", "create_timer",
11950           /* libanl */
11951           "getaddrinfo_a",
11952           /* libgomp */
11953           "GOMP_parallel_start",
11954           "GOMP_parallel_loop_static_start",
11955           "GOMP_parallel_loop_dynamic_start",
11956           "GOMP_parallel_loop_guided_start",
11957           "GOMP_parallel_loop_runtime_start",
11958           "GOMP_parallel_sections_start",
11959         };
11960       unsigned i;
11961
11962       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11963         {
11964           struct elf_link_hash_entry *h;
11965           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11966                                     FALSE, FALSE, TRUE);
11967           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11968           if (htab->params->plt_thread_safe)
11969             break;
11970         }
11971     }
11972   stubs_always_before_branch = htab->params->group_size < 0;
11973   if (htab->params->group_size < 0)
11974     stub_group_size = -htab->params->group_size;
11975   else
11976     stub_group_size = htab->params->group_size;
11977
11978   group_sections (htab, stub_group_size, stubs_always_before_branch);
11979
11980   while (1)
11981     {
11982       bfd *input_bfd;
11983       unsigned int bfd_indx;
11984       asection *stub_sec;
11985
11986       htab->stub_iteration += 1;
11987
11988       for (input_bfd = info->input_bfds, bfd_indx = 0;
11989            input_bfd != NULL;
11990            input_bfd = input_bfd->link.next, bfd_indx++)
11991         {
11992           Elf_Internal_Shdr *symtab_hdr;
11993           asection *section;
11994           Elf_Internal_Sym *local_syms = NULL;
11995
11996           if (!is_ppc64_elf (input_bfd))
11997             continue;
11998
11999           /* We'll need the symbol table in a second.  */
12000           symtab_hdr = &elf_symtab_hdr (input_bfd);
12001           if (symtab_hdr->sh_info == 0)
12002             continue;
12003
12004           /* Walk over each section attached to the input bfd.  */
12005           for (section = input_bfd->sections;
12006                section != NULL;
12007                section = section->next)
12008             {
12009               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12010
12011               /* If there aren't any relocs, then there's nothing more
12012                  to do.  */
12013               if ((section->flags & SEC_RELOC) == 0
12014                   || (section->flags & SEC_ALLOC) == 0
12015                   || (section->flags & SEC_LOAD) == 0
12016                   || (section->flags & SEC_CODE) == 0
12017                   || section->reloc_count == 0)
12018                 continue;
12019
12020               /* If this section is a link-once section that will be
12021                  discarded, then don't create any stubs.  */
12022               if (section->output_section == NULL
12023                   || section->output_section->owner != info->output_bfd)
12024                 continue;
12025
12026               /* Get the relocs.  */
12027               internal_relocs
12028                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12029                                              info->keep_memory);
12030               if (internal_relocs == NULL)
12031                 goto error_ret_free_local;
12032
12033               /* Now examine each relocation.  */
12034               irela = internal_relocs;
12035               irelaend = irela + section->reloc_count;
12036               for (; irela < irelaend; irela++)
12037                 {
12038                   enum elf_ppc64_reloc_type r_type;
12039                   unsigned int r_indx;
12040                   enum ppc_stub_type stub_type;
12041                   struct ppc_stub_hash_entry *stub_entry;
12042                   asection *sym_sec, *code_sec;
12043                   bfd_vma sym_value, code_value;
12044                   bfd_vma destination;
12045                   unsigned long local_off;
12046                   bfd_boolean ok_dest;
12047                   struct ppc_link_hash_entry *hash;
12048                   struct ppc_link_hash_entry *fdh;
12049                   struct elf_link_hash_entry *h;
12050                   Elf_Internal_Sym *sym;
12051                   char *stub_name;
12052                   const asection *id_sec;
12053                   struct _opd_sec_data *opd;
12054                   struct plt_entry *plt_ent;
12055
12056                   r_type = ELF64_R_TYPE (irela->r_info);
12057                   r_indx = ELF64_R_SYM (irela->r_info);
12058
12059                   if (r_type >= R_PPC64_max)
12060                     {
12061                       bfd_set_error (bfd_error_bad_value);
12062                       goto error_ret_free_internal;
12063                     }
12064
12065                   /* Only look for stubs on branch instructions.  */
12066                   if (r_type != R_PPC64_REL24
12067                       && r_type != R_PPC64_REL14
12068                       && r_type != R_PPC64_REL14_BRTAKEN
12069                       && r_type != R_PPC64_REL14_BRNTAKEN)
12070                     continue;
12071
12072                   /* Now determine the call target, its name, value,
12073                      section.  */
12074                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12075                                   r_indx, input_bfd))
12076                     goto error_ret_free_internal;
12077                   hash = (struct ppc_link_hash_entry *) h;
12078
12079                   ok_dest = FALSE;
12080                   fdh = NULL;
12081                   sym_value = 0;
12082                   if (hash == NULL)
12083                     {
12084                       sym_value = sym->st_value;
12085                       ok_dest = TRUE;
12086                     }
12087                   else if (hash->elf.root.type == bfd_link_hash_defined
12088                            || hash->elf.root.type == bfd_link_hash_defweak)
12089                     {
12090                       sym_value = hash->elf.root.u.def.value;
12091                       if (sym_sec->output_section != NULL)
12092                         ok_dest = TRUE;
12093                     }
12094                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12095                            || hash->elf.root.type == bfd_link_hash_undefined)
12096                     {
12097                       /* Recognise an old ABI func code entry sym, and
12098                          use the func descriptor sym instead if it is
12099                          defined.  */
12100                       if (hash->elf.root.root.string[0] == '.'
12101                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12102                         {
12103                           if (fdh->elf.root.type == bfd_link_hash_defined
12104                               || fdh->elf.root.type == bfd_link_hash_defweak)
12105                             {
12106                               sym_sec = fdh->elf.root.u.def.section;
12107                               sym_value = fdh->elf.root.u.def.value;
12108                               if (sym_sec->output_section != NULL)
12109                                 ok_dest = TRUE;
12110                             }
12111                           else
12112                             fdh = NULL;
12113                         }
12114                     }
12115                   else
12116                     {
12117                       bfd_set_error (bfd_error_bad_value);
12118                       goto error_ret_free_internal;
12119                     }
12120
12121                   destination = 0;
12122                   local_off = 0;
12123                   if (ok_dest)
12124                     {
12125                       sym_value += irela->r_addend;
12126                       destination = (sym_value
12127                                      + sym_sec->output_offset
12128                                      + sym_sec->output_section->vma);
12129                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12130                                                             ? hash->elf.other
12131                                                             : sym->st_other);
12132                     }
12133
12134                   code_sec = sym_sec;
12135                   code_value = sym_value;
12136                   opd = get_opd_info (sym_sec);
12137                   if (opd != NULL)
12138                     {
12139                       bfd_vma dest;
12140
12141                       if (hash == NULL && opd->adjust != NULL)
12142                         {
12143                           long adjust = opd->adjust[sym_value / 8];
12144                           if (adjust == -1)
12145                             continue;
12146                           code_value += adjust;
12147                           sym_value += adjust;
12148                         }
12149                       dest = opd_entry_value (sym_sec, sym_value,
12150                                               &code_sec, &code_value, FALSE);
12151                       if (dest != (bfd_vma) -1)
12152                         {
12153                           destination = dest;
12154                           if (fdh != NULL)
12155                             {
12156                               /* Fixup old ABI sym to point at code
12157                                  entry.  */
12158                               hash->elf.root.type = bfd_link_hash_defweak;
12159                               hash->elf.root.u.def.section = code_sec;
12160                               hash->elf.root.u.def.value = code_value;
12161                             }
12162                         }
12163                     }
12164
12165                   /* Determine what (if any) linker stub is needed.  */
12166                   plt_ent = NULL;
12167                   stub_type = ppc_type_of_stub (section, irela, &hash,
12168                                                 &plt_ent, destination,
12169                                                 local_off);
12170
12171                   if (stub_type != ppc_stub_plt_call)
12172                     {
12173                       /* Check whether we need a TOC adjusting stub.
12174                          Since the linker pastes together pieces from
12175                          different object files when creating the
12176                          _init and _fini functions, it may be that a
12177                          call to what looks like a local sym is in
12178                          fact a call needing a TOC adjustment.  */
12179                       if (code_sec != NULL
12180                           && code_sec->output_section != NULL
12181                           && (htab->stub_group[code_sec->id].toc_off
12182                               != htab->stub_group[section->id].toc_off)
12183                           && (code_sec->has_toc_reloc
12184                               || code_sec->makes_toc_func_call))
12185                         stub_type = ppc_stub_long_branch_r2off;
12186                     }
12187
12188                   if (stub_type == ppc_stub_none)
12189                     continue;
12190
12191                   /* __tls_get_addr calls might be eliminated.  */
12192                   if (stub_type != ppc_stub_plt_call
12193                       && hash != NULL
12194                       && (hash == htab->tls_get_addr
12195                           || hash == htab->tls_get_addr_fd)
12196                       && section->has_tls_reloc
12197                       && irela != internal_relocs)
12198                     {
12199                       /* Get tls info.  */
12200                       unsigned char *tls_mask;
12201
12202                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12203                                          irela - 1, input_bfd))
12204                         goto error_ret_free_internal;
12205                       if (*tls_mask != 0)
12206                         continue;
12207                     }
12208
12209                   if (stub_type == ppc_stub_plt_call
12210                       && irela + 1 < irelaend
12211                       && irela[1].r_offset == irela->r_offset + 4
12212                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12213                     {
12214                       if (!tocsave_find (htab, INSERT,
12215                                          &local_syms, irela + 1, input_bfd))
12216                         goto error_ret_free_internal;
12217                     }
12218                   else if (stub_type == ppc_stub_plt_call)
12219                     stub_type = ppc_stub_plt_call_r2save;
12220
12221                   /* Support for grouping stub sections.  */
12222                   id_sec = htab->stub_group[section->id].link_sec;
12223
12224                   /* Get the name of this stub.  */
12225                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12226                   if (!stub_name)
12227                     goto error_ret_free_internal;
12228
12229                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12230                                                      stub_name, FALSE, FALSE);
12231                   if (stub_entry != NULL)
12232                     {
12233                       /* The proper stub has already been created.  */
12234                       free (stub_name);
12235                       if (stub_type == ppc_stub_plt_call_r2save)
12236                         stub_entry->stub_type = stub_type;
12237                       continue;
12238                     }
12239
12240                   stub_entry = ppc_add_stub (stub_name, section, info);
12241                   if (stub_entry == NULL)
12242                     {
12243                       free (stub_name);
12244                     error_ret_free_internal:
12245                       if (elf_section_data (section)->relocs == NULL)
12246                         free (internal_relocs);
12247                     error_ret_free_local:
12248                       if (local_syms != NULL
12249                           && (symtab_hdr->contents
12250                               != (unsigned char *) local_syms))
12251                         free (local_syms);
12252                       return FALSE;
12253                     }
12254
12255                   stub_entry->stub_type = stub_type;
12256                   if (stub_type != ppc_stub_plt_call
12257                       && stub_type != ppc_stub_plt_call_r2save)
12258                     {
12259                       stub_entry->target_value = code_value;
12260                       stub_entry->target_section = code_sec;
12261                     }
12262                   else
12263                     {
12264                       stub_entry->target_value = sym_value;
12265                       stub_entry->target_section = sym_sec;
12266                     }
12267                   stub_entry->h = hash;
12268                   stub_entry->plt_ent = plt_ent;
12269                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12270
12271                   if (stub_entry->h != NULL)
12272                     htab->stub_globals += 1;
12273                 }
12274
12275               /* We're done with the internal relocs, free them.  */
12276               if (elf_section_data (section)->relocs != internal_relocs)
12277                 free (internal_relocs);
12278             }
12279
12280           if (local_syms != NULL
12281               && symtab_hdr->contents != (unsigned char *) local_syms)
12282             {
12283               if (!info->keep_memory)
12284                 free (local_syms);
12285               else
12286                 symtab_hdr->contents = (unsigned char *) local_syms;
12287             }
12288         }
12289
12290       /* We may have added some stubs.  Find out the new size of the
12291          stub sections.  */
12292       for (stub_sec = htab->params->stub_bfd->sections;
12293            stub_sec != NULL;
12294            stub_sec = stub_sec->next)
12295         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12296           {
12297             stub_sec->rawsize = stub_sec->size;
12298             stub_sec->size = 0;
12299             stub_sec->reloc_count = 0;
12300             stub_sec->flags &= ~SEC_RELOC;
12301           }
12302
12303       htab->brlt->size = 0;
12304       htab->brlt->reloc_count = 0;
12305       htab->brlt->flags &= ~SEC_RELOC;
12306       if (htab->relbrlt != NULL)
12307         htab->relbrlt->size = 0;
12308
12309       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12310
12311       if (info->emitrelocations
12312           && htab->glink != NULL && htab->glink->size != 0)
12313         {
12314           htab->glink->reloc_count = 1;
12315           htab->glink->flags |= SEC_RELOC;
12316         }
12317
12318       if (htab->glink_eh_frame != NULL
12319           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12320           && htab->glink_eh_frame->output_section->size != 0)
12321         {
12322           size_t size = 0, align;
12323
12324           for (stub_sec = htab->params->stub_bfd->sections;
12325                stub_sec != NULL;
12326                stub_sec = stub_sec->next)
12327             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12328               size += 20;
12329           if (htab->glink != NULL && htab->glink->size != 0)
12330             size += 24;
12331           if (size != 0)
12332             size += sizeof (glink_eh_frame_cie);
12333           align = 1;
12334           align <<= htab->glink_eh_frame->output_section->alignment_power;
12335           align -= 1;
12336           size = (size + align) & ~align;
12337           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12338           htab->glink_eh_frame->size = size;
12339         }
12340
12341       if (htab->params->plt_stub_align != 0)
12342         for (stub_sec = htab->params->stub_bfd->sections;
12343              stub_sec != NULL;
12344              stub_sec = stub_sec->next)
12345           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12346             stub_sec->size = ((stub_sec->size
12347                                + (1 << htab->params->plt_stub_align) - 1)
12348                               & (-1 << htab->params->plt_stub_align));
12349
12350       for (stub_sec = htab->params->stub_bfd->sections;
12351            stub_sec != NULL;
12352            stub_sec = stub_sec->next)
12353         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12354             && stub_sec->rawsize != stub_sec->size)
12355           break;
12356
12357       /* Exit from this loop when no stubs have been added, and no stubs
12358          have changed size.  */
12359       if (stub_sec == NULL
12360           && (htab->glink_eh_frame == NULL
12361               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12362         break;
12363
12364       /* Ask the linker to do its stuff.  */
12365       (*htab->params->layout_sections_again) ();
12366     }
12367
12368   maybe_strip_output (info, htab->brlt);
12369   if (htab->glink_eh_frame != NULL)
12370     maybe_strip_output (info, htab->glink_eh_frame);
12371
12372   return TRUE;
12373 }
12374
12375 /* Called after we have determined section placement.  If sections
12376    move, we'll be called again.  Provide a value for TOCstart.  */
12377
12378 bfd_vma
12379 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12380 {
12381   asection *s;
12382   bfd_vma TOCstart;
12383
12384   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12385      order.  The TOC starts where the first of these sections starts.  */
12386   s = bfd_get_section_by_name (obfd, ".got");
12387   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12388     s = bfd_get_section_by_name (obfd, ".toc");
12389   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12390     s = bfd_get_section_by_name (obfd, ".tocbss");
12391   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12392     s = bfd_get_section_by_name (obfd, ".plt");
12393   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12394     {
12395       /* This may happen for
12396          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12397          .toc directive
12398          o  bad linker script
12399          o --gc-sections and empty TOC sections
12400
12401          FIXME: Warn user?  */
12402
12403       /* Look for a likely section.  We probably won't even be
12404          using TOCstart.  */
12405       for (s = obfd->sections; s != NULL; s = s->next)
12406         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12407                          | SEC_EXCLUDE))
12408             == (SEC_ALLOC | SEC_SMALL_DATA))
12409           break;
12410       if (s == NULL)
12411         for (s = obfd->sections; s != NULL; s = s->next)
12412           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12413               == (SEC_ALLOC | SEC_SMALL_DATA))
12414             break;
12415       if (s == NULL)
12416         for (s = obfd->sections; s != NULL; s = s->next)
12417           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12418               == SEC_ALLOC)
12419             break;
12420       if (s == NULL)
12421         for (s = obfd->sections; s != NULL; s = s->next)
12422           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12423             break;
12424     }
12425
12426   TOCstart = 0;
12427   if (s != NULL)
12428     TOCstart = s->output_section->vma + s->output_offset;
12429
12430   _bfd_set_gp_value (obfd, TOCstart);
12431
12432   if (info != NULL && s != NULL)
12433     {
12434       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12435
12436       if (htab != NULL)
12437         {
12438           if (htab->elf.hgot != NULL)
12439             {
12440               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12441               htab->elf.hgot->root.u.def.section = s;
12442             }
12443         }
12444       else
12445         {
12446           struct bfd_link_hash_entry *bh = NULL;
12447           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12448                                             s, TOC_BASE_OFF, NULL, FALSE,
12449                                             FALSE, &bh);
12450         }
12451     }
12452   return TOCstart;
12453 }
12454
12455 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12456    write out any global entry stubs.  */
12457
12458 static bfd_boolean
12459 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12460 {
12461   struct bfd_link_info *info;
12462   struct ppc_link_hash_table *htab;
12463   struct plt_entry *pent;
12464   asection *s;
12465
12466   if (h->root.type == bfd_link_hash_indirect)
12467     return TRUE;
12468
12469   if (!h->pointer_equality_needed)
12470     return TRUE;
12471
12472   if (h->def_regular)
12473     return TRUE;
12474
12475   info = inf;
12476   htab = ppc_hash_table (info);
12477   if (htab == NULL)
12478     return FALSE;
12479
12480   s = htab->glink;
12481   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12482     if (pent->plt.offset != (bfd_vma) -1
12483         && pent->addend == 0)
12484       {
12485         bfd_byte *p;
12486         asection *plt;
12487         bfd_vma off;
12488
12489         p = s->contents + h->root.u.def.value;
12490         plt = htab->elf.splt;
12491         if (!htab->elf.dynamic_sections_created
12492             || h->dynindx == -1)
12493           plt = htab->elf.iplt;
12494         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12495         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12496
12497         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12498           {
12499             info->callbacks->einfo
12500               (_("%P: linkage table error against `%T'\n"),
12501                h->root.root.string);
12502             bfd_set_error (bfd_error_bad_value);
12503             htab->stub_error = TRUE;
12504           }
12505
12506         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12507         if (htab->params->emit_stub_syms)
12508           {
12509             size_t len = strlen (h->root.root.string);
12510             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12511
12512             if (name == NULL)
12513               return FALSE;
12514
12515             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12516             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12517             if (h == NULL)
12518               return FALSE;
12519             if (h->root.type == bfd_link_hash_new)
12520               {
12521                 h->root.type = bfd_link_hash_defined;
12522                 h->root.u.def.section = s;
12523                 h->root.u.def.value = p - s->contents;
12524                 h->ref_regular = 1;
12525                 h->def_regular = 1;
12526                 h->ref_regular_nonweak = 1;
12527                 h->forced_local = 1;
12528                 h->non_elf = 0;
12529               }
12530           }
12531
12532         if (PPC_HA (off) != 0)
12533           {
12534             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12535             p += 4;
12536           }
12537         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12538         p += 4;
12539         bfd_put_32 (s->owner, MTCTR_R12, p);
12540         p += 4;
12541         bfd_put_32 (s->owner, BCTR, p);
12542         break;
12543       }
12544   return TRUE;
12545 }
12546
12547 /* Build all the stubs associated with the current output file.
12548    The stubs are kept in a hash table attached to the main linker
12549    hash table.  This function is called via gldelf64ppc_finish.  */
12550
12551 bfd_boolean
12552 ppc64_elf_build_stubs (struct bfd_link_info *info,
12553                        char **stats)
12554 {
12555   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12556   asection *stub_sec;
12557   bfd_byte *p;
12558   int stub_sec_count = 0;
12559
12560   if (htab == NULL)
12561     return FALSE;
12562
12563   /* Allocate memory to hold the linker stubs.  */
12564   for (stub_sec = htab->params->stub_bfd->sections;
12565        stub_sec != NULL;
12566        stub_sec = stub_sec->next)
12567     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12568         && stub_sec->size != 0)
12569       {
12570         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12571         if (stub_sec->contents == NULL)
12572           return FALSE;
12573         /* We want to check that built size is the same as calculated
12574            size.  rawsize is a convenient location to use.  */
12575         stub_sec->rawsize = stub_sec->size;
12576         stub_sec->size = 0;
12577       }
12578
12579   if (htab->glink != NULL && htab->glink->size != 0)
12580     {
12581       unsigned int indx;
12582       bfd_vma plt0;
12583
12584       /* Build the .glink plt call stub.  */
12585       if (htab->params->emit_stub_syms)
12586         {
12587           struct elf_link_hash_entry *h;
12588           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12589                                     TRUE, FALSE, FALSE);
12590           if (h == NULL)
12591             return FALSE;
12592           if (h->root.type == bfd_link_hash_new)
12593             {
12594               h->root.type = bfd_link_hash_defined;
12595               h->root.u.def.section = htab->glink;
12596               h->root.u.def.value = 8;
12597               h->ref_regular = 1;
12598               h->def_regular = 1;
12599               h->ref_regular_nonweak = 1;
12600               h->forced_local = 1;
12601               h->non_elf = 0;
12602             }
12603         }
12604       plt0 = (htab->elf.splt->output_section->vma
12605               + htab->elf.splt->output_offset
12606               - 16);
12607       if (info->emitrelocations)
12608         {
12609           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12610           if (r == NULL)
12611             return FALSE;
12612           r->r_offset = (htab->glink->output_offset
12613                          + htab->glink->output_section->vma);
12614           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12615           r->r_addend = plt0;
12616         }
12617       p = htab->glink->contents;
12618       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12619       bfd_put_64 (htab->glink->owner, plt0, p);
12620       p += 8;
12621       if (htab->opd_abi)
12622         {
12623           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12624           p += 4;
12625           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12626           p += 4;
12627           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12628           p += 4;
12629           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12630           p += 4;
12631           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12632           p += 4;
12633           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12634           p += 4;
12635           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12636           p += 4;
12637           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12638           p += 4;
12639           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12640           p += 4;
12641           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12642           p += 4;
12643         }
12644       else
12645         {
12646           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12647           p += 4;
12648           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12649           p += 4;
12650           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12651           p += 4;
12652           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12653           p += 4;
12654           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12655           p += 4;
12656           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12657           p += 4;
12658           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12659           p += 4;
12660           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12661           p += 4;
12662           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12663           p += 4;
12664           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12665           p += 4;
12666           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12667           p += 4;
12668           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12669           p += 4;
12670         }
12671       bfd_put_32 (htab->glink->owner, BCTR, p);
12672       p += 4;
12673       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12674         {
12675           bfd_put_32 (htab->glink->owner, NOP, p);
12676           p += 4;
12677         }
12678
12679       /* Build the .glink lazy link call stubs.  */
12680       indx = 0;
12681       while (p < htab->glink->contents + htab->glink->rawsize)
12682         {
12683           if (htab->opd_abi)
12684             {
12685               if (indx < 0x8000)
12686                 {
12687                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12688                   p += 4;
12689                 }
12690               else
12691                 {
12692                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12693                   p += 4;
12694                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12695                               p);
12696                   p += 4;
12697                 }
12698             }
12699           bfd_put_32 (htab->glink->owner,
12700                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12701           indx++;
12702           p += 4;
12703         }
12704
12705       /* Build .glink global entry stubs.  */
12706       if (htab->glink->size > htab->glink->rawsize)
12707         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12708     }
12709
12710   if (htab->brlt != NULL && htab->brlt->size != 0)
12711     {
12712       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12713                                          htab->brlt->size);
12714       if (htab->brlt->contents == NULL)
12715         return FALSE;
12716     }
12717   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12718     {
12719       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12720                                             htab->relbrlt->size);
12721       if (htab->relbrlt->contents == NULL)
12722         return FALSE;
12723     }
12724
12725   if (htab->glink_eh_frame != NULL
12726       && htab->glink_eh_frame->size != 0)
12727     {
12728       bfd_vma val;
12729       bfd_byte *last_fde;
12730       size_t last_fde_len, size, align, pad;
12731
12732       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12733       if (p == NULL)
12734         return FALSE;
12735       htab->glink_eh_frame->contents = p;
12736       last_fde = p;
12737
12738       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12739
12740       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12741       /* CIE length (rewrite in case little-endian).  */
12742       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12743       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12744       p += sizeof (glink_eh_frame_cie);
12745
12746       for (stub_sec = htab->params->stub_bfd->sections;
12747            stub_sec != NULL;
12748            stub_sec = stub_sec->next)
12749         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12750           {
12751             last_fde = p;
12752             last_fde_len = 16;
12753             /* FDE length.  */
12754             bfd_put_32 (htab->elf.dynobj, 16, p);
12755             p += 4;
12756             /* CIE pointer.  */
12757             val = p - htab->glink_eh_frame->contents;
12758             bfd_put_32 (htab->elf.dynobj, val, p);
12759             p += 4;
12760             /* Offset to stub section.  */
12761             val = (stub_sec->output_section->vma
12762                    + stub_sec->output_offset);
12763             val -= (htab->glink_eh_frame->output_section->vma
12764                     + htab->glink_eh_frame->output_offset);
12765             val -= p - htab->glink_eh_frame->contents;
12766             if (val + 0x80000000 > 0xffffffff)
12767               {
12768                 info->callbacks->einfo
12769                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12770                    stub_sec->name);
12771                 return FALSE;
12772               }
12773             bfd_put_32 (htab->elf.dynobj, val, p);
12774             p += 4;
12775             /* stub section size.  */
12776             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12777             p += 4;
12778             /* Augmentation.  */
12779             p += 1;
12780             /* Pad.  */
12781             p += 3;
12782           }
12783       if (htab->glink != NULL && htab->glink->size != 0)
12784         {
12785           last_fde = p;
12786           last_fde_len = 20;
12787           /* FDE length.  */
12788           bfd_put_32 (htab->elf.dynobj, 20, p);
12789           p += 4;
12790           /* CIE pointer.  */
12791           val = p - htab->glink_eh_frame->contents;
12792           bfd_put_32 (htab->elf.dynobj, val, p);
12793           p += 4;
12794           /* Offset to .glink.  */
12795           val = (htab->glink->output_section->vma
12796                  + htab->glink->output_offset
12797                  + 8);
12798           val -= (htab->glink_eh_frame->output_section->vma
12799                   + htab->glink_eh_frame->output_offset);
12800           val -= p - htab->glink_eh_frame->contents;
12801           if (val + 0x80000000 > 0xffffffff)
12802             {
12803               info->callbacks->einfo
12804                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12805                  htab->glink->name);
12806               return FALSE;
12807             }
12808           bfd_put_32 (htab->elf.dynobj, val, p);
12809           p += 4;
12810           /* .glink size.  */
12811           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12812           p += 4;
12813           /* Augmentation.  */
12814           p += 1;
12815
12816           *p++ = DW_CFA_advance_loc + 1;
12817           *p++ = DW_CFA_register;
12818           *p++ = 65;
12819           *p++ = 12;
12820           *p++ = DW_CFA_advance_loc + 4;
12821           *p++ = DW_CFA_restore_extended;
12822           *p++ = 65;
12823         }
12824       /* Subsume any padding into the last FDE if user .eh_frame
12825          sections are aligned more than glink_eh_frame.  Otherwise any
12826          zero padding will be seen as a terminator.  */
12827       size = p - htab->glink_eh_frame->contents;
12828       align = 1;
12829       align <<= htab->glink_eh_frame->output_section->alignment_power;
12830       align -= 1;
12831       pad = ((size + align) & ~align) - size;
12832       htab->glink_eh_frame->size = size + pad;
12833       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12834     }
12835
12836   /* Build the stubs as directed by the stub hash table.  */
12837   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12838
12839   if (htab->relbrlt != NULL)
12840     htab->relbrlt->reloc_count = 0;
12841
12842   if (htab->params->plt_stub_align != 0)
12843     for (stub_sec = htab->params->stub_bfd->sections;
12844          stub_sec != NULL;
12845          stub_sec = stub_sec->next)
12846       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12847         stub_sec->size = ((stub_sec->size
12848                            + (1 << htab->params->plt_stub_align) - 1)
12849                           & (-1 << htab->params->plt_stub_align));
12850
12851   for (stub_sec = htab->params->stub_bfd->sections;
12852        stub_sec != NULL;
12853        stub_sec = stub_sec->next)
12854     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12855       {
12856         stub_sec_count += 1;
12857         if (stub_sec->rawsize != stub_sec->size)
12858           break;
12859       }
12860
12861   if (stub_sec != NULL
12862       || (htab->glink_eh_frame != NULL
12863           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12864     {
12865       htab->stub_error = TRUE;
12866       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12867     }
12868
12869   if (htab->stub_error)
12870     return FALSE;
12871
12872   if (stats != NULL)
12873     {
12874       *stats = bfd_malloc (500);
12875       if (*stats == NULL)
12876         return FALSE;
12877
12878       sprintf (*stats, _("linker stubs in %u group%s\n"
12879                          "  branch       %lu\n"
12880                          "  toc adjust   %lu\n"
12881                          "  long branch  %lu\n"
12882                          "  long toc adj %lu\n"
12883                          "  plt call     %lu\n"
12884                          "  plt call toc %lu\n"
12885                          "  global entry %lu"),
12886                stub_sec_count,
12887                stub_sec_count == 1 ? "" : "s",
12888                htab->stub_count[ppc_stub_long_branch - 1],
12889                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12890                htab->stub_count[ppc_stub_plt_branch - 1],
12891                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12892                htab->stub_count[ppc_stub_plt_call - 1],
12893                htab->stub_count[ppc_stub_plt_call_r2save - 1],
12894                htab->stub_count[ppc_stub_global_entry - 1]);
12895     }
12896   return TRUE;
12897 }
12898
12899 /* This function undoes the changes made by add_symbol_adjust.  */
12900
12901 static bfd_boolean
12902 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12903 {
12904   struct ppc_link_hash_entry *eh;
12905
12906   if (h->root.type == bfd_link_hash_indirect)
12907     return TRUE;
12908
12909   eh = (struct ppc_link_hash_entry *) h;
12910   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12911     return TRUE;
12912
12913   eh->elf.root.type = bfd_link_hash_undefined;
12914   return TRUE;
12915 }
12916
12917 void
12918 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12919 {
12920   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12921
12922   if (htab != NULL)
12923     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12924 }
12925
12926 /* What to do when ld finds relocations against symbols defined in
12927    discarded sections.  */
12928
12929 static unsigned int
12930 ppc64_elf_action_discarded (asection *sec)
12931 {
12932   if (strcmp (".opd", sec->name) == 0)
12933     return 0;
12934
12935   if (strcmp (".toc", sec->name) == 0)
12936     return 0;
12937
12938   if (strcmp (".toc1", sec->name) == 0)
12939     return 0;
12940
12941   return _bfd_elf_default_action_discarded (sec);
12942 }
12943
12944 /* The RELOCATE_SECTION function is called by the ELF backend linker
12945    to handle the relocations for a section.
12946
12947    The relocs are always passed as Rela structures; if the section
12948    actually uses Rel structures, the r_addend field will always be
12949    zero.
12950
12951    This function is responsible for adjust the section contents as
12952    necessary, and (if using Rela relocs and generating a
12953    relocatable output file) adjusting the reloc addend as
12954    necessary.
12955
12956    This function does not have to worry about setting the reloc
12957    address or the reloc symbol index.
12958
12959    LOCAL_SYMS is a pointer to the swapped in local symbols.
12960
12961    LOCAL_SECTIONS is an array giving the section in the input file
12962    corresponding to the st_shndx field of each local symbol.
12963
12964    The global hash table entry for the global symbols can be found
12965    via elf_sym_hashes (input_bfd).
12966
12967    When generating relocatable output, this function must handle
12968    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12969    going to be the section symbol corresponding to the output
12970    section, which means that the addend must be adjusted
12971    accordingly.  */
12972
12973 static bfd_boolean
12974 ppc64_elf_relocate_section (bfd *output_bfd,
12975                             struct bfd_link_info *info,
12976                             bfd *input_bfd,
12977                             asection *input_section,
12978                             bfd_byte *contents,
12979                             Elf_Internal_Rela *relocs,
12980                             Elf_Internal_Sym *local_syms,
12981                             asection **local_sections)
12982 {
12983   struct ppc_link_hash_table *htab;
12984   Elf_Internal_Shdr *symtab_hdr;
12985   struct elf_link_hash_entry **sym_hashes;
12986   Elf_Internal_Rela *rel;
12987   Elf_Internal_Rela *relend;
12988   Elf_Internal_Rela outrel;
12989   bfd_byte *loc;
12990   struct got_entry **local_got_ents;
12991   bfd_vma TOCstart;
12992   bfd_boolean ret = TRUE;
12993   bfd_boolean is_opd;
12994   /* Assume 'at' branch hints.  */
12995   bfd_boolean is_isa_v2 = TRUE;
12996   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12997
12998   /* Initialize howto table if needed.  */
12999   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13000     ppc_howto_init ();
13001
13002   htab = ppc_hash_table (info);
13003   if (htab == NULL)
13004     return FALSE;
13005
13006   /* Don't relocate stub sections.  */
13007   if (input_section->owner == htab->params->stub_bfd)
13008     return TRUE;
13009
13010   BFD_ASSERT (is_ppc64_elf (input_bfd));
13011
13012   local_got_ents = elf_local_got_ents (input_bfd);
13013   TOCstart = elf_gp (output_bfd);
13014   symtab_hdr = &elf_symtab_hdr (input_bfd);
13015   sym_hashes = elf_sym_hashes (input_bfd);
13016   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13017
13018   rel = relocs;
13019   relend = relocs + input_section->reloc_count;
13020   for (; rel < relend; rel++)
13021     {
13022       enum elf_ppc64_reloc_type r_type;
13023       bfd_vma addend;
13024       bfd_reloc_status_type r;
13025       Elf_Internal_Sym *sym;
13026       asection *sec;
13027       struct elf_link_hash_entry *h_elf;
13028       struct ppc_link_hash_entry *h;
13029       struct ppc_link_hash_entry *fdh;
13030       const char *sym_name;
13031       unsigned long r_symndx, toc_symndx;
13032       bfd_vma toc_addend;
13033       unsigned char tls_mask, tls_gd, tls_type;
13034       unsigned char sym_type;
13035       bfd_vma relocation;
13036       bfd_boolean unresolved_reloc;
13037       bfd_boolean warned;
13038       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13039       unsigned int insn;
13040       unsigned int mask;
13041       struct ppc_stub_hash_entry *stub_entry;
13042       bfd_vma max_br_offset;
13043       bfd_vma from;
13044       const Elf_Internal_Rela orig_rel = *rel;
13045       reloc_howto_type *howto;
13046       struct reloc_howto_struct alt_howto;
13047
13048       r_type = ELF64_R_TYPE (rel->r_info);
13049       r_symndx = ELF64_R_SYM (rel->r_info);
13050
13051       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13052          symbol of the previous ADDR64 reloc.  The symbol gives us the
13053          proper TOC base to use.  */
13054       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13055           && rel != relocs
13056           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
13057           && is_opd)
13058         r_symndx = ELF64_R_SYM (rel[-1].r_info);
13059
13060       sym = NULL;
13061       sec = NULL;
13062       h_elf = NULL;
13063       sym_name = NULL;
13064       unresolved_reloc = FALSE;
13065       warned = FALSE;
13066
13067       if (r_symndx < symtab_hdr->sh_info)
13068         {
13069           /* It's a local symbol.  */
13070           struct _opd_sec_data *opd;
13071
13072           sym = local_syms + r_symndx;
13073           sec = local_sections[r_symndx];
13074           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13075           sym_type = ELF64_ST_TYPE (sym->st_info);
13076           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13077           opd = get_opd_info (sec);
13078           if (opd != NULL && opd->adjust != NULL)
13079             {
13080               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13081               if (adjust == -1)
13082                 relocation = 0;
13083               else
13084                 {
13085                   /* If this is a relocation against the opd section sym
13086                      and we have edited .opd, adjust the reloc addend so
13087                      that ld -r and ld --emit-relocs output is correct.
13088                      If it is a reloc against some other .opd symbol,
13089                      then the symbol value will be adjusted later.  */
13090                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13091                     rel->r_addend += adjust;
13092                   else
13093                     relocation += adjust;
13094                 }
13095             }
13096         }
13097       else
13098         {
13099           bfd_boolean ignored;
13100
13101           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13102                                    r_symndx, symtab_hdr, sym_hashes,
13103                                    h_elf, sec, relocation,
13104                                    unresolved_reloc, warned, ignored);
13105           sym_name = h_elf->root.root.string;
13106           sym_type = h_elf->type;
13107           if (sec != NULL
13108               && sec->owner == output_bfd
13109               && strcmp (sec->name, ".opd") == 0)
13110             {
13111               /* This is a symbol defined in a linker script.  All
13112                  such are defined in output sections, even those
13113                  defined by simple assignment from a symbol defined in
13114                  an input section.  Transfer the symbol to an
13115                  appropriate input .opd section, so that a branch to
13116                  this symbol will be mapped to the location specified
13117                  by the opd entry.  */
13118               struct bfd_link_order *lo;
13119               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13120                 if (lo->type == bfd_indirect_link_order)
13121                   {
13122                     asection *isec = lo->u.indirect.section;
13123                     if (h_elf->root.u.def.value >= isec->output_offset
13124                         && h_elf->root.u.def.value < (isec->output_offset
13125                                                       + isec->size))
13126                       {
13127                         h_elf->root.u.def.value -= isec->output_offset;
13128                         h_elf->root.u.def.section = isec;
13129                         sec = isec;
13130                         break;
13131                       }
13132                   }
13133             }
13134         }
13135       h = (struct ppc_link_hash_entry *) h_elf;
13136
13137       if (sec != NULL && discarded_section (sec))
13138         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13139                                          rel, 1, relend,
13140                                          ppc64_elf_howto_table[r_type], 0,
13141                                          contents);
13142
13143       if (info->relocatable)
13144         continue;
13145
13146       if (h != NULL && &h->elf == htab->elf.hgot)
13147         {
13148           relocation = (TOCstart
13149                         + htab->stub_group[input_section->id].toc_off);
13150           sec = bfd_abs_section_ptr;
13151           unresolved_reloc = FALSE;
13152         }
13153
13154       /* TLS optimizations.  Replace instruction sequences and relocs
13155          based on information we collected in tls_optimize.  We edit
13156          RELOCS so that --emit-relocs will output something sensible
13157          for the final instruction stream.  */
13158       tls_mask = 0;
13159       tls_gd = 0;
13160       toc_symndx = 0;
13161       if (h != NULL)
13162         tls_mask = h->tls_mask;
13163       else if (local_got_ents != NULL)
13164         {
13165           struct plt_entry **local_plt = (struct plt_entry **)
13166             (local_got_ents + symtab_hdr->sh_info);
13167           unsigned char *lgot_masks = (unsigned char *)
13168             (local_plt + symtab_hdr->sh_info);
13169           tls_mask = lgot_masks[r_symndx];
13170         }
13171       if (tls_mask == 0
13172           && (r_type == R_PPC64_TLS
13173               || r_type == R_PPC64_TLSGD
13174               || r_type == R_PPC64_TLSLD))
13175         {
13176           /* Check for toc tls entries.  */
13177           unsigned char *toc_tls;
13178
13179           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13180                              &local_syms, rel, input_bfd))
13181             return FALSE;
13182
13183           if (toc_tls)
13184             tls_mask = *toc_tls;
13185         }
13186
13187       /* Check that tls relocs are used with tls syms, and non-tls
13188          relocs are used with non-tls syms.  */
13189       if (r_symndx != STN_UNDEF
13190           && r_type != R_PPC64_NONE
13191           && (h == NULL
13192               || h->elf.root.type == bfd_link_hash_defined
13193               || h->elf.root.type == bfd_link_hash_defweak)
13194           && (IS_PPC64_TLS_RELOC (r_type)
13195               != (sym_type == STT_TLS
13196                   || (sym_type == STT_SECTION
13197                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13198         {
13199           if (tls_mask != 0
13200               && (r_type == R_PPC64_TLS
13201                   || r_type == R_PPC64_TLSGD
13202                   || r_type == R_PPC64_TLSLD))
13203             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13204             ;
13205           else
13206             info->callbacks->einfo
13207               (!IS_PPC64_TLS_RELOC (r_type)
13208                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13209                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13210                input_bfd, input_section, rel->r_offset,
13211                ppc64_elf_howto_table[r_type]->name,
13212                sym_name);
13213         }
13214
13215       /* Ensure reloc mapping code below stays sane.  */
13216       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13217           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13218           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13219           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13220           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13221           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13222           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13223           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13224           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13225           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13226         abort ();
13227
13228       switch (r_type)
13229         {
13230         default:
13231           break;
13232
13233         case R_PPC64_LO_DS_OPT:
13234           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13235           if ((insn & (0x3f << 26)) != 58u << 26)
13236             abort ();
13237           insn += (14u << 26) - (58u << 26);
13238           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13239           r_type = R_PPC64_TOC16_LO;
13240           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13241           break;
13242
13243         case R_PPC64_TOC16:
13244         case R_PPC64_TOC16_LO:
13245         case R_PPC64_TOC16_DS:
13246         case R_PPC64_TOC16_LO_DS:
13247           {
13248             /* Check for toc tls entries.  */
13249             unsigned char *toc_tls;
13250             int retval;
13251
13252             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13253                                    &local_syms, rel, input_bfd);
13254             if (retval == 0)
13255               return FALSE;
13256
13257             if (toc_tls)
13258               {
13259                 tls_mask = *toc_tls;
13260                 if (r_type == R_PPC64_TOC16_DS
13261                     || r_type == R_PPC64_TOC16_LO_DS)
13262                   {
13263                     if (tls_mask != 0
13264                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13265                       goto toctprel;
13266                   }
13267                 else
13268                   {
13269                     /* If we found a GD reloc pair, then we might be
13270                        doing a GD->IE transition.  */
13271                     if (retval == 2)
13272                       {
13273                         tls_gd = TLS_TPRELGD;
13274                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13275                           goto tls_ldgd_opt;
13276                       }
13277                     else if (retval == 3)
13278                       {
13279                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13280                           goto tls_ldgd_opt;
13281                       }
13282                   }
13283               }
13284           }
13285           break;
13286
13287         case R_PPC64_GOT_TPREL16_HI:
13288         case R_PPC64_GOT_TPREL16_HA:
13289           if (tls_mask != 0
13290               && (tls_mask & TLS_TPREL) == 0)
13291             {
13292               rel->r_offset -= d_offset;
13293               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13294               r_type = R_PPC64_NONE;
13295               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13296             }
13297           break;
13298
13299         case R_PPC64_GOT_TPREL16_DS:
13300         case R_PPC64_GOT_TPREL16_LO_DS:
13301           if (tls_mask != 0
13302               && (tls_mask & TLS_TPREL) == 0)
13303             {
13304             toctprel:
13305               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13306               insn &= 31 << 21;
13307               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13308               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13309               r_type = R_PPC64_TPREL16_HA;
13310               if (toc_symndx != 0)
13311                 {
13312                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13313                   rel->r_addend = toc_addend;
13314                   /* We changed the symbol.  Start over in order to
13315                      get h, sym, sec etc. right.  */
13316                   rel--;
13317                   continue;
13318                 }
13319               else
13320                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13321             }
13322           break;
13323
13324         case R_PPC64_TLS:
13325           if (tls_mask != 0
13326               && (tls_mask & TLS_TPREL) == 0)
13327             {
13328               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13329               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13330               if (insn == 0)
13331                 abort ();
13332               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13333               /* Was PPC64_TLS which sits on insn boundary, now
13334                  PPC64_TPREL16_LO which is at low-order half-word.  */
13335               rel->r_offset += d_offset;
13336               r_type = R_PPC64_TPREL16_LO;
13337               if (toc_symndx != 0)
13338                 {
13339                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13340                   rel->r_addend = toc_addend;
13341                   /* We changed the symbol.  Start over in order to
13342                      get h, sym, sec etc. right.  */
13343                   rel--;
13344                   continue;
13345                 }
13346               else
13347                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13348             }
13349           break;
13350
13351         case R_PPC64_GOT_TLSGD16_HI:
13352         case R_PPC64_GOT_TLSGD16_HA:
13353           tls_gd = TLS_TPRELGD;
13354           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13355             goto tls_gdld_hi;
13356           break;
13357
13358         case R_PPC64_GOT_TLSLD16_HI:
13359         case R_PPC64_GOT_TLSLD16_HA:
13360           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13361             {
13362             tls_gdld_hi:
13363               if ((tls_mask & tls_gd) != 0)
13364                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13365                           + R_PPC64_GOT_TPREL16_DS);
13366               else
13367                 {
13368                   rel->r_offset -= d_offset;
13369                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13370                   r_type = R_PPC64_NONE;
13371                 }
13372               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13373             }
13374           break;
13375
13376         case R_PPC64_GOT_TLSGD16:
13377         case R_PPC64_GOT_TLSGD16_LO:
13378           tls_gd = TLS_TPRELGD;
13379           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13380             goto tls_ldgd_opt;
13381           break;
13382
13383         case R_PPC64_GOT_TLSLD16:
13384         case R_PPC64_GOT_TLSLD16_LO:
13385           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13386             {
13387               unsigned int insn1, insn2, insn3;
13388               bfd_vma offset;
13389
13390             tls_ldgd_opt:
13391               offset = (bfd_vma) -1;
13392               /* If not using the newer R_PPC64_TLSGD/LD to mark
13393                  __tls_get_addr calls, we must trust that the call
13394                  stays with its arg setup insns, ie. that the next
13395                  reloc is the __tls_get_addr call associated with
13396                  the current reloc.  Edit both insns.  */
13397               if (input_section->has_tls_get_addr_call
13398                   && rel + 1 < relend
13399                   && branch_reloc_hash_match (input_bfd, rel + 1,
13400                                               htab->tls_get_addr,
13401                                               htab->tls_get_addr_fd))
13402                 offset = rel[1].r_offset;
13403               if ((tls_mask & tls_gd) != 0)
13404                 {
13405                   /* IE */
13406                   insn1 = bfd_get_32 (output_bfd,
13407                                       contents + rel->r_offset - d_offset);
13408                   insn1 &= (1 << 26) - (1 << 2);
13409                   insn1 |= 58 << 26;    /* ld */
13410                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13411                   if (offset != (bfd_vma) -1)
13412                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13413                   if ((tls_mask & TLS_EXPLICIT) == 0)
13414                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13415                               + R_PPC64_GOT_TPREL16_DS);
13416                   else
13417                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13418                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13419                 }
13420               else
13421                 {
13422                   /* LE */
13423                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13424                   insn2 = 0x38630000;   /* addi 3,3,0 */
13425                   if (tls_gd == 0)
13426                     {
13427                       /* Was an LD reloc.  */
13428                       if (toc_symndx)
13429                         sec = local_sections[toc_symndx];
13430                       for (r_symndx = 0;
13431                            r_symndx < symtab_hdr->sh_info;
13432                            r_symndx++)
13433                         if (local_sections[r_symndx] == sec)
13434                           break;
13435                       if (r_symndx >= symtab_hdr->sh_info)
13436                         r_symndx = STN_UNDEF;
13437                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13438                       if (r_symndx != STN_UNDEF)
13439                         rel->r_addend -= (local_syms[r_symndx].st_value
13440                                           + sec->output_offset
13441                                           + sec->output_section->vma);
13442                     }
13443                   else if (toc_symndx != 0)
13444                     {
13445                       r_symndx = toc_symndx;
13446                       rel->r_addend = toc_addend;
13447                     }
13448                   r_type = R_PPC64_TPREL16_HA;
13449                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13450                   if (offset != (bfd_vma) -1)
13451                     {
13452                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13453                                                     R_PPC64_TPREL16_LO);
13454                       rel[1].r_offset = offset + d_offset;
13455                       rel[1].r_addend = rel->r_addend;
13456                     }
13457                 }
13458               bfd_put_32 (output_bfd, insn1,
13459                           contents + rel->r_offset - d_offset);
13460               if (offset != (bfd_vma) -1)
13461                 {
13462                   insn3 = bfd_get_32 (output_bfd,
13463                                       contents + offset + 4);
13464                   if (insn3 == NOP
13465                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13466                     {
13467                       rel[1].r_offset += 4;
13468                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13469                       insn2 = NOP;
13470                     }
13471                   bfd_put_32 (output_bfd, insn2, contents + offset);
13472                 }
13473               if ((tls_mask & tls_gd) == 0
13474                   && (tls_gd == 0 || toc_symndx != 0))
13475                 {
13476                   /* We changed the symbol.  Start over in order
13477                      to get h, sym, sec etc. right.  */
13478                   rel--;
13479                   continue;
13480                 }
13481             }
13482           break;
13483
13484         case R_PPC64_TLSGD:
13485           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13486             {
13487               unsigned int insn2, insn3;
13488               bfd_vma offset = rel->r_offset;
13489
13490               if ((tls_mask & TLS_TPRELGD) != 0)
13491                 {
13492                   /* IE */
13493                   r_type = R_PPC64_NONE;
13494                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13495                 }
13496               else
13497                 {
13498                   /* LE */
13499                   if (toc_symndx != 0)
13500                     {
13501                       r_symndx = toc_symndx;
13502                       rel->r_addend = toc_addend;
13503                     }
13504                   r_type = R_PPC64_TPREL16_LO;
13505                   rel->r_offset = offset + d_offset;
13506                   insn2 = 0x38630000;   /* addi 3,3,0 */
13507                 }
13508               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13509               /* Zap the reloc on the _tls_get_addr call too.  */
13510               BFD_ASSERT (offset == rel[1].r_offset);
13511               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13512               insn3 = bfd_get_32 (output_bfd,
13513                                   contents + offset + 4);
13514               if (insn3 == NOP
13515                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13516                 {
13517                   rel->r_offset += 4;
13518                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13519                   insn2 = NOP;
13520                 }
13521               bfd_put_32 (output_bfd, insn2, contents + offset);
13522               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13523                 {
13524                   rel--;
13525                   continue;
13526                 }
13527             }
13528           break;
13529
13530         case R_PPC64_TLSLD:
13531           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13532             {
13533               unsigned int insn2, insn3;
13534               bfd_vma offset = rel->r_offset;
13535
13536               if (toc_symndx)
13537                 sec = local_sections[toc_symndx];
13538               for (r_symndx = 0;
13539                    r_symndx < symtab_hdr->sh_info;
13540                    r_symndx++)
13541                 if (local_sections[r_symndx] == sec)
13542                   break;
13543               if (r_symndx >= symtab_hdr->sh_info)
13544                 r_symndx = STN_UNDEF;
13545               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13546               if (r_symndx != STN_UNDEF)
13547                 rel->r_addend -= (local_syms[r_symndx].st_value
13548                                   + sec->output_offset
13549                                   + sec->output_section->vma);
13550
13551               r_type = R_PPC64_TPREL16_LO;
13552               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13553               rel->r_offset = offset + d_offset;
13554               /* Zap the reloc on the _tls_get_addr call too.  */
13555               BFD_ASSERT (offset == rel[1].r_offset);
13556               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13557               insn2 = 0x38630000;       /* addi 3,3,0 */
13558               insn3 = bfd_get_32 (output_bfd,
13559                                   contents + offset + 4);
13560               if (insn3 == NOP
13561                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13562                 {
13563                   rel->r_offset += 4;
13564                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13565                   insn2 = NOP;
13566                 }
13567               bfd_put_32 (output_bfd, insn2, contents + offset);
13568               rel--;
13569               continue;
13570             }
13571           break;
13572
13573         case R_PPC64_DTPMOD64:
13574           if (rel + 1 < relend
13575               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13576               && rel[1].r_offset == rel->r_offset + 8)
13577             {
13578               if ((tls_mask & TLS_GD) == 0)
13579                 {
13580                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13581                   if ((tls_mask & TLS_TPRELGD) != 0)
13582                     r_type = R_PPC64_TPREL64;
13583                   else
13584                     {
13585                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13586                       r_type = R_PPC64_NONE;
13587                     }
13588                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13589                 }
13590             }
13591           else
13592             {
13593               if ((tls_mask & TLS_LD) == 0)
13594                 {
13595                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13596                   r_type = R_PPC64_NONE;
13597                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13598                 }
13599             }
13600           break;
13601
13602         case R_PPC64_TPREL64:
13603           if ((tls_mask & TLS_TPREL) == 0)
13604             {
13605               r_type = R_PPC64_NONE;
13606               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13607             }
13608           break;
13609
13610         case R_PPC64_REL16_HA:
13611           /* If we are generating a non-PIC executable, edit
13612              .  0:      addis 2,12,.TOC.-0b@ha
13613              .          addi 2,2,.TOC.-0b@l
13614              used by ELFv2 global entry points to set up r2, to
13615              .          lis 2,.TOC.@ha
13616              .          addi 2,2,.TOC.@l
13617              if .TOC. is in range.  */
13618           if (!info->shared
13619               && !info->traditional_format
13620               && h != NULL && &h->elf == htab->elf.hgot
13621               && rel + 1 < relend
13622               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13623               && rel[1].r_offset == rel->r_offset + 4
13624               && rel[1].r_addend == rel->r_addend + 4
13625               && relocation + 0x80008000 <= 0xffffffff)
13626             {
13627               unsigned int insn1, insn2;
13628               bfd_vma offset = rel->r_offset - d_offset;
13629               insn1 = bfd_get_32 (output_bfd, contents + offset);
13630               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13631               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13632                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13633                 {
13634                   r_type = R_PPC64_ADDR16_HA;
13635                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13636                   rel->r_addend -= d_offset;
13637                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13638                   rel[1].r_addend -= d_offset + 4;
13639                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13640                 }
13641             }
13642           break;
13643         }
13644
13645       /* Handle other relocations that tweak non-addend part of insn.  */
13646       insn = 0;
13647       max_br_offset = 1 << 25;
13648       addend = rel->r_addend;
13649       reloc_dest = DEST_NORMAL;
13650       switch (r_type)
13651         {
13652         default:
13653           break;
13654
13655         case R_PPC64_TOCSAVE:
13656           if (relocation + addend == (rel->r_offset
13657                                       + input_section->output_offset
13658                                       + input_section->output_section->vma)
13659               && tocsave_find (htab, NO_INSERT,
13660                                &local_syms, rel, input_bfd))
13661             {
13662               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13663               if (insn == NOP
13664                   || insn == CROR_151515 || insn == CROR_313131)
13665                 bfd_put_32 (input_bfd,
13666                             STD_R2_0R1 + STK_TOC (htab),
13667                             contents + rel->r_offset);
13668             }
13669           break;
13670
13671           /* Branch taken prediction relocations.  */
13672         case R_PPC64_ADDR14_BRTAKEN:
13673         case R_PPC64_REL14_BRTAKEN:
13674           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13675           /* Fall thru.  */
13676
13677           /* Branch not taken prediction relocations.  */
13678         case R_PPC64_ADDR14_BRNTAKEN:
13679         case R_PPC64_REL14_BRNTAKEN:
13680           insn |= bfd_get_32 (output_bfd,
13681                               contents + rel->r_offset) & ~(0x01 << 21);
13682           /* Fall thru.  */
13683
13684         case R_PPC64_REL14:
13685           max_br_offset = 1 << 15;
13686           /* Fall thru.  */
13687
13688         case R_PPC64_REL24:
13689           /* Calls to functions with a different TOC, such as calls to
13690              shared objects, need to alter the TOC pointer.  This is
13691              done using a linkage stub.  A REL24 branching to these
13692              linkage stubs needs to be followed by a nop, as the nop
13693              will be replaced with an instruction to restore the TOC
13694              base pointer.  */
13695           fdh = h;
13696           if (h != NULL
13697               && h->oh != NULL
13698               && h->oh->is_func_descriptor)
13699             fdh = ppc_follow_link (h->oh);
13700           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13701                                            htab);
13702           if (stub_entry != NULL
13703               && (stub_entry->stub_type == ppc_stub_plt_call
13704                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13705                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13706                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13707             {
13708               bfd_boolean can_plt_call = FALSE;
13709
13710               /* All of these stubs will modify r2, so there must be a
13711                  branch and link followed by a nop.  The nop is
13712                  replaced by an insn to restore r2.  */
13713               if (rel->r_offset + 8 <= input_section->size)
13714                 {
13715                   unsigned long br;
13716
13717                   br = bfd_get_32 (input_bfd,
13718                                    contents + rel->r_offset);
13719                   if ((br & 1) != 0)
13720                     {
13721                       unsigned long nop;
13722
13723                       nop = bfd_get_32 (input_bfd,
13724                                         contents + rel->r_offset + 4);
13725                       if (nop == NOP
13726                           || nop == CROR_151515 || nop == CROR_313131)
13727                         {
13728                           if (h != NULL
13729                               && (h == htab->tls_get_addr_fd
13730                                   || h == htab->tls_get_addr)
13731                               && !htab->params->no_tls_get_addr_opt)
13732                             {
13733                               /* Special stub used, leave nop alone.  */
13734                             }
13735                           else
13736                             bfd_put_32 (input_bfd,
13737                                         LD_R2_0R1 + STK_TOC (htab),
13738                                         contents + rel->r_offset + 4);
13739                           can_plt_call = TRUE;
13740                         }
13741                     }
13742                 }
13743
13744               if (!can_plt_call && h != NULL)
13745                 {
13746                   const char *name = h->elf.root.root.string;
13747
13748                   if (*name == '.')
13749                     ++name;
13750
13751                   if (strncmp (name, "__libc_start_main", 17) == 0
13752                       && (name[17] == 0 || name[17] == '@'))
13753                     {
13754                       /* Allow crt1 branch to go via a toc adjusting
13755                          stub.  Other calls that never return could do
13756                          the same, if we could detect such.  */
13757                       can_plt_call = TRUE;
13758                     }
13759                 }
13760
13761               if (!can_plt_call)
13762                 {
13763                   /* g++ as of 20130507 emits self-calls without a
13764                      following nop.  This is arguably wrong since we
13765                      have conflicting information.  On the one hand a
13766                      global symbol and on the other a local call
13767                      sequence, but don't error for this special case.
13768                      It isn't possible to cheaply verify we have
13769                      exactly such a call.  Allow all calls to the same
13770                      section.  */
13771                   asection *code_sec = sec;
13772
13773                   if (get_opd_info (sec) != NULL)
13774                     {
13775                       bfd_vma off = (relocation + addend
13776                                      - sec->output_section->vma
13777                                      - sec->output_offset);
13778
13779                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13780                     }
13781                   if (code_sec == input_section)
13782                     can_plt_call = TRUE;
13783                 }
13784
13785               if (!can_plt_call)
13786                 {
13787                   info->callbacks->einfo
13788                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13789                        "recompile with -fPIC\n"),
13790                      input_bfd, input_section, rel->r_offset, sym_name);
13791
13792                   bfd_set_error (bfd_error_bad_value);
13793                   ret = FALSE;
13794                 }
13795
13796               if (can_plt_call
13797                   && (stub_entry->stub_type == ppc_stub_plt_call
13798                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13799                 unresolved_reloc = FALSE;
13800             }
13801
13802           if ((stub_entry == NULL
13803                || stub_entry->stub_type == ppc_stub_long_branch
13804                || stub_entry->stub_type == ppc_stub_plt_branch)
13805               && get_opd_info (sec) != NULL)
13806             {
13807               /* The branch destination is the value of the opd entry. */
13808               bfd_vma off = (relocation + addend
13809                              - sec->output_section->vma
13810                              - sec->output_offset);
13811               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13812               if (dest != (bfd_vma) -1)
13813                 {
13814                   relocation = dest;
13815                   addend = 0;
13816                   reloc_dest = DEST_OPD;
13817                 }
13818             }
13819
13820           /* If the branch is out of reach we ought to have a long
13821              branch stub.  */
13822           from = (rel->r_offset
13823                   + input_section->output_offset
13824                   + input_section->output_section->vma);
13825
13826           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13827                                                   ? fdh->elf.other
13828                                                   : sym->st_other);
13829
13830           if (stub_entry != NULL
13831               && (stub_entry->stub_type == ppc_stub_long_branch
13832                   || stub_entry->stub_type == ppc_stub_plt_branch)
13833               && (r_type == R_PPC64_ADDR14_BRTAKEN
13834                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13835                   || (relocation + addend - from + max_br_offset
13836                       < 2 * max_br_offset)))
13837             /* Don't use the stub if this branch is in range.  */
13838             stub_entry = NULL;
13839
13840           if (stub_entry != NULL)
13841             {
13842               /* Munge up the value and addend so that we call the stub
13843                  rather than the procedure directly.  */
13844               relocation = (stub_entry->stub_offset
13845                             + stub_entry->stub_sec->output_offset
13846                             + stub_entry->stub_sec->output_section->vma);
13847               addend = 0;
13848               reloc_dest = DEST_STUB;
13849
13850               if ((stub_entry->stub_type == ppc_stub_plt_call
13851                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13852                   && (ALWAYS_EMIT_R2SAVE
13853                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13854                   && rel + 1 < relend
13855                   && rel[1].r_offset == rel->r_offset + 4
13856                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13857                 relocation += 4;
13858             }
13859
13860           if (insn != 0)
13861             {
13862               if (is_isa_v2)
13863                 {
13864                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13865                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13866                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13867                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13868                     insn |= 0x02 << 21;
13869                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13870                     insn |= 0x08 << 21;
13871                   else
13872                     break;
13873                 }
13874               else
13875                 {
13876                   /* Invert 'y' bit if not the default.  */
13877                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13878                     insn ^= 0x01 << 21;
13879                 }
13880
13881               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13882             }
13883
13884           /* NOP out calls to undefined weak functions.
13885              We can thus call a weak function without first
13886              checking whether the function is defined.  */
13887           else if (h != NULL
13888                    && h->elf.root.type == bfd_link_hash_undefweak
13889                    && h->elf.dynindx == -1
13890                    && r_type == R_PPC64_REL24
13891                    && relocation == 0
13892                    && addend == 0)
13893             {
13894               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13895               continue;
13896             }
13897           break;
13898         }
13899
13900       /* Set `addend'.  */
13901       tls_type = 0;
13902       switch (r_type)
13903         {
13904         default:
13905           info->callbacks->einfo
13906             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13907              input_bfd, (int) r_type, sym_name);
13908
13909           bfd_set_error (bfd_error_bad_value);
13910           ret = FALSE;
13911           continue;
13912
13913         case R_PPC64_NONE:
13914         case R_PPC64_TLS:
13915         case R_PPC64_TLSGD:
13916         case R_PPC64_TLSLD:
13917         case R_PPC64_TOCSAVE:
13918         case R_PPC64_GNU_VTINHERIT:
13919         case R_PPC64_GNU_VTENTRY:
13920           continue;
13921
13922           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13923              address in the GOT as relocation value instead of the
13924              symbol's value itself.  Also, create a GOT entry for the
13925              symbol and put the symbol value there.  */
13926         case R_PPC64_GOT_TLSGD16:
13927         case R_PPC64_GOT_TLSGD16_LO:
13928         case R_PPC64_GOT_TLSGD16_HI:
13929         case R_PPC64_GOT_TLSGD16_HA:
13930           tls_type = TLS_TLS | TLS_GD;
13931           goto dogot;
13932
13933         case R_PPC64_GOT_TLSLD16:
13934         case R_PPC64_GOT_TLSLD16_LO:
13935         case R_PPC64_GOT_TLSLD16_HI:
13936         case R_PPC64_GOT_TLSLD16_HA:
13937           tls_type = TLS_TLS | TLS_LD;
13938           goto dogot;
13939
13940         case R_PPC64_GOT_TPREL16_DS:
13941         case R_PPC64_GOT_TPREL16_LO_DS:
13942         case R_PPC64_GOT_TPREL16_HI:
13943         case R_PPC64_GOT_TPREL16_HA:
13944           tls_type = TLS_TLS | TLS_TPREL;
13945           goto dogot;
13946
13947         case R_PPC64_GOT_DTPREL16_DS:
13948         case R_PPC64_GOT_DTPREL16_LO_DS:
13949         case R_PPC64_GOT_DTPREL16_HI:
13950         case R_PPC64_GOT_DTPREL16_HA:
13951           tls_type = TLS_TLS | TLS_DTPREL;
13952           goto dogot;
13953
13954         case R_PPC64_GOT16:
13955         case R_PPC64_GOT16_LO:
13956         case R_PPC64_GOT16_HI:
13957         case R_PPC64_GOT16_HA:
13958         case R_PPC64_GOT16_DS:
13959         case R_PPC64_GOT16_LO_DS:
13960         dogot:
13961           {
13962             /* Relocation is to the entry for this symbol in the global
13963                offset table.  */
13964             asection *got;
13965             bfd_vma *offp;
13966             bfd_vma off;
13967             unsigned long indx = 0;
13968             struct got_entry *ent;
13969
13970             if (tls_type == (TLS_TLS | TLS_LD)
13971                 && (h == NULL
13972                     || !h->elf.def_dynamic))
13973               ent = ppc64_tlsld_got (input_bfd);
13974             else
13975               {
13976
13977                 if (h != NULL)
13978                   {
13979                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13980                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13981                                                           &h->elf)
13982                         || (info->shared
13983                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13984                       /* This is actually a static link, or it is a
13985                          -Bsymbolic link and the symbol is defined
13986                          locally, or the symbol was forced to be local
13987                          because of a version file.  */
13988                       ;
13989                     else
13990                       {
13991                         BFD_ASSERT (h->elf.dynindx != -1);
13992                         indx = h->elf.dynindx;
13993                         unresolved_reloc = FALSE;
13994                       }
13995                     ent = h->elf.got.glist;
13996                   }
13997                 else
13998                   {
13999                     if (local_got_ents == NULL)
14000                       abort ();
14001                     ent = local_got_ents[r_symndx];
14002                   }
14003
14004                 for (; ent != NULL; ent = ent->next)
14005                   if (ent->addend == orig_rel.r_addend
14006                       && ent->owner == input_bfd
14007                       && ent->tls_type == tls_type)
14008                     break;
14009               }
14010
14011             if (ent == NULL)
14012               abort ();
14013             if (ent->is_indirect)
14014               ent = ent->got.ent;
14015             offp = &ent->got.offset;
14016             got = ppc64_elf_tdata (ent->owner)->got;
14017             if (got == NULL)
14018               abort ();
14019
14020             /* The offset must always be a multiple of 8.  We use the
14021                least significant bit to record whether we have already
14022                processed this entry.  */
14023             off = *offp;
14024             if ((off & 1) != 0)
14025               off &= ~1;
14026             else
14027               {
14028                 /* Generate relocs for the dynamic linker, except in
14029                    the case of TLSLD where we'll use one entry per
14030                    module.  */
14031                 asection *relgot;
14032                 bfd_boolean ifunc;
14033
14034                 *offp = off | 1;
14035                 relgot = NULL;
14036                 ifunc = (h != NULL
14037                          ? h->elf.type == STT_GNU_IFUNC
14038                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14039                 if (ifunc)
14040                   relgot = htab->elf.irelplt;
14041                 else if ((info->shared || indx != 0)
14042                          && (h == NULL
14043                              || (tls_type == (TLS_TLS | TLS_LD)
14044                                  && !h->elf.def_dynamic)
14045                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14046                              || h->elf.root.type != bfd_link_hash_undefweak))
14047                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14048                 if (relgot != NULL)
14049                   {
14050                     outrel.r_offset = (got->output_section->vma
14051                                        + got->output_offset
14052                                        + off);
14053                     outrel.r_addend = addend;
14054                     if (tls_type & (TLS_LD | TLS_GD))
14055                       {
14056                         outrel.r_addend = 0;
14057                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14058                         if (tls_type == (TLS_TLS | TLS_GD))
14059                           {
14060                             loc = relgot->contents;
14061                             loc += (relgot->reloc_count++
14062                                     * sizeof (Elf64_External_Rela));
14063                             bfd_elf64_swap_reloca_out (output_bfd,
14064                                                        &outrel, loc);
14065                             outrel.r_offset += 8;
14066                             outrel.r_addend = addend;
14067                             outrel.r_info
14068                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14069                           }
14070                       }
14071                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14072                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14073                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14074                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14075                     else if (indx != 0)
14076                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14077                     else
14078                       {
14079                         if (ifunc)
14080                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14081                         else
14082                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14083
14084                         /* Write the .got section contents for the sake
14085                            of prelink.  */
14086                         loc = got->contents + off;
14087                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14088                                     loc);
14089                       }
14090
14091                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14092                       {
14093                         outrel.r_addend += relocation;
14094                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14095                           outrel.r_addend -= htab->elf.tls_sec->vma;
14096                       }
14097                     loc = relgot->contents;
14098                     loc += (relgot->reloc_count++
14099                             * sizeof (Elf64_External_Rela));
14100                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14101                   }
14102
14103                 /* Init the .got section contents here if we're not
14104                    emitting a reloc.  */
14105                 else
14106                   {
14107                     relocation += addend;
14108                     if (tls_type == (TLS_TLS | TLS_LD))
14109                       relocation = 1;
14110                     else if (tls_type != 0)
14111                       {
14112                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14113                         if (tls_type == (TLS_TLS | TLS_TPREL))
14114                           relocation += DTP_OFFSET - TP_OFFSET;
14115
14116                         if (tls_type == (TLS_TLS | TLS_GD))
14117                           {
14118                             bfd_put_64 (output_bfd, relocation,
14119                                         got->contents + off + 8);
14120                             relocation = 1;
14121                           }
14122                       }
14123
14124                     bfd_put_64 (output_bfd, relocation,
14125                                 got->contents + off);
14126                   }
14127               }
14128
14129             if (off >= (bfd_vma) -2)
14130               abort ();
14131
14132             relocation = got->output_section->vma + got->output_offset + off;
14133             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14134           }
14135           break;
14136
14137         case R_PPC64_PLT16_HA:
14138         case R_PPC64_PLT16_HI:
14139         case R_PPC64_PLT16_LO:
14140         case R_PPC64_PLT32:
14141         case R_PPC64_PLT64:
14142           /* Relocation is to the entry for this symbol in the
14143              procedure linkage table.  */
14144
14145           /* Resolve a PLT reloc against a local symbol directly,
14146              without using the procedure linkage table.  */
14147           if (h == NULL)
14148             break;
14149
14150           /* It's possible that we didn't make a PLT entry for this
14151              symbol.  This happens when statically linking PIC code,
14152              or when using -Bsymbolic.  Go find a match if there is a
14153              PLT entry.  */
14154           if (htab->elf.splt != NULL)
14155             {
14156               struct plt_entry *ent;
14157               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14158                 if (ent->plt.offset != (bfd_vma) -1
14159                     && ent->addend == orig_rel.r_addend)
14160                   {
14161                     relocation = (htab->elf.splt->output_section->vma
14162                                   + htab->elf.splt->output_offset
14163                                   + ent->plt.offset);
14164                     unresolved_reloc = FALSE;
14165                     break;
14166                   }
14167             }
14168           break;
14169
14170         case R_PPC64_TOC:
14171           /* Relocation value is TOC base.  */
14172           relocation = TOCstart;
14173           if (r_symndx == STN_UNDEF)
14174             relocation += htab->stub_group[input_section->id].toc_off;
14175           else if (unresolved_reloc)
14176             ;
14177           else if (sec != NULL && sec->id <= htab->top_id)
14178             relocation += htab->stub_group[sec->id].toc_off;
14179           else
14180             unresolved_reloc = TRUE;
14181           goto dodyn;
14182
14183           /* TOC16 relocs.  We want the offset relative to the TOC base,
14184              which is the address of the start of the TOC plus 0x8000.
14185              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14186              in this order.  */
14187         case R_PPC64_TOC16:
14188         case R_PPC64_TOC16_LO:
14189         case R_PPC64_TOC16_HI:
14190         case R_PPC64_TOC16_DS:
14191         case R_PPC64_TOC16_LO_DS:
14192         case R_PPC64_TOC16_HA:
14193           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14194           break;
14195
14196           /* Relocate against the beginning of the section.  */
14197         case R_PPC64_SECTOFF:
14198         case R_PPC64_SECTOFF_LO:
14199         case R_PPC64_SECTOFF_HI:
14200         case R_PPC64_SECTOFF_DS:
14201         case R_PPC64_SECTOFF_LO_DS:
14202         case R_PPC64_SECTOFF_HA:
14203           if (sec != NULL)
14204             addend -= sec->output_section->vma;
14205           break;
14206
14207         case R_PPC64_REL16:
14208         case R_PPC64_REL16_LO:
14209         case R_PPC64_REL16_HI:
14210         case R_PPC64_REL16_HA:
14211           break;
14212
14213         case R_PPC64_REL14:
14214         case R_PPC64_REL14_BRNTAKEN:
14215         case R_PPC64_REL14_BRTAKEN:
14216         case R_PPC64_REL24:
14217           break;
14218
14219         case R_PPC64_TPREL16:
14220         case R_PPC64_TPREL16_LO:
14221         case R_PPC64_TPREL16_HI:
14222         case R_PPC64_TPREL16_HA:
14223         case R_PPC64_TPREL16_DS:
14224         case R_PPC64_TPREL16_LO_DS:
14225         case R_PPC64_TPREL16_HIGH:
14226         case R_PPC64_TPREL16_HIGHA:
14227         case R_PPC64_TPREL16_HIGHER:
14228         case R_PPC64_TPREL16_HIGHERA:
14229         case R_PPC64_TPREL16_HIGHEST:
14230         case R_PPC64_TPREL16_HIGHESTA:
14231           if (h != NULL
14232               && h->elf.root.type == bfd_link_hash_undefweak
14233               && h->elf.dynindx == -1)
14234             {
14235               /* Make this relocation against an undefined weak symbol
14236                  resolve to zero.  This is really just a tweak, since
14237                  code using weak externs ought to check that they are
14238                  defined before using them.  */
14239               bfd_byte *p = contents + rel->r_offset - d_offset;
14240
14241               insn = bfd_get_32 (output_bfd, p);
14242               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14243               if (insn != 0)
14244                 bfd_put_32 (output_bfd, insn, p);
14245               break;
14246             }
14247           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14248           if (info->shared)
14249             /* The TPREL16 relocs shouldn't really be used in shared
14250                libs as they will result in DT_TEXTREL being set, but
14251                support them anyway.  */
14252             goto dodyn;
14253           break;
14254
14255         case R_PPC64_DTPREL16:
14256         case R_PPC64_DTPREL16_LO:
14257         case R_PPC64_DTPREL16_HI:
14258         case R_PPC64_DTPREL16_HA:
14259         case R_PPC64_DTPREL16_DS:
14260         case R_PPC64_DTPREL16_LO_DS:
14261         case R_PPC64_DTPREL16_HIGH:
14262         case R_PPC64_DTPREL16_HIGHA:
14263         case R_PPC64_DTPREL16_HIGHER:
14264         case R_PPC64_DTPREL16_HIGHERA:
14265         case R_PPC64_DTPREL16_HIGHEST:
14266         case R_PPC64_DTPREL16_HIGHESTA:
14267           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14268           break;
14269
14270         case R_PPC64_ADDR64_LOCAL:
14271           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14272                                               ? h->elf.other
14273                                               : sym->st_other);
14274           break;
14275
14276         case R_PPC64_DTPMOD64:
14277           relocation = 1;
14278           addend = 0;
14279           goto dodyn;
14280
14281         case R_PPC64_TPREL64:
14282           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14283           goto dodyn;
14284
14285         case R_PPC64_DTPREL64:
14286           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14287           /* Fall thru */
14288
14289           /* Relocations that may need to be propagated if this is a
14290              dynamic object.  */
14291         case R_PPC64_REL30:
14292         case R_PPC64_REL32:
14293         case R_PPC64_REL64:
14294         case R_PPC64_ADDR14:
14295         case R_PPC64_ADDR14_BRNTAKEN:
14296         case R_PPC64_ADDR14_BRTAKEN:
14297         case R_PPC64_ADDR16:
14298         case R_PPC64_ADDR16_DS:
14299         case R_PPC64_ADDR16_HA:
14300         case R_PPC64_ADDR16_HI:
14301         case R_PPC64_ADDR16_HIGH:
14302         case R_PPC64_ADDR16_HIGHA:
14303         case R_PPC64_ADDR16_HIGHER:
14304         case R_PPC64_ADDR16_HIGHERA:
14305         case R_PPC64_ADDR16_HIGHEST:
14306         case R_PPC64_ADDR16_HIGHESTA:
14307         case R_PPC64_ADDR16_LO:
14308         case R_PPC64_ADDR16_LO_DS:
14309         case R_PPC64_ADDR24:
14310         case R_PPC64_ADDR32:
14311         case R_PPC64_ADDR64:
14312         case R_PPC64_UADDR16:
14313         case R_PPC64_UADDR32:
14314         case R_PPC64_UADDR64:
14315         dodyn:
14316           if ((input_section->flags & SEC_ALLOC) == 0)
14317             break;
14318
14319           if (NO_OPD_RELOCS && is_opd)
14320             break;
14321
14322           if ((info->shared
14323                && (h == NULL
14324                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14325                    || h->elf.root.type != bfd_link_hash_undefweak)
14326                && (must_be_dyn_reloc (info, r_type)
14327                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14328               || (ELIMINATE_COPY_RELOCS
14329                   && !info->shared
14330                   && h != NULL
14331                   && h->elf.dynindx != -1
14332                   && !h->elf.non_got_ref
14333                   && !h->elf.def_regular)
14334               || (!info->shared
14335                   && (h != NULL
14336                       ? h->elf.type == STT_GNU_IFUNC
14337                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14338             {
14339               bfd_boolean skip, relocate;
14340               asection *sreloc;
14341               bfd_vma out_off;
14342
14343               /* When generating a dynamic object, these relocations
14344                  are copied into the output file to be resolved at run
14345                  time.  */
14346
14347               skip = FALSE;
14348               relocate = FALSE;
14349
14350               out_off = _bfd_elf_section_offset (output_bfd, info,
14351                                                  input_section, rel->r_offset);
14352               if (out_off == (bfd_vma) -1)
14353                 skip = TRUE;
14354               else if (out_off == (bfd_vma) -2)
14355                 skip = TRUE, relocate = TRUE;
14356               out_off += (input_section->output_section->vma
14357                           + input_section->output_offset);
14358               outrel.r_offset = out_off;
14359               outrel.r_addend = rel->r_addend;
14360
14361               /* Optimize unaligned reloc use.  */
14362               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14363                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14364                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14365               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14366                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14367                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14368               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14369                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14370                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14371
14372               if (skip)
14373                 memset (&outrel, 0, sizeof outrel);
14374               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14375                        && !is_opd
14376                        && r_type != R_PPC64_TOC)
14377                 {
14378                   BFD_ASSERT (h->elf.dynindx != -1);
14379                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14380                 }
14381               else
14382                 {
14383                   /* This symbol is local, or marked to become local,
14384                      or this is an opd section reloc which must point
14385                      at a local function.  */
14386                   outrel.r_addend += relocation;
14387                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14388                     {
14389                       if (is_opd && h != NULL)
14390                         {
14391                           /* Lie about opd entries.  This case occurs
14392                              when building shared libraries and we
14393                              reference a function in another shared
14394                              lib.  The same thing happens for a weak
14395                              definition in an application that's
14396                              overridden by a strong definition in a
14397                              shared lib.  (I believe this is a generic
14398                              bug in binutils handling of weak syms.)
14399                              In these cases we won't use the opd
14400                              entry in this lib.  */
14401                           unresolved_reloc = FALSE;
14402                         }
14403                       if (!is_opd
14404                           && r_type == R_PPC64_ADDR64
14405                           && (h != NULL
14406                               ? h->elf.type == STT_GNU_IFUNC
14407                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14408                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14409                       else
14410                         {
14411                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14412
14413                           /* We need to relocate .opd contents for ld.so.
14414                              Prelink also wants simple and consistent rules
14415                              for relocs.  This make all RELATIVE relocs have
14416                              *r_offset equal to r_addend.  */
14417                           relocate = TRUE;
14418                         }
14419                     }
14420                   else
14421                     {
14422                       long indx = 0;
14423
14424                       if (h != NULL
14425                           ? h->elf.type == STT_GNU_IFUNC
14426                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14427                         {
14428                           info->callbacks->einfo
14429                             (_("%P: %H: %s for indirect "
14430                                "function `%T' unsupported\n"),
14431                              input_bfd, input_section, rel->r_offset,
14432                              ppc64_elf_howto_table[r_type]->name,
14433                              sym_name);
14434                           ret = FALSE;
14435                         }
14436                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14437                         ;
14438                       else if (sec == NULL || sec->owner == NULL)
14439                         {
14440                           bfd_set_error (bfd_error_bad_value);
14441                           return FALSE;
14442                         }
14443                       else
14444                         {
14445                           asection *osec;
14446
14447                           osec = sec->output_section;
14448                           indx = elf_section_data (osec)->dynindx;
14449
14450                           if (indx == 0)
14451                             {
14452                               if ((osec->flags & SEC_READONLY) == 0
14453                                   && htab->elf.data_index_section != NULL)
14454                                 osec = htab->elf.data_index_section;
14455                               else
14456                                 osec = htab->elf.text_index_section;
14457                               indx = elf_section_data (osec)->dynindx;
14458                             }
14459                           BFD_ASSERT (indx != 0);
14460
14461                           /* We are turning this relocation into one
14462                              against a section symbol, so subtract out
14463                              the output section's address but not the
14464                              offset of the input section in the output
14465                              section.  */
14466                           outrel.r_addend -= osec->vma;
14467                         }
14468
14469                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14470                     }
14471                 }
14472
14473               sreloc = elf_section_data (input_section)->sreloc;
14474               if (h != NULL
14475                   ? h->elf.type == STT_GNU_IFUNC
14476                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14477                 sreloc = htab->elf.irelplt;
14478               if (sreloc == NULL)
14479                 abort ();
14480
14481               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14482                   >= sreloc->size)
14483                 abort ();
14484               loc = sreloc->contents;
14485               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14486               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14487
14488               /* If this reloc is against an external symbol, it will
14489                  be computed at runtime, so there's no need to do
14490                  anything now.  However, for the sake of prelink ensure
14491                  that the section contents are a known value.  */
14492               if (! relocate)
14493                 {
14494                   unresolved_reloc = FALSE;
14495                   /* The value chosen here is quite arbitrary as ld.so
14496                      ignores section contents except for the special
14497                      case of .opd where the contents might be accessed
14498                      before relocation.  Choose zero, as that won't
14499                      cause reloc overflow.  */
14500                   relocation = 0;
14501                   addend = 0;
14502                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14503                      to improve backward compatibility with older
14504                      versions of ld.  */
14505                   if (r_type == R_PPC64_ADDR64)
14506                     addend = outrel.r_addend;
14507                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14508                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14509                     addend = (input_section->output_section->vma
14510                               + input_section->output_offset
14511                               + rel->r_offset);
14512                 }
14513             }
14514           break;
14515
14516         case R_PPC64_COPY:
14517         case R_PPC64_GLOB_DAT:
14518         case R_PPC64_JMP_SLOT:
14519         case R_PPC64_JMP_IREL:
14520         case R_PPC64_RELATIVE:
14521           /* We shouldn't ever see these dynamic relocs in relocatable
14522              files.  */
14523           /* Fall through.  */
14524
14525         case R_PPC64_PLTGOT16:
14526         case R_PPC64_PLTGOT16_DS:
14527         case R_PPC64_PLTGOT16_HA:
14528         case R_PPC64_PLTGOT16_HI:
14529         case R_PPC64_PLTGOT16_LO:
14530         case R_PPC64_PLTGOT16_LO_DS:
14531         case R_PPC64_PLTREL32:
14532         case R_PPC64_PLTREL64:
14533           /* These ones haven't been implemented yet.  */
14534
14535           info->callbacks->einfo
14536             (_("%P: %B: %s is not supported for `%T'\n"),
14537              input_bfd,
14538              ppc64_elf_howto_table[r_type]->name, sym_name);
14539
14540           bfd_set_error (bfd_error_invalid_operation);
14541           ret = FALSE;
14542           continue;
14543         }
14544
14545       /* Multi-instruction sequences that access the TOC can be
14546          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14547          to             nop;           addi rb,r2,x;  */
14548       switch (r_type)
14549         {
14550         default:
14551           break;
14552
14553         case R_PPC64_GOT_TLSLD16_HI:
14554         case R_PPC64_GOT_TLSGD16_HI:
14555         case R_PPC64_GOT_TPREL16_HI:
14556         case R_PPC64_GOT_DTPREL16_HI:
14557         case R_PPC64_GOT16_HI:
14558         case R_PPC64_TOC16_HI:
14559           /* These relocs would only be useful if building up an
14560              offset to later add to r2, perhaps in an indexed
14561              addressing mode instruction.  Don't try to optimize.
14562              Unfortunately, the possibility of someone building up an
14563              offset like this or even with the HA relocs, means that
14564              we need to check the high insn when optimizing the low
14565              insn.  */
14566           break;
14567
14568         case R_PPC64_GOT_TLSLD16_HA:
14569         case R_PPC64_GOT_TLSGD16_HA:
14570         case R_PPC64_GOT_TPREL16_HA:
14571         case R_PPC64_GOT_DTPREL16_HA:
14572         case R_PPC64_GOT16_HA:
14573         case R_PPC64_TOC16_HA:
14574           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14575               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14576             {
14577               bfd_byte *p = contents + (rel->r_offset & ~3);
14578               bfd_put_32 (input_bfd, NOP, p);
14579             }
14580           break;
14581
14582         case R_PPC64_GOT_TLSLD16_LO:
14583         case R_PPC64_GOT_TLSGD16_LO:
14584         case R_PPC64_GOT_TPREL16_LO_DS:
14585         case R_PPC64_GOT_DTPREL16_LO_DS:
14586         case R_PPC64_GOT16_LO:
14587         case R_PPC64_GOT16_LO_DS:
14588         case R_PPC64_TOC16_LO:
14589         case R_PPC64_TOC16_LO_DS:
14590           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14591               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14592             {
14593               bfd_byte *p = contents + (rel->r_offset & ~3);
14594               insn = bfd_get_32 (input_bfd, p);
14595               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14596                 {
14597                   /* Transform addic to addi when we change reg.  */
14598                   insn &= ~((0x3f << 26) | (0x1f << 16));
14599                   insn |= (14u << 26) | (2 << 16);
14600                 }
14601               else
14602                 {
14603                   insn &= ~(0x1f << 16);
14604                   insn |= 2 << 16;
14605                 }
14606               bfd_put_32 (input_bfd, insn, p);
14607             }
14608           break;
14609         }
14610
14611       /* Do any further special processing.  */
14612       howto = ppc64_elf_howto_table[(int) r_type];
14613       switch (r_type)
14614         {
14615         default:
14616           break;
14617
14618         case R_PPC64_REL16_HA:
14619         case R_PPC64_ADDR16_HA:
14620         case R_PPC64_ADDR16_HIGHA:
14621         case R_PPC64_ADDR16_HIGHERA:
14622         case R_PPC64_ADDR16_HIGHESTA:
14623         case R_PPC64_TOC16_HA:
14624         case R_PPC64_SECTOFF_HA:
14625         case R_PPC64_TPREL16_HA:
14626         case R_PPC64_TPREL16_HIGHA:
14627         case R_PPC64_TPREL16_HIGHERA:
14628         case R_PPC64_TPREL16_HIGHESTA:
14629         case R_PPC64_DTPREL16_HA:
14630         case R_PPC64_DTPREL16_HIGHA:
14631         case R_PPC64_DTPREL16_HIGHERA:
14632         case R_PPC64_DTPREL16_HIGHESTA:
14633           /* It's just possible that this symbol is a weak symbol
14634              that's not actually defined anywhere. In that case,
14635              'sec' would be NULL, and we should leave the symbol
14636              alone (it will be set to zero elsewhere in the link).  */
14637           if (sec == NULL)
14638             break;
14639           /* Fall thru */
14640
14641         case R_PPC64_GOT16_HA:
14642         case R_PPC64_PLTGOT16_HA:
14643         case R_PPC64_PLT16_HA:
14644         case R_PPC64_GOT_TLSGD16_HA:
14645         case R_PPC64_GOT_TLSLD16_HA:
14646         case R_PPC64_GOT_TPREL16_HA:
14647         case R_PPC64_GOT_DTPREL16_HA:
14648           /* Add 0x10000 if sign bit in 0:15 is set.
14649              Bits 0:15 are not used.  */
14650           addend += 0x8000;
14651           break;
14652
14653         case R_PPC64_ADDR16_DS:
14654         case R_PPC64_ADDR16_LO_DS:
14655         case R_PPC64_GOT16_DS:
14656         case R_PPC64_GOT16_LO_DS:
14657         case R_PPC64_PLT16_LO_DS:
14658         case R_PPC64_SECTOFF_DS:
14659         case R_PPC64_SECTOFF_LO_DS:
14660         case R_PPC64_TOC16_DS:
14661         case R_PPC64_TOC16_LO_DS:
14662         case R_PPC64_PLTGOT16_DS:
14663         case R_PPC64_PLTGOT16_LO_DS:
14664         case R_PPC64_GOT_TPREL16_DS:
14665         case R_PPC64_GOT_TPREL16_LO_DS:
14666         case R_PPC64_GOT_DTPREL16_DS:
14667         case R_PPC64_GOT_DTPREL16_LO_DS:
14668         case R_PPC64_TPREL16_DS:
14669         case R_PPC64_TPREL16_LO_DS:
14670         case R_PPC64_DTPREL16_DS:
14671         case R_PPC64_DTPREL16_LO_DS:
14672           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14673           mask = 3;
14674           /* If this reloc is against an lq insn, then the value must be
14675              a multiple of 16.  This is somewhat of a hack, but the
14676              "correct" way to do this by defining _DQ forms of all the
14677              _DS relocs bloats all reloc switches in this file.  It
14678              doesn't seem to make much sense to use any of these relocs
14679              in data, so testing the insn should be safe.  */
14680           if ((insn & (0x3f << 26)) == (56u << 26))
14681             mask = 15;
14682           if (((relocation + addend) & mask) != 0)
14683             {
14684               info->callbacks->einfo
14685                 (_("%P: %H: error: %s not a multiple of %u\n"),
14686                  input_bfd, input_section, rel->r_offset,
14687                  howto->name,
14688                  mask + 1);
14689               bfd_set_error (bfd_error_bad_value);
14690               ret = FALSE;
14691               continue;
14692             }
14693           break;
14694         }
14695
14696       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14697          because such sections are not SEC_ALLOC and thus ld.so will
14698          not process them.  */
14699       if (unresolved_reloc
14700           && !((input_section->flags & SEC_DEBUGGING) != 0
14701                && h->elf.def_dynamic)
14702           && _bfd_elf_section_offset (output_bfd, info, input_section,
14703                                       rel->r_offset) != (bfd_vma) -1)
14704         {
14705           info->callbacks->einfo
14706             (_("%P: %H: unresolvable %s against `%T'\n"),
14707              input_bfd, input_section, rel->r_offset,
14708              howto->name,
14709              h->elf.root.root.string);
14710           ret = FALSE;
14711         }
14712
14713       /* 16-bit fields in insns mostly have signed values, but a
14714          few insns have 16-bit unsigned values.  Really, we should
14715          have different reloc types.  */
14716       if (howto->complain_on_overflow != complain_overflow_dont
14717           && howto->dst_mask == 0xffff
14718           && (input_section->flags & SEC_CODE) != 0)
14719         {
14720           enum complain_overflow complain = complain_overflow_signed;
14721
14722           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14723           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14724             complain = complain_overflow_bitfield;
14725           else if (howto->rightshift == 0
14726                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14727                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14728                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14729                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14730                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14731                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14732             complain = complain_overflow_unsigned;
14733           if (howto->complain_on_overflow != complain)
14734             {
14735               alt_howto = *howto;
14736               alt_howto.complain_on_overflow = complain;
14737               howto = &alt_howto;
14738             }
14739         }
14740
14741       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14742                                     rel->r_offset, relocation, addend);
14743
14744       if (r != bfd_reloc_ok)
14745         {
14746           char *more_info = NULL;
14747           const char *reloc_name = howto->name;
14748
14749           if (reloc_dest != DEST_NORMAL)
14750             {
14751               more_info = bfd_malloc (strlen (reloc_name) + 8);
14752               if (more_info != NULL)
14753                 {
14754                   strcpy (more_info, reloc_name);
14755                   strcat (more_info, (reloc_dest == DEST_OPD
14756                                       ? " (OPD)" : " (stub)"));
14757                   reloc_name = more_info;
14758                 }
14759             }
14760
14761           if (r == bfd_reloc_overflow)
14762             {
14763               if (warned)
14764                 continue;
14765               if (h != NULL
14766                   && h->elf.root.type == bfd_link_hash_undefweak
14767                   && howto->pc_relative)
14768                 {
14769                   /* Assume this is a call protected by other code that
14770                      detects the symbol is undefined.  If this is the case,
14771                      we can safely ignore the overflow.  If not, the
14772                      program is hosed anyway, and a little warning isn't
14773                      going to help.  */
14774
14775                   continue;
14776                 }
14777
14778               if (!((*info->callbacks->reloc_overflow)
14779                     (info, &h->elf.root, sym_name,
14780                      reloc_name, orig_rel.r_addend,
14781                      input_bfd, input_section, rel->r_offset)))
14782                 return FALSE;
14783             }
14784           else
14785             {
14786               info->callbacks->einfo
14787                 (_("%P: %H: %s against `%T': error %d\n"),
14788                  input_bfd, input_section, rel->r_offset,
14789                  reloc_name, sym_name, (int) r);
14790               ret = FALSE;
14791             }
14792           if (more_info != NULL)
14793             free (more_info);
14794         }
14795     }
14796
14797   /* If we're emitting relocations, then shortly after this function
14798      returns, reloc offsets and addends for this section will be
14799      adjusted.  Worse, reloc symbol indices will be for the output
14800      file rather than the input.  Save a copy of the relocs for
14801      opd_entry_value.  */
14802   if (is_opd && (info->emitrelocations || info->relocatable))
14803     {
14804       bfd_size_type amt;
14805       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14806       rel = bfd_alloc (input_bfd, amt);
14807       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14808       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14809       if (rel == NULL)
14810         return FALSE;
14811       memcpy (rel, relocs, amt);
14812     }
14813   return ret;
14814 }
14815
14816 /* Adjust the value of any local symbols in opd sections.  */
14817
14818 static int
14819 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14820                               const char *name ATTRIBUTE_UNUSED,
14821                               Elf_Internal_Sym *elfsym,
14822                               asection *input_sec,
14823                               struct elf_link_hash_entry *h)
14824 {
14825   struct _opd_sec_data *opd;
14826   long adjust;
14827   bfd_vma value;
14828
14829   if (h != NULL)
14830     return 1;
14831
14832   opd = get_opd_info (input_sec);
14833   if (opd == NULL || opd->adjust == NULL)
14834     return 1;
14835
14836   value = elfsym->st_value - input_sec->output_offset;
14837   if (!info->relocatable)
14838     value -= input_sec->output_section->vma;
14839
14840   adjust = opd->adjust[value / 8];
14841   if (adjust == -1)
14842     return 2;
14843
14844   elfsym->st_value += adjust;
14845   return 1;
14846 }
14847
14848 /* Finish up dynamic symbol handling.  We set the contents of various
14849    dynamic sections here.  */
14850
14851 static bfd_boolean
14852 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14853                                  struct bfd_link_info *info,
14854                                  struct elf_link_hash_entry *h,
14855                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14856 {
14857   struct ppc_link_hash_table *htab;
14858   struct plt_entry *ent;
14859   Elf_Internal_Rela rela;
14860   bfd_byte *loc;
14861
14862   htab = ppc_hash_table (info);
14863   if (htab == NULL)
14864     return FALSE;
14865
14866   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14867     if (ent->plt.offset != (bfd_vma) -1)
14868       {
14869         /* This symbol has an entry in the procedure linkage
14870            table.  Set it up.  */
14871         if (!htab->elf.dynamic_sections_created
14872             || h->dynindx == -1)
14873           {
14874             BFD_ASSERT (h->type == STT_GNU_IFUNC
14875                         && h->def_regular
14876                         && (h->root.type == bfd_link_hash_defined
14877                             || h->root.type == bfd_link_hash_defweak));
14878             rela.r_offset = (htab->elf.iplt->output_section->vma
14879                              + htab->elf.iplt->output_offset
14880                              + ent->plt.offset);
14881             if (htab->opd_abi)
14882               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14883             else
14884               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14885             rela.r_addend = (h->root.u.def.value
14886                              + h->root.u.def.section->output_offset
14887                              + h->root.u.def.section->output_section->vma
14888                              + ent->addend);
14889             loc = (htab->elf.irelplt->contents
14890                    + (htab->elf.irelplt->reloc_count++
14891                       * sizeof (Elf64_External_Rela)));
14892           }
14893         else
14894           {
14895             rela.r_offset = (htab->elf.splt->output_section->vma
14896                              + htab->elf.splt->output_offset
14897                              + ent->plt.offset);
14898             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14899             rela.r_addend = ent->addend;
14900             loc = (htab->elf.srelplt->contents
14901                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14902                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14903           }
14904         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14905
14906         if (!htab->opd_abi)
14907           {
14908             if (!h->def_regular)
14909               {
14910                 /* Mark the symbol as undefined, rather than as
14911                    defined in glink.  Leave the value if there were
14912                    any relocations where pointer equality matters
14913                    (this is a clue for the dynamic linker, to make
14914                    function pointer comparisons work between an
14915                    application and shared library), otherwise set it
14916                    to zero.  */
14917                 sym->st_shndx = SHN_UNDEF;
14918                 if (!h->pointer_equality_needed)
14919                   sym->st_value = 0;
14920                 else if (!h->ref_regular_nonweak)
14921                   {
14922                     /* This breaks function pointer comparisons, but
14923                        that is better than breaking tests for a NULL
14924                        function pointer.  */
14925                     sym->st_value = 0;
14926                   }
14927               }
14928           }
14929       }
14930
14931   if (h->needs_copy)
14932     {
14933       /* This symbol needs a copy reloc.  Set it up.  */
14934
14935       if (h->dynindx == -1
14936           || (h->root.type != bfd_link_hash_defined
14937               && h->root.type != bfd_link_hash_defweak)
14938           || htab->relbss == NULL)
14939         abort ();
14940
14941       rela.r_offset = (h->root.u.def.value
14942                        + h->root.u.def.section->output_section->vma
14943                        + h->root.u.def.section->output_offset);
14944       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14945       rela.r_addend = 0;
14946       loc = htab->relbss->contents;
14947       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14948       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14949     }
14950
14951   return TRUE;
14952 }
14953
14954 /* Used to decide how to sort relocs in an optimal manner for the
14955    dynamic linker, before writing them out.  */
14956
14957 static enum elf_reloc_type_class
14958 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14959                             const asection *rel_sec,
14960                             const Elf_Internal_Rela *rela)
14961 {
14962   enum elf_ppc64_reloc_type r_type;
14963   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14964
14965   if (rel_sec == htab->elf.irelplt)
14966     return reloc_class_ifunc;
14967
14968   r_type = ELF64_R_TYPE (rela->r_info);
14969   switch (r_type)
14970     {
14971     case R_PPC64_RELATIVE:
14972       return reloc_class_relative;
14973     case R_PPC64_JMP_SLOT:
14974       return reloc_class_plt;
14975     case R_PPC64_COPY:
14976       return reloc_class_copy;
14977     default:
14978       return reloc_class_normal;
14979     }
14980 }
14981
14982 /* Finish up the dynamic sections.  */
14983
14984 static bfd_boolean
14985 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14986                                    struct bfd_link_info *info)
14987 {
14988   struct ppc_link_hash_table *htab;
14989   bfd *dynobj;
14990   asection *sdyn;
14991
14992   htab = ppc_hash_table (info);
14993   if (htab == NULL)
14994     return FALSE;
14995
14996   dynobj = htab->elf.dynobj;
14997   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14998
14999   if (htab->elf.dynamic_sections_created)
15000     {
15001       Elf64_External_Dyn *dyncon, *dynconend;
15002
15003       if (sdyn == NULL || htab->elf.sgot == NULL)
15004         abort ();
15005
15006       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15007       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15008       for (; dyncon < dynconend; dyncon++)
15009         {
15010           Elf_Internal_Dyn dyn;
15011           asection *s;
15012
15013           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15014
15015           switch (dyn.d_tag)
15016             {
15017             default:
15018               continue;
15019
15020             case DT_PPC64_GLINK:
15021               s = htab->glink;
15022               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15023               /* We stupidly defined DT_PPC64_GLINK to be the start
15024                  of glink rather than the first entry point, which is
15025                  what ld.so needs, and now have a bigger stub to
15026                  support automatic multiple TOCs.  */
15027               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15028               break;
15029
15030             case DT_PPC64_OPD:
15031               s = bfd_get_section_by_name (output_bfd, ".opd");
15032               if (s == NULL)
15033                 continue;
15034               dyn.d_un.d_ptr = s->vma;
15035               break;
15036
15037             case DT_PPC64_OPT:
15038               if (htab->do_multi_toc && htab->multi_toc_needed)
15039                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15040               break;
15041
15042             case DT_PPC64_OPDSZ:
15043               s = bfd_get_section_by_name (output_bfd, ".opd");
15044               if (s == NULL)
15045                 continue;
15046               dyn.d_un.d_val = s->size;
15047               break;
15048
15049             case DT_PLTGOT:
15050               s = htab->elf.splt;
15051               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15052               break;
15053
15054             case DT_JMPREL:
15055               s = htab->elf.srelplt;
15056               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15057               break;
15058
15059             case DT_PLTRELSZ:
15060               dyn.d_un.d_val = htab->elf.srelplt->size;
15061               break;
15062
15063             case DT_RELASZ:
15064               /* Don't count procedure linkage table relocs in the
15065                  overall reloc count.  */
15066               s = htab->elf.srelplt;
15067               if (s == NULL)
15068                 continue;
15069               dyn.d_un.d_val -= s->size;
15070               break;
15071
15072             case DT_RELA:
15073               /* We may not be using the standard ELF linker script.
15074                  If .rela.plt is the first .rela section, we adjust
15075                  DT_RELA to not include it.  */
15076               s = htab->elf.srelplt;
15077               if (s == NULL)
15078                 continue;
15079               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15080                 continue;
15081               dyn.d_un.d_ptr += s->size;
15082               break;
15083             }
15084
15085           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15086         }
15087     }
15088
15089   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15090     {
15091       /* Fill in the first entry in the global offset table.
15092          We use it to hold the link-time TOCbase.  */
15093       bfd_put_64 (output_bfd,
15094                   elf_gp (output_bfd) + TOC_BASE_OFF,
15095                   htab->elf.sgot->contents);
15096
15097       /* Set .got entry size.  */
15098       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15099     }
15100
15101   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15102     {
15103       /* Set .plt entry size.  */
15104       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15105         = PLT_ENTRY_SIZE (htab);
15106     }
15107
15108   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15109      brlt ourselves if emitrelocations.  */
15110   if (htab->brlt != NULL
15111       && htab->brlt->reloc_count != 0
15112       && !_bfd_elf_link_output_relocs (output_bfd,
15113                                        htab->brlt,
15114                                        elf_section_data (htab->brlt)->rela.hdr,
15115                                        elf_section_data (htab->brlt)->relocs,
15116                                        NULL))
15117     return FALSE;
15118
15119   if (htab->glink != NULL
15120       && htab->glink->reloc_count != 0
15121       && !_bfd_elf_link_output_relocs (output_bfd,
15122                                        htab->glink,
15123                                        elf_section_data (htab->glink)->rela.hdr,
15124                                        elf_section_data (htab->glink)->relocs,
15125                                        NULL))
15126     return FALSE;
15127
15128
15129   if (htab->glink_eh_frame != NULL
15130       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15131       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15132                                            htab->glink_eh_frame,
15133                                            htab->glink_eh_frame->contents))
15134     return FALSE;
15135
15136   /* We need to handle writing out multiple GOT sections ourselves,
15137      since we didn't add them to DYNOBJ.  We know dynobj is the first
15138      bfd.  */
15139   while ((dynobj = dynobj->link.next) != NULL)
15140     {
15141       asection *s;
15142
15143       if (!is_ppc64_elf (dynobj))
15144         continue;
15145
15146       s = ppc64_elf_tdata (dynobj)->got;
15147       if (s != NULL
15148           && s->size != 0
15149           && s->output_section != bfd_abs_section_ptr
15150           && !bfd_set_section_contents (output_bfd, s->output_section,
15151                                         s->contents, s->output_offset,
15152                                         s->size))
15153         return FALSE;
15154       s = ppc64_elf_tdata (dynobj)->relgot;
15155       if (s != NULL
15156           && s->size != 0
15157           && s->output_section != bfd_abs_section_ptr
15158           && !bfd_set_section_contents (output_bfd, s->output_section,
15159                                         s->contents, s->output_offset,
15160                                         s->size))
15161         return FALSE;
15162     }
15163
15164   return TRUE;
15165 }
15166
15167 #include "elf64-target.h"
15168
15169 /* FreeBSD support */
15170
15171 #undef  TARGET_LITTLE_SYM
15172 #undef  TARGET_LITTLE_NAME
15173
15174 #undef  TARGET_BIG_SYM
15175 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15176 #undef  TARGET_BIG_NAME
15177 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15178
15179 #undef  ELF_OSABI
15180 #define ELF_OSABI       ELFOSABI_FREEBSD
15181
15182 #undef  elf64_bed
15183 #define elf64_bed       elf64_powerpc_fbsd_bed
15184
15185 #include "elf64-target.h"
15186