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 };
3790
3791 struct ppc_stub_hash_entry {
3792
3793   /* Base hash table entry structure.  */
3794   struct bfd_hash_entry root;
3795
3796   enum ppc_stub_type stub_type;
3797
3798   /* The stub section.  */
3799   asection *stub_sec;
3800
3801   /* Offset within stub_sec of the beginning of this stub.  */
3802   bfd_vma stub_offset;
3803
3804   /* Given the symbol's value and its section we can determine its final
3805      value when building the stubs (so the stub knows where to jump.  */
3806   bfd_vma target_value;
3807   asection *target_section;
3808
3809   /* The symbol table entry, if any, that this was derived from.  */
3810   struct ppc_link_hash_entry *h;
3811   struct plt_entry *plt_ent;
3812
3813   /* Where this stub is being called from, or, in the case of combined
3814      stub sections, the first input section in the group.  */
3815   asection *id_sec;
3816
3817   /* Symbol st_other.  */
3818   unsigned char other;
3819 };
3820
3821 struct ppc_branch_hash_entry {
3822
3823   /* Base hash table entry structure.  */
3824   struct bfd_hash_entry root;
3825
3826   /* Offset within branch lookup table.  */
3827   unsigned int offset;
3828
3829   /* Generation marker.  */
3830   unsigned int iter;
3831 };
3832
3833 /* Used to track dynamic relocations for local symbols.  */
3834 struct ppc_dyn_relocs
3835 {
3836   struct ppc_dyn_relocs *next;
3837
3838   /* The input section of the reloc.  */
3839   asection *sec;
3840
3841   /* Total number of relocs copied for the input section.  */
3842   unsigned int count : 31;
3843
3844   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3845   unsigned int ifunc : 1;
3846 };
3847
3848 struct ppc_link_hash_entry
3849 {
3850   struct elf_link_hash_entry elf;
3851
3852   union {
3853     /* A pointer to the most recently used stub hash entry against this
3854        symbol.  */
3855     struct ppc_stub_hash_entry *stub_cache;
3856
3857     /* A pointer to the next symbol starting with a '.'  */
3858     struct ppc_link_hash_entry *next_dot_sym;
3859   } u;
3860
3861   /* Track dynamic relocs copied for this symbol.  */
3862   struct elf_dyn_relocs *dyn_relocs;
3863
3864   /* Link between function code and descriptor symbols.  */
3865   struct ppc_link_hash_entry *oh;
3866
3867   /* Flag function code and descriptor symbols.  */
3868   unsigned int is_func:1;
3869   unsigned int is_func_descriptor:1;
3870   unsigned int fake:1;
3871
3872   /* Whether global opd/toc sym has been adjusted or not.
3873      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3874      should be set for all globals defined in any opd/toc section.  */
3875   unsigned int adjust_done:1;
3876
3877   /* Set if we twiddled this symbol to weak at some stage.  */
3878   unsigned int was_undefined:1;
3879
3880   /* Contexts in which symbol is used in the GOT (or TOC).
3881      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3882      corresponding relocs are encountered during check_relocs.
3883      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3884      indicate the corresponding GOT entry type is not needed.
3885      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3886      a TPREL one.  We use a separate flag rather than setting TPREL
3887      just for convenience in distinguishing the two cases.  */
3888 #define TLS_GD           1      /* GD reloc. */
3889 #define TLS_LD           2      /* LD reloc. */
3890 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3891 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3892 #define TLS_TLS         16      /* Any TLS reloc.  */
3893 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3894 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3895 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3896   unsigned char tls_mask;
3897 };
3898
3899 /* ppc64 ELF linker hash table.  */
3900
3901 struct ppc_link_hash_table
3902 {
3903   struct elf_link_hash_table elf;
3904
3905   /* The stub hash table.  */
3906   struct bfd_hash_table stub_hash_table;
3907
3908   /* Another hash table for plt_branch stubs.  */
3909   struct bfd_hash_table branch_hash_table;
3910
3911   /* Hash table for function prologue tocsave.  */
3912   htab_t tocsave_htab;
3913
3914   /* Various options and other info passed from the linker.  */
3915   struct ppc64_elf_params *params;
3916
3917   /* Array to keep track of which stub sections have been created, and
3918      information on stub grouping.  */
3919   struct map_stub {
3920     /* This is the section to which stubs in the group will be attached.  */
3921     asection *link_sec;
3922     /* The stub section.  */
3923     asection *stub_sec;
3924     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3925     bfd_vma toc_off;
3926   } *stub_group;
3927
3928   /* Temp used when calculating TOC pointers.  */
3929   bfd_vma toc_curr;
3930   bfd *toc_bfd;
3931   asection *toc_first_sec;
3932
3933   /* Highest input section id.  */
3934   int top_id;
3935
3936   /* Highest output section index.  */
3937   int top_index;
3938
3939   /* Used when adding symbols.  */
3940   struct ppc_link_hash_entry *dot_syms;
3941
3942   /* List of input sections for each output section.  */
3943   asection **input_list;
3944
3945   /* Shortcuts to get to dynamic linker sections.  */
3946   asection *dynbss;
3947   asection *relbss;
3948   asection *glink;
3949   asection *sfpr;
3950   asection *brlt;
3951   asection *relbrlt;
3952   asection *glink_eh_frame;
3953
3954   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3955   struct ppc_link_hash_entry *tls_get_addr;
3956   struct ppc_link_hash_entry *tls_get_addr_fd;
3957
3958   /* The size of reliplt used by got entry relocs.  */
3959   bfd_size_type got_reli_size;
3960
3961   /* Statistics.  */
3962   unsigned long stub_count[ppc_stub_plt_call_r2save];
3963
3964   /* Number of stubs against global syms.  */
3965   unsigned long stub_globals;
3966
3967   /* Set if we're linking code with function descriptors.  */
3968   unsigned int opd_abi:1;
3969
3970   /* Support for multiple toc sections.  */
3971   unsigned int do_multi_toc:1;
3972   unsigned int multi_toc_needed:1;
3973   unsigned int second_toc_pass:1;
3974   unsigned int do_toc_opt:1;
3975
3976   /* Set on error.  */
3977   unsigned int stub_error:1;
3978
3979   /* Temp used by ppc64_elf_before_check_relocs.  */
3980   unsigned int twiddled_syms:1;
3981
3982   /* Incremented every time we size stubs.  */
3983   unsigned int stub_iteration;
3984
3985   /* Small local sym cache.  */
3986   struct sym_cache sym_cache;
3987 };
3988
3989 /* Rename some of the generic section flags to better document how they
3990    are used here.  */
3991
3992 /* Nonzero if this section has TLS related relocations.  */
3993 #define has_tls_reloc sec_flg0
3994
3995 /* Nonzero if this section has a call to __tls_get_addr.  */
3996 #define has_tls_get_addr_call sec_flg1
3997
3998 /* Nonzero if this section has any toc or got relocs.  */
3999 #define has_toc_reloc sec_flg2
4000
4001 /* Nonzero if this section has a call to another section that uses
4002    the toc or got.  */
4003 #define makes_toc_func_call sec_flg3
4004
4005 /* Recursion protection when determining above flag.  */
4006 #define call_check_in_progress sec_flg4
4007 #define call_check_done sec_flg5
4008
4009 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4010
4011 #define ppc_hash_table(p) \
4012   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4013   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4014
4015 #define ppc_stub_hash_lookup(table, string, create, copy) \
4016   ((struct ppc_stub_hash_entry *) \
4017    bfd_hash_lookup ((table), (string), (create), (copy)))
4018
4019 #define ppc_branch_hash_lookup(table, string, create, copy) \
4020   ((struct ppc_branch_hash_entry *) \
4021    bfd_hash_lookup ((table), (string), (create), (copy)))
4022
4023 /* Create an entry in the stub hash table.  */
4024
4025 static struct bfd_hash_entry *
4026 stub_hash_newfunc (struct bfd_hash_entry *entry,
4027                    struct bfd_hash_table *table,
4028                    const char *string)
4029 {
4030   /* Allocate the structure if it has not already been allocated by a
4031      subclass.  */
4032   if (entry == NULL)
4033     {
4034       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4035       if (entry == NULL)
4036         return entry;
4037     }
4038
4039   /* Call the allocation method of the superclass.  */
4040   entry = bfd_hash_newfunc (entry, table, string);
4041   if (entry != NULL)
4042     {
4043       struct ppc_stub_hash_entry *eh;
4044
4045       /* Initialize the local fields.  */
4046       eh = (struct ppc_stub_hash_entry *) entry;
4047       eh->stub_type = ppc_stub_none;
4048       eh->stub_sec = NULL;
4049       eh->stub_offset = 0;
4050       eh->target_value = 0;
4051       eh->target_section = NULL;
4052       eh->h = NULL;
4053       eh->plt_ent = NULL;
4054       eh->id_sec = NULL;
4055       eh->other = 0;
4056     }
4057
4058   return entry;
4059 }
4060
4061 /* Create an entry in the branch hash table.  */
4062
4063 static struct bfd_hash_entry *
4064 branch_hash_newfunc (struct bfd_hash_entry *entry,
4065                      struct bfd_hash_table *table,
4066                      const char *string)
4067 {
4068   /* Allocate the structure if it has not already been allocated by a
4069      subclass.  */
4070   if (entry == NULL)
4071     {
4072       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4073       if (entry == NULL)
4074         return entry;
4075     }
4076
4077   /* Call the allocation method of the superclass.  */
4078   entry = bfd_hash_newfunc (entry, table, string);
4079   if (entry != NULL)
4080     {
4081       struct ppc_branch_hash_entry *eh;
4082
4083       /* Initialize the local fields.  */
4084       eh = (struct ppc_branch_hash_entry *) entry;
4085       eh->offset = 0;
4086       eh->iter = 0;
4087     }
4088
4089   return entry;
4090 }
4091
4092 /* Create an entry in a ppc64 ELF linker hash table.  */
4093
4094 static struct bfd_hash_entry *
4095 link_hash_newfunc (struct bfd_hash_entry *entry,
4096                    struct bfd_hash_table *table,
4097                    const char *string)
4098 {
4099   /* Allocate the structure if it has not already been allocated by a
4100      subclass.  */
4101   if (entry == NULL)
4102     {
4103       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4104       if (entry == NULL)
4105         return entry;
4106     }
4107
4108   /* Call the allocation method of the superclass.  */
4109   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4110   if (entry != NULL)
4111     {
4112       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4113
4114       memset (&eh->u.stub_cache, 0,
4115               (sizeof (struct ppc_link_hash_entry)
4116                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4117
4118       /* When making function calls, old ABI code references function entry
4119          points (dot symbols), while new ABI code references the function
4120          descriptor symbol.  We need to make any combination of reference and
4121          definition work together, without breaking archive linking.
4122
4123          For a defined function "foo" and an undefined call to "bar":
4124          An old object defines "foo" and ".foo", references ".bar" (possibly
4125          "bar" too).
4126          A new object defines "foo" and references "bar".
4127
4128          A new object thus has no problem with its undefined symbols being
4129          satisfied by definitions in an old object.  On the other hand, the
4130          old object won't have ".bar" satisfied by a new object.
4131
4132          Keep a list of newly added dot-symbols.  */
4133
4134       if (string[0] == '.')
4135         {
4136           struct ppc_link_hash_table *htab;
4137
4138           htab = (struct ppc_link_hash_table *) table;
4139           eh->u.next_dot_sym = htab->dot_syms;
4140           htab->dot_syms = eh;
4141         }
4142     }
4143
4144   return entry;
4145 }
4146
4147 struct tocsave_entry {
4148   asection *sec;
4149   bfd_vma offset;
4150 };
4151
4152 static hashval_t
4153 tocsave_htab_hash (const void *p)
4154 {
4155   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4156   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4157 }
4158
4159 static int
4160 tocsave_htab_eq (const void *p1, const void *p2)
4161 {
4162   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4163   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4164   return e1->sec == e2->sec && e1->offset == e2->offset;
4165 }
4166
4167 /* Destroy a ppc64 ELF linker hash table.  */
4168
4169 static void
4170 ppc64_elf_link_hash_table_free (bfd *obfd)
4171 {
4172   struct ppc_link_hash_table *htab;
4173
4174   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4175   if (htab->tocsave_htab)
4176     htab_delete (htab->tocsave_htab);
4177   bfd_hash_table_free (&htab->branch_hash_table);
4178   bfd_hash_table_free (&htab->stub_hash_table);
4179   _bfd_elf_link_hash_table_free (obfd);
4180 }
4181
4182 /* Create a ppc64 ELF linker hash table.  */
4183
4184 static struct bfd_link_hash_table *
4185 ppc64_elf_link_hash_table_create (bfd *abfd)
4186 {
4187   struct ppc_link_hash_table *htab;
4188   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4189
4190   htab = bfd_zmalloc (amt);
4191   if (htab == NULL)
4192     return NULL;
4193
4194   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4195                                       sizeof (struct ppc_link_hash_entry),
4196                                       PPC64_ELF_DATA))
4197     {
4198       free (htab);
4199       return NULL;
4200     }
4201
4202   /* Init the stub hash table too.  */
4203   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4204                             sizeof (struct ppc_stub_hash_entry)))
4205     {
4206       _bfd_elf_link_hash_table_free (abfd);
4207       return NULL;
4208     }
4209
4210   /* And the branch hash table.  */
4211   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4212                             sizeof (struct ppc_branch_hash_entry)))
4213     {
4214       bfd_hash_table_free (&htab->stub_hash_table);
4215       _bfd_elf_link_hash_table_free (abfd);
4216       return NULL;
4217     }
4218
4219   htab->tocsave_htab = htab_try_create (1024,
4220                                         tocsave_htab_hash,
4221                                         tocsave_htab_eq,
4222                                         NULL);
4223   if (htab->tocsave_htab == NULL)
4224     {
4225       ppc64_elf_link_hash_table_free (abfd);
4226       return NULL;
4227     }
4228   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4229
4230   /* Initializing two fields of the union is just cosmetic.  We really
4231      only care about glist, but when compiled on a 32-bit host the
4232      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4233      debugger inspection of these fields look nicer.  */
4234   htab->elf.init_got_refcount.refcount = 0;
4235   htab->elf.init_got_refcount.glist = NULL;
4236   htab->elf.init_plt_refcount.refcount = 0;
4237   htab->elf.init_plt_refcount.glist = NULL;
4238   htab->elf.init_got_offset.offset = 0;
4239   htab->elf.init_got_offset.glist = NULL;
4240   htab->elf.init_plt_offset.offset = 0;
4241   htab->elf.init_plt_offset.glist = NULL;
4242
4243   return &htab->elf.root;
4244 }
4245
4246 /* Create sections for linker generated code.  */
4247
4248 static bfd_boolean
4249 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4250 {
4251   struct ppc_link_hash_table *htab;
4252   flagword flags;
4253
4254   htab = ppc_hash_table (info);
4255
4256   /* Create .sfpr for code to save and restore fp regs.  */
4257   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4258            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4259   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4260                                                    flags);
4261   if (htab->sfpr == NULL
4262       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4263     return FALSE;
4264
4265   /* Create .glink for lazy dynamic linking support.  */
4266   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4267                                                     flags);
4268   if (htab->glink == NULL
4269       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4270     return FALSE;
4271
4272   if (!info->no_ld_generated_unwind_info)
4273     {
4274       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4275                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4276       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4277                                                                  ".eh_frame",
4278                                                                  flags);
4279       if (htab->glink_eh_frame == NULL
4280           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4281         return FALSE;
4282     }
4283
4284   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4285   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4286   if (htab->elf.iplt == NULL
4287       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4288     return FALSE;
4289
4290   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4291            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4292   htab->elf.irelplt
4293     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4294   if (htab->elf.irelplt == NULL
4295       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4296     return FALSE;
4297
4298   /* Create branch lookup table for plt_branch stubs.  */
4299   flags = (SEC_ALLOC | SEC_LOAD
4300            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4301   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4302                                                    flags);
4303   if (htab->brlt == NULL
4304       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4305     return FALSE;
4306
4307   if (!info->shared)
4308     return TRUE;
4309
4310   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4311            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4312   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4313                                                       ".rela.branch_lt",
4314                                                       flags);
4315   if (htab->relbrlt == NULL
4316       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4317     return FALSE;
4318
4319   return TRUE;
4320 }
4321
4322 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4323
4324 bfd_boolean
4325 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4326                          struct ppc64_elf_params *params)
4327 {
4328   struct ppc_link_hash_table *htab;
4329
4330   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4331
4332 /* Always hook our dynamic sections into the first bfd, which is the
4333    linker created stub bfd.  This ensures that the GOT header is at
4334    the start of the output TOC section.  */
4335   htab = ppc_hash_table (info);
4336   if (htab == NULL)
4337     return FALSE;
4338   htab->elf.dynobj = params->stub_bfd;
4339   htab->params = params;
4340
4341   if (info->relocatable)
4342     return TRUE;
4343
4344   return create_linkage_sections (htab->elf.dynobj, info);
4345 }
4346
4347 /* Build a name for an entry in the stub hash table.  */
4348
4349 static char *
4350 ppc_stub_name (const asection *input_section,
4351                const asection *sym_sec,
4352                const struct ppc_link_hash_entry *h,
4353                const Elf_Internal_Rela *rel)
4354 {
4355   char *stub_name;
4356   ssize_t len;
4357
4358   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4359      offsets from a sym as a branch target?  In fact, we could
4360      probably assume the addend is always zero.  */
4361   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4362
4363   if (h)
4364     {
4365       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4366       stub_name = bfd_malloc (len);
4367       if (stub_name == NULL)
4368         return stub_name;
4369
4370       len = sprintf (stub_name, "%08x.%s+%x",
4371                      input_section->id & 0xffffffff,
4372                      h->elf.root.root.string,
4373                      (int) rel->r_addend & 0xffffffff);
4374     }
4375   else
4376     {
4377       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4378       stub_name = bfd_malloc (len);
4379       if (stub_name == NULL)
4380         return stub_name;
4381
4382       len = sprintf (stub_name, "%08x.%x:%x+%x",
4383                      input_section->id & 0xffffffff,
4384                      sym_sec->id & 0xffffffff,
4385                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4386                      (int) rel->r_addend & 0xffffffff);
4387     }
4388   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4389     stub_name[len - 2] = 0;
4390   return stub_name;
4391 }
4392
4393 /* Look up an entry in the stub hash.  Stub entries are cached because
4394    creating the stub name takes a bit of time.  */
4395
4396 static struct ppc_stub_hash_entry *
4397 ppc_get_stub_entry (const asection *input_section,
4398                     const asection *sym_sec,
4399                     struct ppc_link_hash_entry *h,
4400                     const Elf_Internal_Rela *rel,
4401                     struct ppc_link_hash_table *htab)
4402 {
4403   struct ppc_stub_hash_entry *stub_entry;
4404   const asection *id_sec;
4405
4406   /* If this input section is part of a group of sections sharing one
4407      stub section, then use the id of the first section in the group.
4408      Stub names need to include a section id, as there may well be
4409      more than one stub used to reach say, printf, and we need to
4410      distinguish between them.  */
4411   id_sec = htab->stub_group[input_section->id].link_sec;
4412
4413   if (h != NULL && h->u.stub_cache != NULL
4414       && h->u.stub_cache->h == h
4415       && h->u.stub_cache->id_sec == id_sec)
4416     {
4417       stub_entry = h->u.stub_cache;
4418     }
4419   else
4420     {
4421       char *stub_name;
4422
4423       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4424       if (stub_name == NULL)
4425         return NULL;
4426
4427       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4428                                          stub_name, FALSE, FALSE);
4429       if (h != NULL)
4430         h->u.stub_cache = stub_entry;
4431
4432       free (stub_name);
4433     }
4434
4435   return stub_entry;
4436 }
4437
4438 /* Add a new stub entry to the stub hash.  Not all fields of the new
4439    stub entry are initialised.  */
4440
4441 static struct ppc_stub_hash_entry *
4442 ppc_add_stub (const char *stub_name,
4443               asection *section,
4444               struct bfd_link_info *info)
4445 {
4446   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4447   asection *link_sec;
4448   asection *stub_sec;
4449   struct ppc_stub_hash_entry *stub_entry;
4450
4451   link_sec = htab->stub_group[section->id].link_sec;
4452   stub_sec = htab->stub_group[section->id].stub_sec;
4453   if (stub_sec == NULL)
4454     {
4455       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4456       if (stub_sec == NULL)
4457         {
4458           size_t namelen;
4459           bfd_size_type len;
4460           char *s_name;
4461
4462           namelen = strlen (link_sec->name);
4463           len = namelen + sizeof (STUB_SUFFIX);
4464           s_name = bfd_alloc (htab->params->stub_bfd, len);
4465           if (s_name == NULL)
4466             return NULL;
4467
4468           memcpy (s_name, link_sec->name, namelen);
4469           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4470           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4471           if (stub_sec == NULL)
4472             return NULL;
4473           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4474         }
4475       htab->stub_group[section->id].stub_sec = stub_sec;
4476     }
4477
4478   /* Enter this entry into the linker stub hash table.  */
4479   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4480                                      TRUE, FALSE);
4481   if (stub_entry == NULL)
4482     {
4483       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4484                               section->owner, stub_name);
4485       return NULL;
4486     }
4487
4488   stub_entry->stub_sec = stub_sec;
4489   stub_entry->stub_offset = 0;
4490   stub_entry->id_sec = link_sec;
4491   return stub_entry;
4492 }
4493
4494 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4495    not already done.  */
4496
4497 static bfd_boolean
4498 create_got_section (bfd *abfd, struct bfd_link_info *info)
4499 {
4500   asection *got, *relgot;
4501   flagword flags;
4502   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4503
4504   if (!is_ppc64_elf (abfd))
4505     return FALSE;
4506   if (htab == NULL)
4507     return FALSE;
4508
4509   if (!htab->elf.sgot
4510       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4511     return FALSE;
4512
4513   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4514            | SEC_LINKER_CREATED);
4515
4516   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4517   if (!got
4518       || !bfd_set_section_alignment (abfd, got, 3))
4519     return FALSE;
4520
4521   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4522                                                flags | SEC_READONLY);
4523   if (!relgot
4524       || ! bfd_set_section_alignment (abfd, relgot, 3))
4525     return FALSE;
4526
4527   ppc64_elf_tdata (abfd)->got = got;
4528   ppc64_elf_tdata (abfd)->relgot = relgot;
4529   return TRUE;
4530 }
4531
4532 /* Create the dynamic sections, and set up shortcuts.  */
4533
4534 static bfd_boolean
4535 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4536 {
4537   struct ppc_link_hash_table *htab;
4538
4539   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4540     return FALSE;
4541
4542   htab = ppc_hash_table (info);
4543   if (htab == NULL)
4544     return FALSE;
4545
4546   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4547   if (!info->shared)
4548     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4549
4550   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4551       || (!info->shared && !htab->relbss))
4552     abort ();
4553
4554   return TRUE;
4555 }
4556
4557 /* Follow indirect and warning symbol links.  */
4558
4559 static inline struct bfd_link_hash_entry *
4560 follow_link (struct bfd_link_hash_entry *h)
4561 {
4562   while (h->type == bfd_link_hash_indirect
4563          || h->type == bfd_link_hash_warning)
4564     h = h->u.i.link;
4565   return h;
4566 }
4567
4568 static inline struct elf_link_hash_entry *
4569 elf_follow_link (struct elf_link_hash_entry *h)
4570 {
4571   return (struct elf_link_hash_entry *) follow_link (&h->root);
4572 }
4573
4574 static inline struct ppc_link_hash_entry *
4575 ppc_follow_link (struct ppc_link_hash_entry *h)
4576 {
4577   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4578 }
4579
4580 /* Merge PLT info on FROM with that on TO.  */
4581
4582 static void
4583 move_plt_plist (struct ppc_link_hash_entry *from,
4584                 struct ppc_link_hash_entry *to)
4585 {
4586   if (from->elf.plt.plist != NULL)
4587     {
4588       if (to->elf.plt.plist != NULL)
4589         {
4590           struct plt_entry **entp;
4591           struct plt_entry *ent;
4592
4593           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4594             {
4595               struct plt_entry *dent;
4596
4597               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4598                 if (dent->addend == ent->addend)
4599                   {
4600                     dent->plt.refcount += ent->plt.refcount;
4601                     *entp = ent->next;
4602                     break;
4603                   }
4604               if (dent == NULL)
4605                 entp = &ent->next;
4606             }
4607           *entp = to->elf.plt.plist;
4608         }
4609
4610       to->elf.plt.plist = from->elf.plt.plist;
4611       from->elf.plt.plist = NULL;
4612     }
4613 }
4614
4615 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4616
4617 static void
4618 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4619                                 struct elf_link_hash_entry *dir,
4620                                 struct elf_link_hash_entry *ind)
4621 {
4622   struct ppc_link_hash_entry *edir, *eind;
4623
4624   edir = (struct ppc_link_hash_entry *) dir;
4625   eind = (struct ppc_link_hash_entry *) ind;
4626
4627   edir->is_func |= eind->is_func;
4628   edir->is_func_descriptor |= eind->is_func_descriptor;
4629   edir->tls_mask |= eind->tls_mask;
4630   if (eind->oh != NULL)
4631     edir->oh = ppc_follow_link (eind->oh);
4632
4633   /* If called to transfer flags for a weakdef during processing
4634      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4635      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4636   if (!(ELIMINATE_COPY_RELOCS
4637         && eind->elf.root.type != bfd_link_hash_indirect
4638         && edir->elf.dynamic_adjusted))
4639     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4640
4641   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4642   edir->elf.ref_regular |= eind->elf.ref_regular;
4643   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4644   edir->elf.needs_plt |= eind->elf.needs_plt;
4645   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4646
4647   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4648   if (eind->dyn_relocs != NULL)
4649     {
4650       if (edir->dyn_relocs != NULL)
4651         {
4652           struct elf_dyn_relocs **pp;
4653           struct elf_dyn_relocs *p;
4654
4655           /* Add reloc counts against the indirect sym to the direct sym
4656              list.  Merge any entries against the same section.  */
4657           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4658             {
4659               struct elf_dyn_relocs *q;
4660
4661               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4662                 if (q->sec == p->sec)
4663                   {
4664                     q->pc_count += p->pc_count;
4665                     q->count += p->count;
4666                     *pp = p->next;
4667                     break;
4668                   }
4669               if (q == NULL)
4670                 pp = &p->next;
4671             }
4672           *pp = edir->dyn_relocs;
4673         }
4674
4675       edir->dyn_relocs = eind->dyn_relocs;
4676       eind->dyn_relocs = NULL;
4677     }
4678
4679   /* If we were called to copy over info for a weak sym, that's all.
4680      You might think dyn_relocs need not be copied over;  After all,
4681      both syms will be dynamic or both non-dynamic so we're just
4682      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4683      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4684      dyn_relocs in read-only sections, and it does so on what is the
4685      DIR sym here.  */
4686   if (eind->elf.root.type != bfd_link_hash_indirect)
4687     return;
4688
4689   /* Copy over got entries that we may have already seen to the
4690      symbol which just became indirect.  */
4691   if (eind->elf.got.glist != NULL)
4692     {
4693       if (edir->elf.got.glist != NULL)
4694         {
4695           struct got_entry **entp;
4696           struct got_entry *ent;
4697
4698           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4699             {
4700               struct got_entry *dent;
4701
4702               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4703                 if (dent->addend == ent->addend
4704                     && dent->owner == ent->owner
4705                     && dent->tls_type == ent->tls_type)
4706                   {
4707                     dent->got.refcount += ent->got.refcount;
4708                     *entp = ent->next;
4709                     break;
4710                   }
4711               if (dent == NULL)
4712                 entp = &ent->next;
4713             }
4714           *entp = edir->elf.got.glist;
4715         }
4716
4717       edir->elf.got.glist = eind->elf.got.glist;
4718       eind->elf.got.glist = NULL;
4719     }
4720
4721   /* And plt entries.  */
4722   move_plt_plist (eind, edir);
4723
4724   if (eind->elf.dynindx != -1)
4725     {
4726       if (edir->elf.dynindx != -1)
4727         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4728                                 edir->elf.dynstr_index);
4729       edir->elf.dynindx = eind->elf.dynindx;
4730       edir->elf.dynstr_index = eind->elf.dynstr_index;
4731       eind->elf.dynindx = -1;
4732       eind->elf.dynstr_index = 0;
4733     }
4734 }
4735
4736 /* Find the function descriptor hash entry from the given function code
4737    hash entry FH.  Link the entries via their OH fields.  */
4738
4739 static struct ppc_link_hash_entry *
4740 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4741 {
4742   struct ppc_link_hash_entry *fdh = fh->oh;
4743
4744   if (fdh == NULL)
4745     {
4746       const char *fd_name = fh->elf.root.root.string + 1;
4747
4748       fdh = (struct ppc_link_hash_entry *)
4749         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4750       if (fdh == NULL)
4751         return fdh;
4752
4753       fdh->is_func_descriptor = 1;
4754       fdh->oh = fh;
4755       fh->is_func = 1;
4756       fh->oh = fdh;
4757     }
4758
4759   return ppc_follow_link (fdh);
4760 }
4761
4762 /* Make a fake function descriptor sym for the code sym FH.  */
4763
4764 static struct ppc_link_hash_entry *
4765 make_fdh (struct bfd_link_info *info,
4766           struct ppc_link_hash_entry *fh)
4767 {
4768   bfd *abfd;
4769   asymbol *newsym;
4770   struct bfd_link_hash_entry *bh;
4771   struct ppc_link_hash_entry *fdh;
4772
4773   abfd = fh->elf.root.u.undef.abfd;
4774   newsym = bfd_make_empty_symbol (abfd);
4775   newsym->name = fh->elf.root.root.string + 1;
4776   newsym->section = bfd_und_section_ptr;
4777   newsym->value = 0;
4778   newsym->flags = BSF_WEAK;
4779
4780   bh = NULL;
4781   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4782                                          newsym->flags, newsym->section,
4783                                          newsym->value, NULL, FALSE, FALSE,
4784                                          &bh))
4785     return NULL;
4786
4787   fdh = (struct ppc_link_hash_entry *) bh;
4788   fdh->elf.non_elf = 0;
4789   fdh->fake = 1;
4790   fdh->is_func_descriptor = 1;
4791   fdh->oh = fh;
4792   fh->is_func = 1;
4793   fh->oh = fdh;
4794   return fdh;
4795 }
4796
4797 /* Fix function descriptor symbols defined in .opd sections to be
4798    function type.  */
4799
4800 static bfd_boolean
4801 ppc64_elf_add_symbol_hook (bfd *ibfd,
4802                            struct bfd_link_info *info,
4803                            Elf_Internal_Sym *isym,
4804                            const char **name,
4805                            flagword *flags ATTRIBUTE_UNUSED,
4806                            asection **sec,
4807                            bfd_vma *value ATTRIBUTE_UNUSED)
4808 {
4809   if ((ibfd->flags & DYNAMIC) == 0
4810       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4811     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4812
4813   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4814     {
4815       if ((ibfd->flags & DYNAMIC) == 0)
4816         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4817     }
4818   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4819     ;
4820   else if (*sec != NULL
4821            && strcmp ((*sec)->name, ".opd") == 0)
4822     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4823
4824   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4825     {
4826       if (abiversion (ibfd) == 0)
4827         set_abiversion (ibfd, 2);
4828       else if (abiversion (ibfd) == 1)
4829         {
4830           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4831                                     " for ABI version 1\n"), name);
4832           bfd_set_error (bfd_error_bad_value);
4833           return FALSE;
4834         }
4835     }
4836
4837   return TRUE;
4838 }
4839
4840 /* Merge non-visibility st_other attributes: local entry point.  */
4841
4842 static void
4843 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4844                                   const Elf_Internal_Sym *isym,
4845                                   bfd_boolean definition,
4846                                   bfd_boolean dynamic)
4847 {
4848   if (definition && !dynamic)
4849     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4850                 | ELF_ST_VISIBILITY (h->other));
4851 }
4852
4853 /* This function makes an old ABI object reference to ".bar" cause the
4854    inclusion of a new ABI object archive that defines "bar".
4855    NAME is a symbol defined in an archive.  Return a symbol in the hash
4856    table that might be satisfied by the archive symbols.  */
4857
4858 static struct elf_link_hash_entry *
4859 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4860                                  struct bfd_link_info *info,
4861                                  const char *name)
4862 {
4863   struct elf_link_hash_entry *h;
4864   char *dot_name;
4865   size_t len;
4866
4867   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4868   if (h != NULL
4869       /* Don't return this sym if it is a fake function descriptor
4870          created by add_symbol_adjust.  */
4871       && !(h->root.type == bfd_link_hash_undefweak
4872            && ((struct ppc_link_hash_entry *) h)->fake))
4873     return h;
4874
4875   if (name[0] == '.')
4876     return h;
4877
4878   len = strlen (name);
4879   dot_name = bfd_alloc (abfd, len + 2);
4880   if (dot_name == NULL)
4881     return (struct elf_link_hash_entry *) 0 - 1;
4882   dot_name[0] = '.';
4883   memcpy (dot_name + 1, name, len + 1);
4884   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4885   bfd_release (abfd, dot_name);
4886   return h;
4887 }
4888
4889 /* This function satisfies all old ABI object references to ".bar" if a
4890    new ABI object defines "bar".  Well, at least, undefined dot symbols
4891    are made weak.  This stops later archive searches from including an
4892    object if we already have a function descriptor definition.  It also
4893    prevents the linker complaining about undefined symbols.
4894    We also check and correct mismatched symbol visibility here.  The
4895    most restrictive visibility of the function descriptor and the
4896    function entry symbol is used.  */
4897
4898 static bfd_boolean
4899 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4900 {
4901   struct ppc_link_hash_table *htab;
4902   struct ppc_link_hash_entry *fdh;
4903
4904   if (eh->elf.root.type == bfd_link_hash_indirect)
4905     return TRUE;
4906
4907   if (eh->elf.root.type == bfd_link_hash_warning)
4908     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4909
4910   if (eh->elf.root.root.string[0] != '.')
4911     abort ();
4912
4913   htab = ppc_hash_table (info);
4914   if (htab == NULL)
4915     return FALSE;
4916
4917   fdh = lookup_fdh (eh, htab);
4918   if (fdh == NULL)
4919     {
4920       if (!info->relocatable
4921           && (eh->elf.root.type == bfd_link_hash_undefined
4922               || eh->elf.root.type == bfd_link_hash_undefweak)
4923           && eh->elf.ref_regular)
4924         {
4925           /* Make an undefweak function descriptor sym, which is enough to
4926              pull in an --as-needed shared lib, but won't cause link
4927              errors.  Archives are handled elsewhere.  */
4928           fdh = make_fdh (info, eh);
4929           if (fdh == NULL)
4930             return FALSE;
4931           fdh->elf.ref_regular = 1;
4932         }
4933     }
4934   else
4935     {
4936       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4937       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4938       if (entry_vis < descr_vis)
4939         fdh->elf.other += entry_vis - descr_vis;
4940       else if (entry_vis > descr_vis)
4941         eh->elf.other += descr_vis - entry_vis;
4942
4943       if ((fdh->elf.root.type == bfd_link_hash_defined
4944            || fdh->elf.root.type == bfd_link_hash_defweak)
4945           && eh->elf.root.type == bfd_link_hash_undefined)
4946         {
4947           eh->elf.root.type = bfd_link_hash_undefweak;
4948           eh->was_undefined = 1;
4949           htab->twiddled_syms = 1;
4950         }
4951     }
4952
4953   return TRUE;
4954 }
4955
4956 /* Set up opd section info and abiversion for IBFD, and process list
4957    of dot-symbols we made in link_hash_newfunc.  */
4958
4959 static bfd_boolean
4960 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4961 {
4962   struct ppc_link_hash_table *htab;
4963   struct ppc_link_hash_entry **p, *eh;
4964
4965   if (!is_ppc64_elf (info->output_bfd))
4966     return TRUE;
4967   htab = ppc_hash_table (info);
4968   if (htab == NULL)
4969     return FALSE;
4970
4971   if (is_ppc64_elf (ibfd))
4972     {
4973       asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4974
4975       if (opd != NULL && opd->size != 0)
4976         {
4977           if (abiversion (ibfd) == 0)
4978             set_abiversion (ibfd, 1);
4979           else if (abiversion (ibfd) == 2)
4980             {
4981               info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4982                                         " version %d\n"),
4983                                       ibfd, abiversion (ibfd));
4984               bfd_set_error (bfd_error_bad_value);
4985               return FALSE;
4986             }
4987
4988           if ((ibfd->flags & DYNAMIC) == 0
4989               && (opd->flags & SEC_RELOC) != 0
4990               && opd->reloc_count != 0
4991               && !bfd_is_abs_section (opd->output_section))
4992             {
4993               /* Garbage collection needs some extra help with .opd sections.
4994                  We don't want to necessarily keep everything referenced by
4995                  relocs in .opd, as that would keep all functions.  Instead,
4996                  if we reference an .opd symbol (a function descriptor), we
4997                  want to keep the function code symbol's section.  This is
4998                  easy for global symbols, but for local syms we need to keep
4999                  information about the associated function section.  */
5000               bfd_size_type amt;
5001               asection **opd_sym_map;
5002
5003               amt = opd->size * sizeof (*opd_sym_map) / 8;
5004               opd_sym_map = bfd_zalloc (ibfd, amt);
5005               if (opd_sym_map == NULL)
5006                 return FALSE;
5007               ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5008               BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5009               ppc64_elf_section_data (opd)->sec_type = sec_opd;
5010             }
5011         }
5012
5013       /* For input files without an explicit abiversion in e_flags
5014          we should have flagged any with symbol st_other bits set
5015          as ELFv1 and above flagged those with .opd as ELFv2.
5016          Set the output abiversion if not yet set, and for any input
5017          still ambiguous, take its abiversion from the output.
5018          Differences in ABI are reported later.  */
5019       if (abiversion (info->output_bfd) == 0)
5020         set_abiversion (info->output_bfd, abiversion (ibfd));
5021       else if (abiversion (ibfd) == 0)
5022         set_abiversion (ibfd, abiversion (info->output_bfd));
5023
5024       p = &htab->dot_syms;
5025       while ((eh = *p) != NULL)
5026         {
5027           *p = NULL;
5028           if (&eh->elf == htab->elf.hgot)
5029             ;
5030           else if (htab->elf.hgot == NULL
5031                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5032             htab->elf.hgot = &eh->elf;
5033           else if (!add_symbol_adjust (eh, info))
5034             return FALSE;
5035           p = &eh->u.next_dot_sym;
5036         }
5037     }
5038
5039   /* Clear the list for non-ppc64 input files.  */
5040   p = &htab->dot_syms;
5041   while ((eh = *p) != NULL)
5042     {
5043       *p = NULL;
5044       p = &eh->u.next_dot_sym;
5045     }
5046
5047   /* We need to fix the undefs list for any syms we have twiddled to
5048      undef_weak.  */
5049   if (htab->twiddled_syms)
5050     {
5051       bfd_link_repair_undef_list (&htab->elf.root);
5052       htab->twiddled_syms = 0;
5053     }
5054   return TRUE;
5055 }
5056
5057 /* Undo hash table changes when an --as-needed input file is determined
5058    not to be needed.  */
5059
5060 static bfd_boolean
5061 ppc64_elf_notice_as_needed (bfd *ibfd,
5062                             struct bfd_link_info *info,
5063                             enum notice_asneeded_action act)
5064 {
5065   if (act == notice_not_needed)
5066     {
5067       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5068
5069       if (htab == NULL)
5070         return FALSE;
5071
5072       htab->dot_syms = NULL;
5073     }
5074   return _bfd_elf_notice_as_needed (ibfd, info, act);
5075 }
5076
5077 /* If --just-symbols against a final linked binary, then assume we need
5078    toc adjusting stubs when calling functions defined there.  */
5079
5080 static void
5081 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5082 {
5083   if ((sec->flags & SEC_CODE) != 0
5084       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5085       && is_ppc64_elf (sec->owner))
5086     {
5087       if (abiversion (sec->owner) >= 2
5088           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5089         sec->has_toc_reloc = 1;
5090     }
5091   _bfd_elf_link_just_syms (sec, info);
5092 }
5093
5094 static struct plt_entry **
5095 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5096                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5097 {
5098   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5099   struct plt_entry **local_plt;
5100   unsigned char *local_got_tls_masks;
5101
5102   if (local_got_ents == NULL)
5103     {
5104       bfd_size_type size = symtab_hdr->sh_info;
5105
5106       size *= (sizeof (*local_got_ents)
5107                + sizeof (*local_plt)
5108                + sizeof (*local_got_tls_masks));
5109       local_got_ents = bfd_zalloc (abfd, size);
5110       if (local_got_ents == NULL)
5111         return NULL;
5112       elf_local_got_ents (abfd) = local_got_ents;
5113     }
5114
5115   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5116     {
5117       struct got_entry *ent;
5118
5119       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5120         if (ent->addend == r_addend
5121             && ent->owner == abfd
5122             && ent->tls_type == tls_type)
5123           break;
5124       if (ent == NULL)
5125         {
5126           bfd_size_type amt = sizeof (*ent);
5127           ent = bfd_alloc (abfd, amt);
5128           if (ent == NULL)
5129             return FALSE;
5130           ent->next = local_got_ents[r_symndx];
5131           ent->addend = r_addend;
5132           ent->owner = abfd;
5133           ent->tls_type = tls_type;
5134           ent->is_indirect = FALSE;
5135           ent->got.refcount = 0;
5136           local_got_ents[r_symndx] = ent;
5137         }
5138       ent->got.refcount += 1;
5139     }
5140
5141   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5142   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5143   local_got_tls_masks[r_symndx] |= tls_type;
5144
5145   return local_plt + r_symndx;
5146 }
5147
5148 static bfd_boolean
5149 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5150 {
5151   struct plt_entry *ent;
5152
5153   for (ent = *plist; ent != NULL; ent = ent->next)
5154     if (ent->addend == addend)
5155       break;
5156   if (ent == NULL)
5157     {
5158       bfd_size_type amt = sizeof (*ent);
5159       ent = bfd_alloc (abfd, amt);
5160       if (ent == NULL)
5161         return FALSE;
5162       ent->next = *plist;
5163       ent->addend = addend;
5164       ent->plt.refcount = 0;
5165       *plist = ent;
5166     }
5167   ent->plt.refcount += 1;
5168   return TRUE;
5169 }
5170
5171 static bfd_boolean
5172 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5173 {
5174   return (r_type == R_PPC64_REL24
5175           || r_type == R_PPC64_REL14
5176           || r_type == R_PPC64_REL14_BRTAKEN
5177           || r_type == R_PPC64_REL14_BRNTAKEN
5178           || r_type == R_PPC64_ADDR24
5179           || r_type == R_PPC64_ADDR14
5180           || r_type == R_PPC64_ADDR14_BRTAKEN
5181           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5182 }
5183
5184 /* Look through the relocs for a section during the first phase, and
5185    calculate needed space in the global offset table, procedure
5186    linkage table, and dynamic reloc sections.  */
5187
5188 static bfd_boolean
5189 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5190                         asection *sec, const Elf_Internal_Rela *relocs)
5191 {
5192   struct ppc_link_hash_table *htab;
5193   Elf_Internal_Shdr *symtab_hdr;
5194   struct elf_link_hash_entry **sym_hashes;
5195   const Elf_Internal_Rela *rel;
5196   const Elf_Internal_Rela *rel_end;
5197   asection *sreloc;
5198   asection **opd_sym_map;
5199   struct elf_link_hash_entry *tga, *dottga;
5200
5201   if (info->relocatable)
5202     return TRUE;
5203
5204   /* Don't do anything special with non-loaded, non-alloced sections.
5205      In particular, any relocs in such sections should not affect GOT
5206      and PLT reference counting (ie. we don't allow them to create GOT
5207      or PLT entries), there's no possibility or desire to optimize TLS
5208      relocs, and there's not much point in propagating relocs to shared
5209      libs that the dynamic linker won't relocate.  */
5210   if ((sec->flags & SEC_ALLOC) == 0)
5211     return TRUE;
5212
5213   BFD_ASSERT (is_ppc64_elf (abfd));
5214
5215   htab = ppc_hash_table (info);
5216   if (htab == NULL)
5217     return FALSE;
5218
5219   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5220                               FALSE, FALSE, TRUE);
5221   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5222                                  FALSE, FALSE, TRUE);
5223   symtab_hdr = &elf_symtab_hdr (abfd);
5224   sym_hashes = elf_sym_hashes (abfd);
5225   sreloc = NULL;
5226   opd_sym_map = NULL;
5227   if (ppc64_elf_section_data (sec) != NULL
5228       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5229     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5230
5231   rel_end = relocs + sec->reloc_count;
5232   for (rel = relocs; rel < rel_end; rel++)
5233     {
5234       unsigned long r_symndx;
5235       struct elf_link_hash_entry *h;
5236       enum elf_ppc64_reloc_type r_type;
5237       int tls_type;
5238       struct _ppc64_elf_section_data *ppc64_sec;
5239       struct plt_entry **ifunc;
5240
5241       r_symndx = ELF64_R_SYM (rel->r_info);
5242       if (r_symndx < symtab_hdr->sh_info)
5243         h = NULL;
5244       else
5245         {
5246           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5247           h = elf_follow_link (h);
5248
5249           /* PR15323, ref flags aren't set for references in the same
5250              object.  */
5251           h->root.non_ir_ref = 1;
5252
5253           if (h == htab->elf.hgot)
5254             sec->has_toc_reloc = 1;
5255         }
5256
5257       tls_type = 0;
5258       ifunc = NULL;
5259       if (h != NULL)
5260         {
5261           if (h->type == STT_GNU_IFUNC)
5262             {
5263               h->needs_plt = 1;
5264               ifunc = &h->plt.plist;
5265             }
5266         }
5267       else
5268         {
5269           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5270                                                           abfd, r_symndx);
5271           if (isym == NULL)
5272             return FALSE;
5273
5274           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5275             {
5276               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5277                                              rel->r_addend, PLT_IFUNC);
5278               if (ifunc == NULL)
5279                 return FALSE;
5280             }
5281         }
5282       r_type = ELF64_R_TYPE (rel->r_info);
5283       if (is_branch_reloc (r_type))
5284         {
5285           if (h != NULL && (h == tga || h == dottga))
5286             {
5287               if (rel != relocs
5288                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5289                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5290                 /* We have a new-style __tls_get_addr call with a marker
5291                    reloc.  */
5292                 ;
5293               else
5294                 /* Mark this section as having an old-style call.  */
5295                 sec->has_tls_get_addr_call = 1;
5296             }
5297
5298           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5299           if (ifunc != NULL
5300               && !update_plt_info (abfd, ifunc, rel->r_addend))
5301             return FALSE;
5302         }
5303
5304       switch (r_type)
5305         {
5306         case R_PPC64_TLSGD:
5307         case R_PPC64_TLSLD:
5308           /* These special tls relocs tie a call to __tls_get_addr with
5309              its parameter symbol.  */
5310           break;
5311
5312         case R_PPC64_GOT_TLSLD16:
5313         case R_PPC64_GOT_TLSLD16_LO:
5314         case R_PPC64_GOT_TLSLD16_HI:
5315         case R_PPC64_GOT_TLSLD16_HA:
5316           tls_type = TLS_TLS | TLS_LD;
5317           goto dogottls;
5318
5319         case R_PPC64_GOT_TLSGD16:
5320         case R_PPC64_GOT_TLSGD16_LO:
5321         case R_PPC64_GOT_TLSGD16_HI:
5322         case R_PPC64_GOT_TLSGD16_HA:
5323           tls_type = TLS_TLS | TLS_GD;
5324           goto dogottls;
5325
5326         case R_PPC64_GOT_TPREL16_DS:
5327         case R_PPC64_GOT_TPREL16_LO_DS:
5328         case R_PPC64_GOT_TPREL16_HI:
5329         case R_PPC64_GOT_TPREL16_HA:
5330           if (!info->executable)
5331             info->flags |= DF_STATIC_TLS;
5332           tls_type = TLS_TLS | TLS_TPREL;
5333           goto dogottls;
5334
5335         case R_PPC64_GOT_DTPREL16_DS:
5336         case R_PPC64_GOT_DTPREL16_LO_DS:
5337         case R_PPC64_GOT_DTPREL16_HI:
5338         case R_PPC64_GOT_DTPREL16_HA:
5339           tls_type = TLS_TLS | TLS_DTPREL;
5340         dogottls:
5341           sec->has_tls_reloc = 1;
5342           /* Fall thru */
5343
5344         case R_PPC64_GOT16:
5345         case R_PPC64_GOT16_DS:
5346         case R_PPC64_GOT16_HA:
5347         case R_PPC64_GOT16_HI:
5348         case R_PPC64_GOT16_LO:
5349         case R_PPC64_GOT16_LO_DS:
5350           /* This symbol requires a global offset table entry.  */
5351           sec->has_toc_reloc = 1;
5352           if (r_type == R_PPC64_GOT_TLSLD16
5353               || r_type == R_PPC64_GOT_TLSGD16
5354               || r_type == R_PPC64_GOT_TPREL16_DS
5355               || r_type == R_PPC64_GOT_DTPREL16_DS
5356               || r_type == R_PPC64_GOT16
5357               || r_type == R_PPC64_GOT16_DS)
5358             {
5359               htab->do_multi_toc = 1;
5360               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5361             }
5362
5363           if (ppc64_elf_tdata (abfd)->got == NULL
5364               && !create_got_section (abfd, info))
5365             return FALSE;
5366
5367           if (h != NULL)
5368             {
5369               struct ppc_link_hash_entry *eh;
5370               struct got_entry *ent;
5371
5372               eh = (struct ppc_link_hash_entry *) h;
5373               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5374                 if (ent->addend == rel->r_addend
5375                     && ent->owner == abfd
5376                     && ent->tls_type == tls_type)
5377                   break;
5378               if (ent == NULL)
5379                 {
5380                   bfd_size_type amt = sizeof (*ent);
5381                   ent = bfd_alloc (abfd, amt);
5382                   if (ent == NULL)
5383                     return FALSE;
5384                   ent->next = eh->elf.got.glist;
5385                   ent->addend = rel->r_addend;
5386                   ent->owner = abfd;
5387                   ent->tls_type = tls_type;
5388                   ent->is_indirect = FALSE;
5389                   ent->got.refcount = 0;
5390                   eh->elf.got.glist = ent;
5391                 }
5392               ent->got.refcount += 1;
5393               eh->tls_mask |= tls_type;
5394             }
5395           else
5396             /* This is a global offset table entry for a local symbol.  */
5397             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5398                                         rel->r_addend, tls_type))
5399               return FALSE;
5400
5401           /* We may also need a plt entry if the symbol turns out to be
5402              an ifunc.  */
5403           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5404             {
5405               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5406                 return FALSE;
5407             }
5408           break;
5409
5410         case R_PPC64_PLT16_HA:
5411         case R_PPC64_PLT16_HI:
5412         case R_PPC64_PLT16_LO:
5413         case R_PPC64_PLT32:
5414         case R_PPC64_PLT64:
5415           /* This symbol requires a procedure linkage table entry.  We
5416              actually build the entry in adjust_dynamic_symbol,
5417              because this might be a case of linking PIC code without
5418              linking in any dynamic objects, in which case we don't
5419              need to generate a procedure linkage table after all.  */
5420           if (h == NULL)
5421             {
5422               /* It does not make sense to have a procedure linkage
5423                  table entry for a local symbol.  */
5424               bfd_set_error (bfd_error_bad_value);
5425               return FALSE;
5426             }
5427           else
5428             {
5429               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5430                 return FALSE;
5431               h->needs_plt = 1;
5432               if (h->root.root.string[0] == '.'
5433                   && h->root.root.string[1] != '\0')
5434                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5435             }
5436           break;
5437
5438           /* The following relocations don't need to propagate the
5439              relocation if linking a shared object since they are
5440              section relative.  */
5441         case R_PPC64_SECTOFF:
5442         case R_PPC64_SECTOFF_LO:
5443         case R_PPC64_SECTOFF_HI:
5444         case R_PPC64_SECTOFF_HA:
5445         case R_PPC64_SECTOFF_DS:
5446         case R_PPC64_SECTOFF_LO_DS:
5447         case R_PPC64_DTPREL16:
5448         case R_PPC64_DTPREL16_LO:
5449         case R_PPC64_DTPREL16_HI:
5450         case R_PPC64_DTPREL16_HA:
5451         case R_PPC64_DTPREL16_DS:
5452         case R_PPC64_DTPREL16_LO_DS:
5453         case R_PPC64_DTPREL16_HIGH:
5454         case R_PPC64_DTPREL16_HIGHA:
5455         case R_PPC64_DTPREL16_HIGHER:
5456         case R_PPC64_DTPREL16_HIGHERA:
5457         case R_PPC64_DTPREL16_HIGHEST:
5458         case R_PPC64_DTPREL16_HIGHESTA:
5459           break;
5460
5461           /* Nor do these.  */
5462         case R_PPC64_REL16:
5463         case R_PPC64_REL16_LO:
5464         case R_PPC64_REL16_HI:
5465         case R_PPC64_REL16_HA:
5466           break;
5467
5468           /* Not supported as a dynamic relocation.  */
5469         case R_PPC64_ADDR64_LOCAL:
5470           if (info->shared)
5471             {
5472               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5473                 ppc_howto_init ();
5474               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5475                                         "in shared libraries and PIEs.\n"),
5476                                       abfd, sec, rel->r_offset,
5477                                       ppc64_elf_howto_table[r_type]->name);
5478               bfd_set_error (bfd_error_bad_value);
5479               return FALSE;
5480             }
5481           break;
5482
5483         case R_PPC64_TOC16:
5484         case R_PPC64_TOC16_DS:
5485           htab->do_multi_toc = 1;
5486           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5487         case R_PPC64_TOC16_LO:
5488         case R_PPC64_TOC16_HI:
5489         case R_PPC64_TOC16_HA:
5490         case R_PPC64_TOC16_LO_DS:
5491           sec->has_toc_reloc = 1;
5492           break;
5493
5494           /* This relocation describes the C++ object vtable hierarchy.
5495              Reconstruct it for later use during GC.  */
5496         case R_PPC64_GNU_VTINHERIT:
5497           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5498             return FALSE;
5499           break;
5500
5501           /* This relocation describes which C++ vtable entries are actually
5502              used.  Record for later use during GC.  */
5503         case R_PPC64_GNU_VTENTRY:
5504           BFD_ASSERT (h != NULL);
5505           if (h != NULL
5506               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5507             return FALSE;
5508           break;
5509
5510         case R_PPC64_REL14:
5511         case R_PPC64_REL14_BRTAKEN:
5512         case R_PPC64_REL14_BRNTAKEN:
5513           {
5514             asection *dest = NULL;
5515
5516             /* Heuristic: If jumping outside our section, chances are
5517                we are going to need a stub.  */
5518             if (h != NULL)
5519               {
5520                 /* If the sym is weak it may be overridden later, so
5521                    don't assume we know where a weak sym lives.  */
5522                 if (h->root.type == bfd_link_hash_defined)
5523                   dest = h->root.u.def.section;
5524               }
5525             else
5526               {
5527                 Elf_Internal_Sym *isym;
5528
5529                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5530                                               abfd, r_symndx);
5531                 if (isym == NULL)
5532                   return FALSE;
5533
5534                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5535               }
5536
5537             if (dest != sec)
5538               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5539           }
5540           /* Fall through.  */
5541
5542         case R_PPC64_REL24:
5543           if (h != NULL && ifunc == NULL)
5544             {
5545               /* We may need a .plt entry if the function this reloc
5546                  refers to is in a shared lib.  */
5547               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5548                 return FALSE;
5549               h->needs_plt = 1;
5550               if (h->root.root.string[0] == '.'
5551                   && h->root.root.string[1] != '\0')
5552                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5553               if (h == tga || h == dottga)
5554                 sec->has_tls_reloc = 1;
5555             }
5556           break;
5557
5558         case R_PPC64_TPREL64:
5559           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5560           if (!info->executable)
5561             info->flags |= DF_STATIC_TLS;
5562           goto dotlstoc;
5563
5564         case R_PPC64_DTPMOD64:
5565           if (rel + 1 < rel_end
5566               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5567               && rel[1].r_offset == rel->r_offset + 8)
5568             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5569           else
5570             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5571           goto dotlstoc;
5572
5573         case R_PPC64_DTPREL64:
5574           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5575           if (rel != relocs
5576               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5577               && rel[-1].r_offset == rel->r_offset - 8)
5578             /* This is the second reloc of a dtpmod, dtprel pair.
5579                Don't mark with TLS_DTPREL.  */
5580             goto dodyn;
5581
5582         dotlstoc:
5583           sec->has_tls_reloc = 1;
5584           if (h != NULL)
5585             {
5586               struct ppc_link_hash_entry *eh;
5587               eh = (struct ppc_link_hash_entry *) h;
5588               eh->tls_mask |= tls_type;
5589             }
5590           else
5591             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5592                                         rel->r_addend, tls_type))
5593               return FALSE;
5594
5595           ppc64_sec = ppc64_elf_section_data (sec);
5596           if (ppc64_sec->sec_type != sec_toc)
5597             {
5598               bfd_size_type amt;
5599
5600               /* One extra to simplify get_tls_mask.  */
5601               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5602               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5603               if (ppc64_sec->u.toc.symndx == NULL)
5604                 return FALSE;
5605               amt = sec->size * sizeof (bfd_vma) / 8;
5606               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5607               if (ppc64_sec->u.toc.add == NULL)
5608                 return FALSE;
5609               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5610               ppc64_sec->sec_type = sec_toc;
5611             }
5612           BFD_ASSERT (rel->r_offset % 8 == 0);
5613           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5614           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5615
5616           /* Mark the second slot of a GD or LD entry.
5617              -1 to indicate GD and -2 to indicate LD.  */
5618           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5619             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5620           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5621             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5622           goto dodyn;
5623
5624         case R_PPC64_TPREL16:
5625         case R_PPC64_TPREL16_LO:
5626         case R_PPC64_TPREL16_HI:
5627         case R_PPC64_TPREL16_HA:
5628         case R_PPC64_TPREL16_DS:
5629         case R_PPC64_TPREL16_LO_DS:
5630         case R_PPC64_TPREL16_HIGH:
5631         case R_PPC64_TPREL16_HIGHA:
5632         case R_PPC64_TPREL16_HIGHER:
5633         case R_PPC64_TPREL16_HIGHERA:
5634         case R_PPC64_TPREL16_HIGHEST:
5635         case R_PPC64_TPREL16_HIGHESTA:
5636           if (info->shared)
5637             {
5638               if (!info->executable)
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         }
6997       else if (abiversion (info->output_bfd) == 2)
6998         {
6999           /* After adjust_dynamic_symbol, non_got_ref set in the
7000              non-shared case means that we have allocated space in
7001              .dynbss for the symbol and thus dyn_relocs for this
7002              symbol should be discarded.
7003              If we get here we know we are making a PLT entry for this
7004              symbol, and in an executable we'd normally resolve
7005              relocations against this symbol to the PLT entry.  Allow
7006              dynamic relocs if the reference is weak, and the dynamic
7007              relocs will not cause text relocation.  */
7008           if (!h->ref_regular_nonweak
7009               && h->non_got_ref
7010               && h->type != STT_GNU_IFUNC
7011               && !readonly_dynrelocs (h))
7012             h->non_got_ref = 0;
7013
7014           /* If making a plt entry, then we don't need copy relocs.  */
7015           return TRUE;
7016         }
7017     }
7018   else
7019     h->plt.plist = NULL;
7020
7021   /* If this is a weak symbol, and there is a real definition, the
7022      processor independent code will have arranged for us to see the
7023      real definition first, and we can just use the same value.  */
7024   if (h->u.weakdef != NULL)
7025     {
7026       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7027                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7028       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7029       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7030       if (ELIMINATE_COPY_RELOCS)
7031         h->non_got_ref = h->u.weakdef->non_got_ref;
7032       return TRUE;
7033     }
7034
7035   /* If we are creating a shared library, we must presume that the
7036      only references to the symbol are via the global offset table.
7037      For such cases we need not do anything here; the relocations will
7038      be handled correctly by relocate_section.  */
7039   if (info->shared)
7040     return TRUE;
7041
7042   /* If there are no references to this symbol that do not use the
7043      GOT, we don't need to generate a copy reloc.  */
7044   if (!h->non_got_ref)
7045     return TRUE;
7046
7047   /* Don't generate a copy reloc for symbols defined in the executable.  */
7048   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7049     return TRUE;
7050
7051   /* If we didn't find any dynamic relocs in read-only sections, then
7052      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7053   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7054     {
7055       h->non_got_ref = 0;
7056       return TRUE;
7057     }
7058
7059   if (h->plt.plist != NULL)
7060     {
7061       /* We should never get here, but unfortunately there are versions
7062          of gcc out there that improperly (for this ABI) put initialized
7063          function pointers, vtable refs and suchlike in read-only
7064          sections.  Allow them to proceed, but warn that this might
7065          break at runtime.  */
7066       info->callbacks->einfo
7067         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7068            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7069          h->root.root.string);
7070     }
7071
7072   /* This is a reference to a symbol defined by a dynamic object which
7073      is not a function.  */
7074
7075   /* We must allocate the symbol in our .dynbss section, which will
7076      become part of the .bss section of the executable.  There will be
7077      an entry for this symbol in the .dynsym section.  The dynamic
7078      object will contain position independent code, so all references
7079      from the dynamic object to this symbol will go through the global
7080      offset table.  The dynamic linker will use the .dynsym entry to
7081      determine the address it must put in the global offset table, so
7082      both the dynamic object and the regular object will refer to the
7083      same memory location for the variable.  */
7084
7085   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7086      to copy the initial value out of the dynamic object and into the
7087      runtime process image.  We need to remember the offset into the
7088      .rela.bss section we are going to use.  */
7089   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7090     {
7091       htab->relbss->size += sizeof (Elf64_External_Rela);
7092       h->needs_copy = 1;
7093     }
7094
7095   s = htab->dynbss;
7096
7097   return _bfd_elf_adjust_dynamic_copy (h, s);
7098 }
7099
7100 /* If given a function descriptor symbol, hide both the function code
7101    sym and the descriptor.  */
7102 static void
7103 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7104                        struct elf_link_hash_entry *h,
7105                        bfd_boolean force_local)
7106 {
7107   struct ppc_link_hash_entry *eh;
7108   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7109
7110   eh = (struct ppc_link_hash_entry *) h;
7111   if (eh->is_func_descriptor)
7112     {
7113       struct ppc_link_hash_entry *fh = eh->oh;
7114
7115       if (fh == NULL)
7116         {
7117           const char *p, *q;
7118           struct ppc_link_hash_table *htab;
7119           char save;
7120
7121           /* We aren't supposed to use alloca in BFD because on
7122              systems which do not have alloca the version in libiberty
7123              calls xmalloc, which might cause the program to crash
7124              when it runs out of memory.  This function doesn't have a
7125              return status, so there's no way to gracefully return an
7126              error.  So cheat.  We know that string[-1] can be safely
7127              accessed;  It's either a string in an ELF string table,
7128              or allocated in an objalloc structure.  */
7129
7130           p = eh->elf.root.root.string - 1;
7131           save = *p;
7132           *(char *) p = '.';
7133           htab = ppc_hash_table (info);
7134           if (htab == NULL)
7135             return;
7136
7137           fh = (struct ppc_link_hash_entry *)
7138             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7139           *(char *) p = save;
7140
7141           /* Unfortunately, if it so happens that the string we were
7142              looking for was allocated immediately before this string,
7143              then we overwrote the string terminator.  That's the only
7144              reason the lookup should fail.  */
7145           if (fh == NULL)
7146             {
7147               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7148               while (q >= eh->elf.root.root.string && *q == *p)
7149                 --q, --p;
7150               if (q < eh->elf.root.root.string && *p == '.')
7151                 fh = (struct ppc_link_hash_entry *)
7152                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7153             }
7154           if (fh != NULL)
7155             {
7156               eh->oh = fh;
7157               fh->oh = eh;
7158             }
7159         }
7160       if (fh != NULL)
7161         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7162     }
7163 }
7164
7165 static bfd_boolean
7166 get_sym_h (struct elf_link_hash_entry **hp,
7167            Elf_Internal_Sym **symp,
7168            asection **symsecp,
7169            unsigned char **tls_maskp,
7170            Elf_Internal_Sym **locsymsp,
7171            unsigned long r_symndx,
7172            bfd *ibfd)
7173 {
7174   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7175
7176   if (r_symndx >= symtab_hdr->sh_info)
7177     {
7178       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7179       struct elf_link_hash_entry *h;
7180
7181       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7182       h = elf_follow_link (h);
7183
7184       if (hp != NULL)
7185         *hp = h;
7186
7187       if (symp != NULL)
7188         *symp = NULL;
7189
7190       if (symsecp != NULL)
7191         {
7192           asection *symsec = NULL;
7193           if (h->root.type == bfd_link_hash_defined
7194               || h->root.type == bfd_link_hash_defweak)
7195             symsec = h->root.u.def.section;
7196           *symsecp = symsec;
7197         }
7198
7199       if (tls_maskp != NULL)
7200         {
7201           struct ppc_link_hash_entry *eh;
7202
7203           eh = (struct ppc_link_hash_entry *) h;
7204           *tls_maskp = &eh->tls_mask;
7205         }
7206     }
7207   else
7208     {
7209       Elf_Internal_Sym *sym;
7210       Elf_Internal_Sym *locsyms = *locsymsp;
7211
7212       if (locsyms == NULL)
7213         {
7214           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7215           if (locsyms == NULL)
7216             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7217                                             symtab_hdr->sh_info,
7218                                             0, NULL, NULL, NULL);
7219           if (locsyms == NULL)
7220             return FALSE;
7221           *locsymsp = locsyms;
7222         }
7223       sym = locsyms + r_symndx;
7224
7225       if (hp != NULL)
7226         *hp = NULL;
7227
7228       if (symp != NULL)
7229         *symp = sym;
7230
7231       if (symsecp != NULL)
7232         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7233
7234       if (tls_maskp != NULL)
7235         {
7236           struct got_entry **lgot_ents;
7237           unsigned char *tls_mask;
7238
7239           tls_mask = NULL;
7240           lgot_ents = elf_local_got_ents (ibfd);
7241           if (lgot_ents != NULL)
7242             {
7243               struct plt_entry **local_plt = (struct plt_entry **)
7244                 (lgot_ents + symtab_hdr->sh_info);
7245               unsigned char *lgot_masks = (unsigned char *)
7246                 (local_plt + symtab_hdr->sh_info);
7247               tls_mask = &lgot_masks[r_symndx];
7248             }
7249           *tls_maskp = tls_mask;
7250         }
7251     }
7252   return TRUE;
7253 }
7254
7255 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7256    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7257    type suitable for optimization, and 1 otherwise.  */
7258
7259 static int
7260 get_tls_mask (unsigned char **tls_maskp,
7261               unsigned long *toc_symndx,
7262               bfd_vma *toc_addend,
7263               Elf_Internal_Sym **locsymsp,
7264               const Elf_Internal_Rela *rel,
7265               bfd *ibfd)
7266 {
7267   unsigned long r_symndx;
7268   int next_r;
7269   struct elf_link_hash_entry *h;
7270   Elf_Internal_Sym *sym;
7271   asection *sec;
7272   bfd_vma off;
7273
7274   r_symndx = ELF64_R_SYM (rel->r_info);
7275   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7276     return 0;
7277
7278   if ((*tls_maskp != NULL && **tls_maskp != 0)
7279       || sec == NULL
7280       || ppc64_elf_section_data (sec) == NULL
7281       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7282     return 1;
7283
7284   /* Look inside a TOC section too.  */
7285   if (h != NULL)
7286     {
7287       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7288       off = h->root.u.def.value;
7289     }
7290   else
7291     off = sym->st_value;
7292   off += rel->r_addend;
7293   BFD_ASSERT (off % 8 == 0);
7294   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7295   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7296   if (toc_symndx != NULL)
7297     *toc_symndx = r_symndx;
7298   if (toc_addend != NULL)
7299     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7300   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7301     return 0;
7302   if ((h == NULL || is_static_defined (h))
7303       && (next_r == -1 || next_r == -2))
7304     return 1 - next_r;
7305   return 1;
7306 }
7307
7308 /* Find (or create) an entry in the tocsave hash table.  */
7309
7310 static struct tocsave_entry *
7311 tocsave_find (struct ppc_link_hash_table *htab,
7312               enum insert_option insert,
7313               Elf_Internal_Sym **local_syms,
7314               const Elf_Internal_Rela *irela,
7315               bfd *ibfd)
7316 {
7317   unsigned long r_indx;
7318   struct elf_link_hash_entry *h;
7319   Elf_Internal_Sym *sym;
7320   struct tocsave_entry ent, *p;
7321   hashval_t hash;
7322   struct tocsave_entry **slot;
7323
7324   r_indx = ELF64_R_SYM (irela->r_info);
7325   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7326     return NULL;
7327   if (ent.sec == NULL || ent.sec->output_section == NULL)
7328     {
7329       (*_bfd_error_handler)
7330         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7331       return NULL;
7332     }
7333
7334   if (h != NULL)
7335     ent.offset = h->root.u.def.value;
7336   else
7337     ent.offset = sym->st_value;
7338   ent.offset += irela->r_addend;
7339
7340   hash = tocsave_htab_hash (&ent);
7341   slot = ((struct tocsave_entry **)
7342           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7343   if (slot == NULL)
7344     return NULL;
7345
7346   if (*slot == NULL)
7347     {
7348       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7349       if (p == NULL)
7350         return NULL;
7351       *p = ent;
7352       *slot = p;
7353     }
7354   return *slot;
7355 }
7356
7357 /* Adjust all global syms defined in opd sections.  In gcc generated
7358    code for the old ABI, these will already have been done.  */
7359
7360 static bfd_boolean
7361 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7362 {
7363   struct ppc_link_hash_entry *eh;
7364   asection *sym_sec;
7365   struct _opd_sec_data *opd;
7366
7367   if (h->root.type == bfd_link_hash_indirect)
7368     return TRUE;
7369
7370   if (h->root.type != bfd_link_hash_defined
7371       && h->root.type != bfd_link_hash_defweak)
7372     return TRUE;
7373
7374   eh = (struct ppc_link_hash_entry *) h;
7375   if (eh->adjust_done)
7376     return TRUE;
7377
7378   sym_sec = eh->elf.root.u.def.section;
7379   opd = get_opd_info (sym_sec);
7380   if (opd != NULL && opd->adjust != NULL)
7381     {
7382       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7383       if (adjust == -1)
7384         {
7385           /* This entry has been deleted.  */
7386           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7387           if (dsec == NULL)
7388             {
7389               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7390                 if (discarded_section (dsec))
7391                   {
7392                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7393                     break;
7394                   }
7395             }
7396           eh->elf.root.u.def.value = 0;
7397           eh->elf.root.u.def.section = dsec;
7398         }
7399       else
7400         eh->elf.root.u.def.value += adjust;
7401       eh->adjust_done = 1;
7402     }
7403   return TRUE;
7404 }
7405
7406 /* Handles decrementing dynamic reloc counts for the reloc specified by
7407    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7408    have already been determined.  */
7409
7410 static bfd_boolean
7411 dec_dynrel_count (bfd_vma r_info,
7412                   asection *sec,
7413                   struct bfd_link_info *info,
7414                   Elf_Internal_Sym **local_syms,
7415                   struct elf_link_hash_entry *h,
7416                   Elf_Internal_Sym *sym)
7417 {
7418   enum elf_ppc64_reloc_type r_type;
7419   asection *sym_sec = NULL;
7420
7421   /* Can this reloc be dynamic?  This switch, and later tests here
7422      should be kept in sync with the code in check_relocs.  */
7423   r_type = ELF64_R_TYPE (r_info);
7424   switch (r_type)
7425     {
7426     default:
7427       return TRUE;
7428
7429     case R_PPC64_TPREL16:
7430     case R_PPC64_TPREL16_LO:
7431     case R_PPC64_TPREL16_HI:
7432     case R_PPC64_TPREL16_HA:
7433     case R_PPC64_TPREL16_DS:
7434     case R_PPC64_TPREL16_LO_DS:
7435     case R_PPC64_TPREL16_HIGH:
7436     case R_PPC64_TPREL16_HIGHA:
7437     case R_PPC64_TPREL16_HIGHER:
7438     case R_PPC64_TPREL16_HIGHERA:
7439     case R_PPC64_TPREL16_HIGHEST:
7440     case R_PPC64_TPREL16_HIGHESTA:
7441       if (!info->shared)
7442         return TRUE;
7443
7444     case R_PPC64_TPREL64:
7445     case R_PPC64_DTPMOD64:
7446     case R_PPC64_DTPREL64:
7447     case R_PPC64_ADDR64:
7448     case R_PPC64_REL30:
7449     case R_PPC64_REL32:
7450     case R_PPC64_REL64:
7451     case R_PPC64_ADDR14:
7452     case R_PPC64_ADDR14_BRNTAKEN:
7453     case R_PPC64_ADDR14_BRTAKEN:
7454     case R_PPC64_ADDR16:
7455     case R_PPC64_ADDR16_DS:
7456     case R_PPC64_ADDR16_HA:
7457     case R_PPC64_ADDR16_HI:
7458     case R_PPC64_ADDR16_HIGH:
7459     case R_PPC64_ADDR16_HIGHA:
7460     case R_PPC64_ADDR16_HIGHER:
7461     case R_PPC64_ADDR16_HIGHERA:
7462     case R_PPC64_ADDR16_HIGHEST:
7463     case R_PPC64_ADDR16_HIGHESTA:
7464     case R_PPC64_ADDR16_LO:
7465     case R_PPC64_ADDR16_LO_DS:
7466     case R_PPC64_ADDR24:
7467     case R_PPC64_ADDR32:
7468     case R_PPC64_UADDR16:
7469     case R_PPC64_UADDR32:
7470     case R_PPC64_UADDR64:
7471     case R_PPC64_TOC:
7472       break;
7473     }
7474
7475   if (local_syms != NULL)
7476     {
7477       unsigned long r_symndx;
7478       bfd *ibfd = sec->owner;
7479
7480       r_symndx = ELF64_R_SYM (r_info);
7481       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7482         return FALSE;
7483     }
7484
7485   if ((info->shared
7486        && (must_be_dyn_reloc (info, r_type)
7487            || (h != NULL
7488                && (!SYMBOLIC_BIND (info, h)
7489                    || h->root.type == bfd_link_hash_defweak
7490                    || !h->def_regular))))
7491       || (ELIMINATE_COPY_RELOCS
7492           && !info->shared
7493           && h != NULL
7494           && (h->root.type == bfd_link_hash_defweak
7495               || !h->def_regular)))
7496     ;
7497   else
7498     return TRUE;
7499
7500   if (h != NULL)
7501     {
7502       struct elf_dyn_relocs *p;
7503       struct elf_dyn_relocs **pp;
7504       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7505
7506       /* elf_gc_sweep may have already removed all dyn relocs associated
7507          with local syms for a given section.  Also, symbol flags are
7508          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7509          report a dynreloc miscount.  */
7510       if (*pp == NULL && info->gc_sections)
7511         return TRUE;
7512
7513       while ((p = *pp) != NULL)
7514         {
7515           if (p->sec == sec)
7516             {
7517               if (!must_be_dyn_reloc (info, r_type))
7518                 p->pc_count -= 1;
7519               p->count -= 1;
7520               if (p->count == 0)
7521                 *pp = p->next;
7522               return TRUE;
7523             }
7524           pp = &p->next;
7525         }
7526     }
7527   else
7528     {
7529       struct ppc_dyn_relocs *p;
7530       struct ppc_dyn_relocs **pp;
7531       void *vpp;
7532       bfd_boolean is_ifunc;
7533
7534       if (local_syms == NULL)
7535         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7536       if (sym_sec == NULL)
7537         sym_sec = sec;
7538
7539       vpp = &elf_section_data (sym_sec)->local_dynrel;
7540       pp = (struct ppc_dyn_relocs **) vpp;
7541
7542       if (*pp == NULL && info->gc_sections)
7543         return TRUE;
7544
7545       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7546       while ((p = *pp) != NULL)
7547         {
7548           if (p->sec == sec && p->ifunc == is_ifunc)
7549             {
7550               p->count -= 1;
7551               if (p->count == 0)
7552                 *pp = p->next;
7553               return TRUE;
7554             }
7555           pp = &p->next;
7556         }
7557     }
7558
7559   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7560                           sec->owner, sec);
7561   bfd_set_error (bfd_error_bad_value);
7562   return FALSE;
7563 }
7564
7565 /* Remove unused Official Procedure Descriptor entries.  Currently we
7566    only remove those associated with functions in discarded link-once
7567    sections, or weakly defined functions that have been overridden.  It
7568    would be possible to remove many more entries for statically linked
7569    applications.  */
7570
7571 bfd_boolean
7572 ppc64_elf_edit_opd (struct bfd_link_info *info)
7573 {
7574   bfd *ibfd;
7575   bfd_boolean some_edited = FALSE;
7576   asection *need_pad = NULL;
7577   struct ppc_link_hash_table *htab;
7578
7579   htab = ppc_hash_table (info);
7580   if (htab == NULL)
7581     return FALSE;
7582
7583   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7584     {
7585       asection *sec;
7586       Elf_Internal_Rela *relstart, *rel, *relend;
7587       Elf_Internal_Shdr *symtab_hdr;
7588       Elf_Internal_Sym *local_syms;
7589       bfd_vma offset;
7590       struct _opd_sec_data *opd;
7591       bfd_boolean need_edit, add_aux_fields;
7592       bfd_size_type cnt_16b = 0;
7593
7594       if (!is_ppc64_elf (ibfd))
7595         continue;
7596
7597       sec = bfd_get_section_by_name (ibfd, ".opd");
7598       if (sec == NULL || sec->size == 0)
7599         continue;
7600
7601       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7602         continue;
7603
7604       if (sec->output_section == bfd_abs_section_ptr)
7605         continue;
7606
7607       /* Look through the section relocs.  */
7608       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7609         continue;
7610
7611       local_syms = NULL;
7612       symtab_hdr = &elf_symtab_hdr (ibfd);
7613
7614       /* Read the relocations.  */
7615       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7616                                             info->keep_memory);
7617       if (relstart == NULL)
7618         return FALSE;
7619
7620       /* First run through the relocs to check they are sane, and to
7621          determine whether we need to edit this opd section.  */
7622       need_edit = FALSE;
7623       need_pad = sec;
7624       offset = 0;
7625       relend = relstart + sec->reloc_count;
7626       for (rel = relstart; rel < relend; )
7627         {
7628           enum elf_ppc64_reloc_type r_type;
7629           unsigned long r_symndx;
7630           asection *sym_sec;
7631           struct elf_link_hash_entry *h;
7632           Elf_Internal_Sym *sym;
7633
7634           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7635              only interested in the reloc pointing to a function entry
7636              point.  */
7637           if (rel->r_offset != offset
7638               || rel + 1 >= relend
7639               || (rel + 1)->r_offset != offset + 8)
7640             {
7641               /* If someone messes with .opd alignment then after a
7642                  "ld -r" we might have padding in the middle of .opd.
7643                  Also, there's nothing to prevent someone putting
7644                  something silly in .opd with the assembler.  No .opd
7645                  optimization for them!  */
7646             broken_opd:
7647               (*_bfd_error_handler)
7648                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7649               need_edit = FALSE;
7650               break;
7651             }
7652
7653           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7654               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7655             {
7656               (*_bfd_error_handler)
7657                 (_("%B: unexpected reloc type %u in .opd section"),
7658                  ibfd, r_type);
7659               need_edit = FALSE;
7660               break;
7661             }
7662
7663           r_symndx = ELF64_R_SYM (rel->r_info);
7664           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7665                           r_symndx, ibfd))
7666             goto error_ret;
7667
7668           if (sym_sec == NULL || sym_sec->owner == NULL)
7669             {
7670               const char *sym_name;
7671               if (h != NULL)
7672                 sym_name = h->root.root.string;
7673               else
7674                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7675                                              sym_sec);
7676
7677               (*_bfd_error_handler)
7678                 (_("%B: undefined sym `%s' in .opd section"),
7679                  ibfd, sym_name);
7680               need_edit = FALSE;
7681               break;
7682             }
7683
7684           /* opd entries are always for functions defined in the
7685              current input bfd.  If the symbol isn't defined in the
7686              input bfd, then we won't be using the function in this
7687              bfd;  It must be defined in a linkonce section in another
7688              bfd, or is weak.  It's also possible that we are
7689              discarding the function due to a linker script /DISCARD/,
7690              which we test for via the output_section.  */
7691           if (sym_sec->owner != ibfd
7692               || sym_sec->output_section == bfd_abs_section_ptr)
7693             need_edit = TRUE;
7694
7695           rel += 2;
7696           if (rel == relend
7697               || (rel + 1 == relend && rel->r_offset == offset + 16))
7698             {
7699               if (sec->size == offset + 24)
7700                 {
7701                   need_pad = NULL;
7702                   break;
7703                 }
7704               if (rel == relend && sec->size == offset + 16)
7705                 {
7706                   cnt_16b++;
7707                   break;
7708                 }
7709               goto broken_opd;
7710             }
7711
7712           if (rel->r_offset == offset + 24)
7713             offset += 24;
7714           else if (rel->r_offset != offset + 16)
7715             goto broken_opd;
7716           else if (rel + 1 < relend
7717                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7718                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7719             {
7720               offset += 16;
7721               cnt_16b++;
7722             }
7723           else if (rel + 2 < relend
7724                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7725                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7726             {
7727               offset += 24;
7728               rel += 1;
7729             }
7730           else
7731             goto broken_opd;
7732         }
7733
7734       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7735
7736       if (need_edit || add_aux_fields)
7737         {
7738           Elf_Internal_Rela *write_rel;
7739           Elf_Internal_Shdr *rel_hdr;
7740           bfd_byte *rptr, *wptr;
7741           bfd_byte *new_contents;
7742           bfd_boolean skip;
7743           long opd_ent_size;
7744           bfd_size_type amt;
7745
7746           new_contents = NULL;
7747           amt = sec->size * sizeof (long) / 8;
7748           opd = &ppc64_elf_section_data (sec)->u.opd;
7749           opd->adjust = bfd_zalloc (sec->owner, amt);
7750           if (opd->adjust == NULL)
7751             return FALSE;
7752           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7753
7754           /* This seems a waste of time as input .opd sections are all
7755              zeros as generated by gcc, but I suppose there's no reason
7756              this will always be so.  We might start putting something in
7757              the third word of .opd entries.  */
7758           if ((sec->flags & SEC_IN_MEMORY) == 0)
7759             {
7760               bfd_byte *loc;
7761               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7762                 {
7763                   if (loc != NULL)
7764                     free (loc);
7765                 error_ret:
7766                   if (local_syms != NULL
7767                       && symtab_hdr->contents != (unsigned char *) local_syms)
7768                     free (local_syms);
7769                   if (elf_section_data (sec)->relocs != relstart)
7770                     free (relstart);
7771                   return FALSE;
7772                 }
7773               sec->contents = loc;
7774               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7775             }
7776
7777           elf_section_data (sec)->relocs = relstart;
7778
7779           new_contents = sec->contents;
7780           if (add_aux_fields)
7781             {
7782               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7783               if (new_contents == NULL)
7784                 return FALSE;
7785               need_pad = FALSE;
7786             }
7787           wptr = new_contents;
7788           rptr = sec->contents;
7789
7790           write_rel = relstart;
7791           skip = FALSE;
7792           offset = 0;
7793           opd_ent_size = 0;
7794           for (rel = relstart; rel < relend; rel++)
7795             {
7796               unsigned long r_symndx;
7797               asection *sym_sec;
7798               struct elf_link_hash_entry *h;
7799               Elf_Internal_Sym *sym;
7800
7801               r_symndx = ELF64_R_SYM (rel->r_info);
7802               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7803                               r_symndx, ibfd))
7804                 goto error_ret;
7805
7806               if (rel->r_offset == offset)
7807                 {
7808                   struct ppc_link_hash_entry *fdh = NULL;
7809
7810                   /* See if the .opd entry is full 24 byte or
7811                      16 byte (with fd_aux entry overlapped with next
7812                      fd_func).  */
7813                   opd_ent_size = 24;
7814                   if ((rel + 2 == relend && sec->size == offset + 16)
7815                       || (rel + 3 < relend
7816                           && rel[2].r_offset == offset + 16
7817                           && rel[3].r_offset == offset + 24
7818                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7819                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7820                     opd_ent_size = 16;
7821
7822                   if (h != NULL
7823                       && h->root.root.string[0] == '.')
7824                     {
7825                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7826                       if (fdh != NULL
7827                           && fdh->elf.root.type != bfd_link_hash_defined
7828                           && fdh->elf.root.type != bfd_link_hash_defweak)
7829                         fdh = NULL;
7830                     }
7831
7832                   skip = (sym_sec->owner != ibfd
7833                           || sym_sec->output_section == bfd_abs_section_ptr);
7834                   if (skip)
7835                     {
7836                       if (fdh != NULL && sym_sec->owner == ibfd)
7837                         {
7838                           /* Arrange for the function descriptor sym
7839                              to be dropped.  */
7840                           fdh->elf.root.u.def.value = 0;
7841                           fdh->elf.root.u.def.section = sym_sec;
7842                         }
7843                       opd->adjust[rel->r_offset / 8] = -1;
7844                     }
7845                   else
7846                     {
7847                       /* We'll be keeping this opd entry.  */
7848
7849                       if (fdh != NULL)
7850                         {
7851                           /* Redefine the function descriptor symbol to
7852                              this location in the opd section.  It is
7853                              necessary to update the value here rather
7854                              than using an array of adjustments as we do
7855                              for local symbols, because various places
7856                              in the generic ELF code use the value
7857                              stored in u.def.value.  */
7858                           fdh->elf.root.u.def.value = wptr - new_contents;
7859                           fdh->adjust_done = 1;
7860                         }
7861
7862                       /* Local syms are a bit tricky.  We could
7863                          tweak them as they can be cached, but
7864                          we'd need to look through the local syms
7865                          for the function descriptor sym which we
7866                          don't have at the moment.  So keep an
7867                          array of adjustments.  */
7868                       opd->adjust[rel->r_offset / 8]
7869                         = (wptr - new_contents) - (rptr - sec->contents);
7870
7871                       if (wptr != rptr)
7872                         memcpy (wptr, rptr, opd_ent_size);
7873                       wptr += opd_ent_size;
7874                       if (add_aux_fields && opd_ent_size == 16)
7875                         {
7876                           memset (wptr, '\0', 8);
7877                           wptr += 8;
7878                         }
7879                     }
7880                   rptr += opd_ent_size;
7881                   offset += opd_ent_size;
7882                 }
7883
7884               if (skip)
7885                 {
7886                   if (!NO_OPD_RELOCS
7887                       && !info->relocatable
7888                       && !dec_dynrel_count (rel->r_info, sec, info,
7889                                             NULL, h, sym))
7890                     goto error_ret;
7891                 }
7892               else
7893                 {
7894                   /* We need to adjust any reloc offsets to point to the
7895                      new opd entries.  While we're at it, we may as well
7896                      remove redundant relocs.  */
7897                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7898                   if (write_rel != rel)
7899                     memcpy (write_rel, rel, sizeof (*rel));
7900                   ++write_rel;
7901                 }
7902             }
7903
7904           sec->size = wptr - new_contents;
7905           sec->reloc_count = write_rel - relstart;
7906           if (add_aux_fields)
7907             {
7908               free (sec->contents);
7909               sec->contents = new_contents;
7910             }
7911
7912           /* Fudge the header size too, as this is used later in
7913              elf_bfd_final_link if we are emitting relocs.  */
7914           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7915           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7916           some_edited = TRUE;
7917         }
7918       else if (elf_section_data (sec)->relocs != relstart)
7919         free (relstart);
7920
7921       if (local_syms != NULL
7922           && symtab_hdr->contents != (unsigned char *) local_syms)
7923         {
7924           if (!info->keep_memory)
7925             free (local_syms);
7926           else
7927             symtab_hdr->contents = (unsigned char *) local_syms;
7928         }
7929     }
7930
7931   if (some_edited)
7932     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7933
7934   /* If we are doing a final link and the last .opd entry is just 16 byte
7935      long, add a 8 byte padding after it.  */
7936   if (need_pad != NULL && !info->relocatable)
7937     {
7938       bfd_byte *p;
7939
7940       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7941         {
7942           BFD_ASSERT (need_pad->size > 0);
7943
7944           p = bfd_malloc (need_pad->size + 8);
7945           if (p == NULL)
7946             return FALSE;
7947
7948           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7949                                           p, 0, need_pad->size))
7950             return FALSE;
7951
7952           need_pad->contents = p;
7953           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7954         }
7955       else
7956         {
7957           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7958           if (p == NULL)
7959             return FALSE;
7960
7961           need_pad->contents = p;
7962         }
7963
7964       memset (need_pad->contents + need_pad->size, 0, 8);
7965       need_pad->size += 8;
7966     }
7967
7968   return TRUE;
7969 }
7970
7971 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7972
7973 asection *
7974 ppc64_elf_tls_setup (struct bfd_link_info *info)
7975 {
7976   struct ppc_link_hash_table *htab;
7977
7978   htab = ppc_hash_table (info);
7979   if (htab == NULL)
7980     return NULL;
7981
7982   if (abiversion (info->output_bfd) == 1)
7983     htab->opd_abi = 1;
7984
7985   if (htab->params->no_multi_toc)
7986     htab->do_multi_toc = 0;
7987   else if (!htab->do_multi_toc)
7988     htab->params->no_multi_toc = 1;
7989
7990   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7991                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7992                                               FALSE, FALSE, TRUE));
7993   /* Move dynamic linking info to the function descriptor sym.  */
7994   if (htab->tls_get_addr != NULL)
7995     func_desc_adjust (&htab->tls_get_addr->elf, info);
7996   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7997                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7998                                                  FALSE, FALSE, TRUE));
7999   if (!htab->params->no_tls_get_addr_opt)
8000     {
8001       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8002
8003       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8004                                   FALSE, FALSE, TRUE);
8005       if (opt != NULL)
8006         func_desc_adjust (opt, info);
8007       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8008                                      FALSE, FALSE, TRUE);
8009       if (opt_fd != NULL
8010           && (opt_fd->root.type == bfd_link_hash_defined
8011               || opt_fd->root.type == bfd_link_hash_defweak))
8012         {
8013           /* If glibc supports an optimized __tls_get_addr call stub,
8014              signalled by the presence of __tls_get_addr_opt, and we'll
8015              be calling __tls_get_addr via a plt call stub, then
8016              make __tls_get_addr point to __tls_get_addr_opt.  */
8017           tga_fd = &htab->tls_get_addr_fd->elf;
8018           if (htab->elf.dynamic_sections_created
8019               && tga_fd != NULL
8020               && (tga_fd->type == STT_FUNC
8021                   || tga_fd->needs_plt)
8022               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8023                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8024                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8025             {
8026               struct plt_entry *ent;
8027
8028               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8029                 if (ent->plt.refcount > 0)
8030                   break;
8031               if (ent != NULL)
8032                 {
8033                   tga_fd->root.type = bfd_link_hash_indirect;
8034                   tga_fd->root.u.i.link = &opt_fd->root;
8035                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8036                   if (opt_fd->dynindx != -1)
8037                     {
8038                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8039                       opt_fd->dynindx = -1;
8040                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8041                                               opt_fd->dynstr_index);
8042                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8043                         return NULL;
8044                     }
8045                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8046                   tga = &htab->tls_get_addr->elf;
8047                   if (opt != NULL && tga != NULL)
8048                     {
8049                       tga->root.type = bfd_link_hash_indirect;
8050                       tga->root.u.i.link = &opt->root;
8051                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8052                       _bfd_elf_link_hash_hide_symbol (info, opt,
8053                                                       tga->forced_local);
8054                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8055                     }
8056                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8057                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8058                   if (htab->tls_get_addr != NULL)
8059                     {
8060                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8061                       htab->tls_get_addr->is_func = 1;
8062                     }
8063                 }
8064             }
8065         }
8066       else
8067         htab->params->no_tls_get_addr_opt = TRUE;
8068     }
8069   return _bfd_elf_tls_setup (info->output_bfd, info);
8070 }
8071
8072 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8073    HASH1 or HASH2.  */
8074
8075 static bfd_boolean
8076 branch_reloc_hash_match (const bfd *ibfd,
8077                          const Elf_Internal_Rela *rel,
8078                          const struct ppc_link_hash_entry *hash1,
8079                          const struct ppc_link_hash_entry *hash2)
8080 {
8081   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8082   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8083   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8084
8085   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8086     {
8087       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8088       struct elf_link_hash_entry *h;
8089
8090       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8091       h = elf_follow_link (h);
8092       if (h == &hash1->elf || h == &hash2->elf)
8093         return TRUE;
8094     }
8095   return FALSE;
8096 }
8097
8098 /* Run through all the TLS relocs looking for optimization
8099    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8100    a preliminary section layout so that we know the TLS segment
8101    offsets.  We can't optimize earlier because some optimizations need
8102    to know the tp offset, and we need to optimize before allocating
8103    dynamic relocations.  */
8104
8105 bfd_boolean
8106 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8107 {
8108   bfd *ibfd;
8109   asection *sec;
8110   struct ppc_link_hash_table *htab;
8111   unsigned char *toc_ref;
8112   int pass;
8113
8114   if (info->relocatable || !info->executable)
8115     return TRUE;
8116
8117   htab = ppc_hash_table (info);
8118   if (htab == NULL)
8119     return FALSE;
8120
8121   /* Make two passes over the relocs.  On the first pass, mark toc
8122      entries involved with tls relocs, and check that tls relocs
8123      involved in setting up a tls_get_addr call are indeed followed by
8124      such a call.  If they are not, we can't do any tls optimization.
8125      On the second pass twiddle tls_mask flags to notify
8126      relocate_section that optimization can be done, and adjust got
8127      and plt refcounts.  */
8128   toc_ref = NULL;
8129   for (pass = 0; pass < 2; ++pass)
8130     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8131       {
8132         Elf_Internal_Sym *locsyms = NULL;
8133         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8134
8135         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8136           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8137             {
8138               Elf_Internal_Rela *relstart, *rel, *relend;
8139               bfd_boolean found_tls_get_addr_arg = 0;
8140
8141               /* Read the relocations.  */
8142               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8143                                                     info->keep_memory);
8144               if (relstart == NULL)
8145                 {
8146                   free (toc_ref);
8147                   return FALSE;
8148                 }
8149
8150               relend = relstart + sec->reloc_count;
8151               for (rel = relstart; rel < relend; rel++)
8152                 {
8153                   enum elf_ppc64_reloc_type r_type;
8154                   unsigned long r_symndx;
8155                   struct elf_link_hash_entry *h;
8156                   Elf_Internal_Sym *sym;
8157                   asection *sym_sec;
8158                   unsigned char *tls_mask;
8159                   unsigned char tls_set, tls_clear, tls_type = 0;
8160                   bfd_vma value;
8161                   bfd_boolean ok_tprel, is_local;
8162                   long toc_ref_index = 0;
8163                   int expecting_tls_get_addr = 0;
8164                   bfd_boolean ret = FALSE;
8165
8166                   r_symndx = ELF64_R_SYM (rel->r_info);
8167                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8168                                   r_symndx, ibfd))
8169                     {
8170                     err_free_rel:
8171                       if (elf_section_data (sec)->relocs != relstart)
8172                         free (relstart);
8173                       if (toc_ref != NULL)
8174                         free (toc_ref);
8175                       if (locsyms != NULL
8176                           && (elf_symtab_hdr (ibfd).contents
8177                               != (unsigned char *) locsyms))
8178                         free (locsyms);
8179                       return ret;
8180                     }
8181
8182                   if (h != NULL)
8183                     {
8184                       if (h->root.type == bfd_link_hash_defined
8185                           || h->root.type == bfd_link_hash_defweak)
8186                         value = h->root.u.def.value;
8187                       else if (h->root.type == bfd_link_hash_undefweak)
8188                         value = 0;
8189                       else
8190                         {
8191                           found_tls_get_addr_arg = 0;
8192                           continue;
8193                         }
8194                     }
8195                   else
8196                     /* Symbols referenced by TLS relocs must be of type
8197                        STT_TLS.  So no need for .opd local sym adjust.  */
8198                     value = sym->st_value;
8199
8200                   ok_tprel = FALSE;
8201                   is_local = FALSE;
8202                   if (h == NULL
8203                       || !h->def_dynamic)
8204                     {
8205                       is_local = TRUE;
8206                       if (h != NULL
8207                           && h->root.type == bfd_link_hash_undefweak)
8208                         ok_tprel = TRUE;
8209                       else
8210                         {
8211                           value += sym_sec->output_offset;
8212                           value += sym_sec->output_section->vma;
8213                           value -= htab->elf.tls_sec->vma;
8214                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8215                                       < (bfd_vma) 1 << 32);
8216                         }
8217                     }
8218
8219                   r_type = ELF64_R_TYPE (rel->r_info);
8220                   /* If this section has old-style __tls_get_addr calls
8221                      without marker relocs, then check that each
8222                      __tls_get_addr call reloc is preceded by a reloc
8223                      that conceivably belongs to the __tls_get_addr arg
8224                      setup insn.  If we don't find matching arg setup
8225                      relocs, don't do any tls optimization.  */
8226                   if (pass == 0
8227                       && sec->has_tls_get_addr_call
8228                       && h != NULL
8229                       && (h == &htab->tls_get_addr->elf
8230                           || h == &htab->tls_get_addr_fd->elf)
8231                       && !found_tls_get_addr_arg
8232                       && is_branch_reloc (r_type))
8233                     {
8234                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8235                                                 "TLS optimization disabled\n"),
8236                                               ibfd, sec, rel->r_offset);
8237                       ret = TRUE;
8238                       goto err_free_rel;
8239                     }
8240
8241                   found_tls_get_addr_arg = 0;
8242                   switch (r_type)
8243                     {
8244                     case R_PPC64_GOT_TLSLD16:
8245                     case R_PPC64_GOT_TLSLD16_LO:
8246                       expecting_tls_get_addr = 1;
8247                       found_tls_get_addr_arg = 1;
8248                       /* Fall thru */
8249
8250                     case R_PPC64_GOT_TLSLD16_HI:
8251                     case R_PPC64_GOT_TLSLD16_HA:
8252                       /* These relocs should never be against a symbol
8253                          defined in a shared lib.  Leave them alone if
8254                          that turns out to be the case.  */
8255                       if (!is_local)
8256                         continue;
8257
8258                       /* LD -> LE */
8259                       tls_set = 0;
8260                       tls_clear = TLS_LD;
8261                       tls_type = TLS_TLS | TLS_LD;
8262                       break;
8263
8264                     case R_PPC64_GOT_TLSGD16:
8265                     case R_PPC64_GOT_TLSGD16_LO:
8266                       expecting_tls_get_addr = 1;
8267                       found_tls_get_addr_arg = 1;
8268                       /* Fall thru */
8269
8270                     case R_PPC64_GOT_TLSGD16_HI:
8271                     case R_PPC64_GOT_TLSGD16_HA:
8272                       if (ok_tprel)
8273                         /* GD -> LE */
8274                         tls_set = 0;
8275                       else
8276                         /* GD -> IE */
8277                         tls_set = TLS_TLS | TLS_TPRELGD;
8278                       tls_clear = TLS_GD;
8279                       tls_type = TLS_TLS | TLS_GD;
8280                       break;
8281
8282                     case R_PPC64_GOT_TPREL16_DS:
8283                     case R_PPC64_GOT_TPREL16_LO_DS:
8284                     case R_PPC64_GOT_TPREL16_HI:
8285                     case R_PPC64_GOT_TPREL16_HA:
8286                       if (ok_tprel)
8287                         {
8288                           /* IE -> LE */
8289                           tls_set = 0;
8290                           tls_clear = TLS_TPREL;
8291                           tls_type = TLS_TLS | TLS_TPREL;
8292                           break;
8293                         }
8294                       continue;
8295
8296                     case R_PPC64_TLSGD:
8297                     case R_PPC64_TLSLD:
8298                       found_tls_get_addr_arg = 1;
8299                       /* Fall thru */
8300
8301                     case R_PPC64_TLS:
8302                     case R_PPC64_TOC16:
8303                     case R_PPC64_TOC16_LO:
8304                       if (sym_sec == NULL || sym_sec != toc)
8305                         continue;
8306
8307                       /* Mark this toc entry as referenced by a TLS
8308                          code sequence.  We can do that now in the
8309                          case of R_PPC64_TLS, and after checking for
8310                          tls_get_addr for the TOC16 relocs.  */
8311                       if (toc_ref == NULL)
8312                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8313                       if (toc_ref == NULL)
8314                         goto err_free_rel;
8315
8316                       if (h != NULL)
8317                         value = h->root.u.def.value;
8318                       else
8319                         value = sym->st_value;
8320                       value += rel->r_addend;
8321                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8322                       toc_ref_index = (value + toc->output_offset) / 8;
8323                       if (r_type == R_PPC64_TLS
8324                           || r_type == R_PPC64_TLSGD
8325                           || r_type == R_PPC64_TLSLD)
8326                         {
8327                           toc_ref[toc_ref_index] = 1;
8328                           continue;
8329                         }
8330
8331                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8332                         continue;
8333
8334                       tls_set = 0;
8335                       tls_clear = 0;
8336                       expecting_tls_get_addr = 2;
8337                       break;
8338
8339                     case R_PPC64_TPREL64:
8340                       if (pass == 0
8341                           || sec != toc
8342                           || toc_ref == NULL
8343                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8344                         continue;
8345                       if (ok_tprel)
8346                         {
8347                           /* IE -> LE */
8348                           tls_set = TLS_EXPLICIT;
8349                           tls_clear = TLS_TPREL;
8350                           break;
8351                         }
8352                       continue;
8353
8354                     case R_PPC64_DTPMOD64:
8355                       if (pass == 0
8356                           || sec != toc
8357                           || toc_ref == NULL
8358                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8359                         continue;
8360                       if (rel + 1 < relend
8361                           && (rel[1].r_info
8362                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8363                           && rel[1].r_offset == rel->r_offset + 8)
8364                         {
8365                           if (ok_tprel)
8366                             /* GD -> LE */
8367                             tls_set = TLS_EXPLICIT | TLS_GD;
8368                           else
8369                             /* GD -> IE */
8370                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8371                           tls_clear = TLS_GD;
8372                         }
8373                       else
8374                         {
8375                           if (!is_local)
8376                             continue;
8377
8378                           /* LD -> LE */
8379                           tls_set = TLS_EXPLICIT;
8380                           tls_clear = TLS_LD;
8381                         }
8382                       break;
8383
8384                     default:
8385                       continue;
8386                     }
8387
8388                   if (pass == 0)
8389                     {
8390                       if (!expecting_tls_get_addr
8391                           || !sec->has_tls_get_addr_call)
8392                         continue;
8393
8394                       if (rel + 1 < relend
8395                           && branch_reloc_hash_match (ibfd, rel + 1,
8396                                                       htab->tls_get_addr,
8397                                                       htab->tls_get_addr_fd))
8398                         {
8399                           if (expecting_tls_get_addr == 2)
8400                             {
8401                               /* Check for toc tls entries.  */
8402                               unsigned char *toc_tls;
8403                               int retval;
8404
8405                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8406                                                      &locsyms,
8407                                                      rel, ibfd);
8408                               if (retval == 0)
8409                                 goto err_free_rel;
8410                               if (toc_tls != NULL)
8411                                 {
8412                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8413                                     found_tls_get_addr_arg = 1;
8414                                   if (retval > 1)
8415                                     toc_ref[toc_ref_index] = 1;
8416                                 }
8417                             }
8418                           continue;
8419                         }
8420
8421                       if (expecting_tls_get_addr != 1)
8422                         continue;
8423
8424                       /* Uh oh, we didn't find the expected call.  We
8425                          could just mark this symbol to exclude it
8426                          from tls optimization but it's safer to skip
8427                          the entire optimization.  */
8428                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8429                                                 "TLS optimization disabled\n"),
8430                                               ibfd, sec, rel->r_offset);
8431                       ret = TRUE;
8432                       goto err_free_rel;
8433                     }
8434
8435                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8436                     {
8437                       struct plt_entry *ent;
8438                       for (ent = htab->tls_get_addr->elf.plt.plist;
8439                            ent != NULL;
8440                            ent = ent->next)
8441                         if (ent->addend == 0)
8442                           {
8443                             if (ent->plt.refcount > 0)
8444                               {
8445                                 ent->plt.refcount -= 1;
8446                                 expecting_tls_get_addr = 0;
8447                               }
8448                             break;
8449                           }
8450                     }
8451
8452                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8453                     {
8454                       struct plt_entry *ent;
8455                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8456                            ent != NULL;
8457                            ent = ent->next)
8458                         if (ent->addend == 0)
8459                           {
8460                             if (ent->plt.refcount > 0)
8461                               ent->plt.refcount -= 1;
8462                             break;
8463                           }
8464                     }
8465
8466                   if (tls_clear == 0)
8467                     continue;
8468
8469                   if ((tls_set & TLS_EXPLICIT) == 0)
8470                     {
8471                       struct got_entry *ent;
8472
8473                       /* Adjust got entry for this reloc.  */
8474                       if (h != NULL)
8475                         ent = h->got.glist;
8476                       else
8477                         ent = elf_local_got_ents (ibfd)[r_symndx];
8478
8479                       for (; ent != NULL; ent = ent->next)
8480                         if (ent->addend == rel->r_addend
8481                             && ent->owner == ibfd
8482                             && ent->tls_type == tls_type)
8483                           break;
8484                       if (ent == NULL)
8485                         abort ();
8486
8487                       if (tls_set == 0)
8488                         {
8489                           /* We managed to get rid of a got entry.  */
8490                           if (ent->got.refcount > 0)
8491                             ent->got.refcount -= 1;
8492                         }
8493                     }
8494                   else
8495                     {
8496                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8497                          we'll lose one or two dyn relocs.  */
8498                       if (!dec_dynrel_count (rel->r_info, sec, info,
8499                                              NULL, h, sym))
8500                         return FALSE;
8501
8502                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8503                         {
8504                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8505                                                  NULL, h, sym))
8506                             return FALSE;
8507                         }
8508                     }
8509
8510                   *tls_mask |= tls_set;
8511                   *tls_mask &= ~tls_clear;
8512                 }
8513
8514               if (elf_section_data (sec)->relocs != relstart)
8515                 free (relstart);
8516             }
8517
8518         if (locsyms != NULL
8519             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8520           {
8521             if (!info->keep_memory)
8522               free (locsyms);
8523             else
8524               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8525           }
8526       }
8527
8528   if (toc_ref != NULL)
8529     free (toc_ref);
8530   return TRUE;
8531 }
8532
8533 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8534    the values of any global symbols in a toc section that has been
8535    edited.  Globals in toc sections should be a rarity, so this function
8536    sets a flag if any are found in toc sections other than the one just
8537    edited, so that futher hash table traversals can be avoided.  */
8538
8539 struct adjust_toc_info
8540 {
8541   asection *toc;
8542   unsigned long *skip;
8543   bfd_boolean global_toc_syms;
8544 };
8545
8546 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8547
8548 static bfd_boolean
8549 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8550 {
8551   struct ppc_link_hash_entry *eh;
8552   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8553   unsigned long i;
8554
8555   if (h->root.type != bfd_link_hash_defined
8556       && h->root.type != bfd_link_hash_defweak)
8557     return TRUE;
8558
8559   eh = (struct ppc_link_hash_entry *) h;
8560   if (eh->adjust_done)
8561     return TRUE;
8562
8563   if (eh->elf.root.u.def.section == toc_inf->toc)
8564     {
8565       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8566         i = toc_inf->toc->rawsize >> 3;
8567       else
8568         i = eh->elf.root.u.def.value >> 3;
8569
8570       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8571         {
8572           (*_bfd_error_handler)
8573             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8574           do
8575             ++i;
8576           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8577           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8578         }
8579
8580       eh->elf.root.u.def.value -= toc_inf->skip[i];
8581       eh->adjust_done = 1;
8582     }
8583   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8584     toc_inf->global_toc_syms = TRUE;
8585
8586   return TRUE;
8587 }
8588
8589 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8590
8591 static bfd_boolean
8592 ok_lo_toc_insn (unsigned int insn)
8593 {
8594   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8595           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8596           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8597           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8598           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8599           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8600           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8601           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8602           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8603           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8604           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8605           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8606           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8607           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8608           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8609               && (insn & 3) != 1)
8610           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8611               && ((insn & 3) == 0 || (insn & 3) == 3))
8612           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8613 }
8614
8615 /* Examine all relocs referencing .toc sections in order to remove
8616    unused .toc entries.  */
8617
8618 bfd_boolean
8619 ppc64_elf_edit_toc (struct bfd_link_info *info)
8620 {
8621   bfd *ibfd;
8622   struct adjust_toc_info toc_inf;
8623   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8624
8625   htab->do_toc_opt = 1;
8626   toc_inf.global_toc_syms = TRUE;
8627   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8628     {
8629       asection *toc, *sec;
8630       Elf_Internal_Shdr *symtab_hdr;
8631       Elf_Internal_Sym *local_syms;
8632       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8633       unsigned long *skip, *drop;
8634       unsigned char *used;
8635       unsigned char *keep, last, some_unused;
8636
8637       if (!is_ppc64_elf (ibfd))
8638         continue;
8639
8640       toc = bfd_get_section_by_name (ibfd, ".toc");
8641       if (toc == NULL
8642           || toc->size == 0
8643           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8644           || discarded_section (toc))
8645         continue;
8646
8647       toc_relocs = NULL;
8648       local_syms = NULL;
8649       symtab_hdr = &elf_symtab_hdr (ibfd);
8650
8651       /* Look at sections dropped from the final link.  */
8652       skip = NULL;
8653       relstart = NULL;
8654       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8655         {
8656           if (sec->reloc_count == 0
8657               || !discarded_section (sec)
8658               || get_opd_info (sec)
8659               || (sec->flags & SEC_ALLOC) == 0
8660               || (sec->flags & SEC_DEBUGGING) != 0)
8661             continue;
8662
8663           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8664           if (relstart == NULL)
8665             goto error_ret;
8666
8667           /* Run through the relocs to see which toc entries might be
8668              unused.  */
8669           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8670             {
8671               enum elf_ppc64_reloc_type r_type;
8672               unsigned long r_symndx;
8673               asection *sym_sec;
8674               struct elf_link_hash_entry *h;
8675               Elf_Internal_Sym *sym;
8676               bfd_vma val;
8677
8678               r_type = ELF64_R_TYPE (rel->r_info);
8679               switch (r_type)
8680                 {
8681                 default:
8682                   continue;
8683
8684                 case R_PPC64_TOC16:
8685                 case R_PPC64_TOC16_LO:
8686                 case R_PPC64_TOC16_HI:
8687                 case R_PPC64_TOC16_HA:
8688                 case R_PPC64_TOC16_DS:
8689                 case R_PPC64_TOC16_LO_DS:
8690                   break;
8691                 }
8692
8693               r_symndx = ELF64_R_SYM (rel->r_info);
8694               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8695                               r_symndx, ibfd))
8696                 goto error_ret;
8697
8698               if (sym_sec != toc)
8699                 continue;
8700
8701               if (h != NULL)
8702                 val = h->root.u.def.value;
8703               else
8704                 val = sym->st_value;
8705               val += rel->r_addend;
8706
8707               if (val >= toc->size)
8708                 continue;
8709
8710               /* Anything in the toc ought to be aligned to 8 bytes.
8711                  If not, don't mark as unused.  */
8712               if (val & 7)
8713                 continue;
8714
8715               if (skip == NULL)
8716                 {
8717                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8718                   if (skip == NULL)
8719                     goto error_ret;
8720                 }
8721
8722               skip[val >> 3] = ref_from_discarded;
8723             }
8724
8725           if (elf_section_data (sec)->relocs != relstart)
8726             free (relstart);
8727         }
8728
8729       /* For largetoc loads of address constants, we can convert
8730          .  addis rx,2,addr@got@ha
8731          .  ld ry,addr@got@l(rx)
8732          to
8733          .  addis rx,2,addr@toc@ha
8734          .  addi ry,rx,addr@toc@l
8735          when addr is within 2G of the toc pointer.  This then means
8736          that the word storing "addr" in the toc is no longer needed.  */
8737
8738       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8739           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8740           && toc->reloc_count != 0)
8741         {
8742           /* Read toc relocs.  */
8743           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8744                                                   info->keep_memory);
8745           if (toc_relocs == NULL)
8746             goto error_ret;
8747
8748           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8749             {
8750               enum elf_ppc64_reloc_type r_type;
8751               unsigned long r_symndx;
8752               asection *sym_sec;
8753               struct elf_link_hash_entry *h;
8754               Elf_Internal_Sym *sym;
8755               bfd_vma val, addr;
8756
8757               r_type = ELF64_R_TYPE (rel->r_info);
8758               if (r_type != R_PPC64_ADDR64)
8759                 continue;
8760
8761               r_symndx = ELF64_R_SYM (rel->r_info);
8762               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8763                               r_symndx, ibfd))
8764                 goto error_ret;
8765
8766               if (sym_sec == NULL
8767                   || discarded_section (sym_sec))
8768                 continue;
8769
8770               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8771                 continue;
8772
8773               if (h != NULL)
8774                 {
8775                   if (h->type == STT_GNU_IFUNC)
8776                     continue;
8777                   val = h->root.u.def.value;
8778                 }
8779               else
8780                 {
8781                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8782                     continue;
8783                   val = sym->st_value;
8784                 }
8785               val += rel->r_addend;
8786               val += sym_sec->output_section->vma + sym_sec->output_offset;
8787
8788               /* We don't yet know the exact toc pointer value, but we
8789                  know it will be somewhere in the toc section.  Don't
8790                  optimize if the difference from any possible toc
8791                  pointer is outside [ff..f80008000, 7fff7fff].  */
8792               addr = toc->output_section->vma + TOC_BASE_OFF;
8793               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8794                 continue;
8795
8796               addr = toc->output_section->vma + toc->output_section->rawsize;
8797               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8798                 continue;
8799
8800               if (skip == NULL)
8801                 {
8802                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8803                   if (skip == NULL)
8804                     goto error_ret;
8805                 }
8806
8807               skip[rel->r_offset >> 3]
8808                 |= can_optimize | ((rel - toc_relocs) << 2);
8809             }
8810         }
8811
8812       if (skip == NULL)
8813         continue;
8814
8815       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8816       if (used == NULL)
8817         {
8818         error_ret:
8819           if (local_syms != NULL
8820               && symtab_hdr->contents != (unsigned char *) local_syms)
8821             free (local_syms);
8822           if (sec != NULL
8823               && relstart != NULL
8824               && elf_section_data (sec)->relocs != relstart)
8825             free (relstart);
8826           if (toc_relocs != NULL
8827               && elf_section_data (toc)->relocs != toc_relocs)
8828             free (toc_relocs);
8829           if (skip != NULL)
8830             free (skip);
8831           return FALSE;
8832         }
8833
8834       /* Now check all kept sections that might reference the toc.
8835          Check the toc itself last.  */
8836       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8837                   : ibfd->sections);
8838            sec != NULL;
8839            sec = (sec == toc ? NULL
8840                   : sec->next == NULL ? toc
8841                   : sec->next == toc && toc->next ? toc->next
8842                   : sec->next))
8843         {
8844           int repeat;
8845
8846           if (sec->reloc_count == 0
8847               || discarded_section (sec)
8848               || get_opd_info (sec)
8849               || (sec->flags & SEC_ALLOC) == 0
8850               || (sec->flags & SEC_DEBUGGING) != 0)
8851             continue;
8852
8853           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8854                                                 info->keep_memory);
8855           if (relstart == NULL)
8856             {
8857               free (used);
8858               goto error_ret;
8859             }
8860
8861           /* Mark toc entries referenced as used.  */
8862           do
8863             {
8864               repeat = 0;
8865               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8866                 {
8867                   enum elf_ppc64_reloc_type r_type;
8868                   unsigned long r_symndx;
8869                   asection *sym_sec;
8870                   struct elf_link_hash_entry *h;
8871                   Elf_Internal_Sym *sym;
8872                   bfd_vma val;
8873                   enum {no_check, check_lo, check_ha} insn_check;
8874
8875                   r_type = ELF64_R_TYPE (rel->r_info);
8876                   switch (r_type)
8877                     {
8878                     default:
8879                       insn_check = no_check;
8880                       break;
8881
8882                     case R_PPC64_GOT_TLSLD16_HA:
8883                     case R_PPC64_GOT_TLSGD16_HA:
8884                     case R_PPC64_GOT_TPREL16_HA:
8885                     case R_PPC64_GOT_DTPREL16_HA:
8886                     case R_PPC64_GOT16_HA:
8887                     case R_PPC64_TOC16_HA:
8888                       insn_check = check_ha;
8889                       break;
8890
8891                     case R_PPC64_GOT_TLSLD16_LO:
8892                     case R_PPC64_GOT_TLSGD16_LO:
8893                     case R_PPC64_GOT_TPREL16_LO_DS:
8894                     case R_PPC64_GOT_DTPREL16_LO_DS:
8895                     case R_PPC64_GOT16_LO:
8896                     case R_PPC64_GOT16_LO_DS:
8897                     case R_PPC64_TOC16_LO:
8898                     case R_PPC64_TOC16_LO_DS:
8899                       insn_check = check_lo;
8900                       break;
8901                     }
8902
8903                   if (insn_check != no_check)
8904                     {
8905                       bfd_vma off = rel->r_offset & ~3;
8906                       unsigned char buf[4];
8907                       unsigned int insn;
8908
8909                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8910                         {
8911                           free (used);
8912                           goto error_ret;
8913                         }
8914                       insn = bfd_get_32 (ibfd, buf);
8915                       if (insn_check == check_lo
8916                           ? !ok_lo_toc_insn (insn)
8917                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8918                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8919                         {
8920                           char str[12];
8921
8922                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8923                           sprintf (str, "%#08x", insn);
8924                           info->callbacks->einfo
8925                             (_("%P: %H: toc optimization is not supported for"
8926                                " %s instruction.\n"),
8927                              ibfd, sec, rel->r_offset & ~3, str);
8928                         }
8929                     }
8930
8931                   switch (r_type)
8932                     {
8933                     case R_PPC64_TOC16:
8934                     case R_PPC64_TOC16_LO:
8935                     case R_PPC64_TOC16_HI:
8936                     case R_PPC64_TOC16_HA:
8937                     case R_PPC64_TOC16_DS:
8938                     case R_PPC64_TOC16_LO_DS:
8939                       /* In case we're taking addresses of toc entries.  */
8940                     case R_PPC64_ADDR64:
8941                       break;
8942
8943                     default:
8944                       continue;
8945                     }
8946
8947                   r_symndx = ELF64_R_SYM (rel->r_info);
8948                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8949                                   r_symndx, ibfd))
8950                     {
8951                       free (used);
8952                       goto error_ret;
8953                     }
8954
8955                   if (sym_sec != toc)
8956                     continue;
8957
8958                   if (h != NULL)
8959                     val = h->root.u.def.value;
8960                   else
8961                     val = sym->st_value;
8962                   val += rel->r_addend;
8963
8964                   if (val >= toc->size)
8965                     continue;
8966
8967                   if ((skip[val >> 3] & can_optimize) != 0)
8968                     {
8969                       bfd_vma off;
8970                       unsigned char opc;
8971
8972                       switch (r_type)
8973                         {
8974                         case R_PPC64_TOC16_HA:
8975                           break;
8976
8977                         case R_PPC64_TOC16_LO_DS:
8978                           off = rel->r_offset;
8979                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8980                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8981                                                          off, 1))
8982                             {
8983                               free (used);
8984                               goto error_ret;
8985                             }
8986                           if ((opc & (0x3f << 2)) == (58u << 2))
8987                             break;
8988                           /* Fall thru */
8989
8990                         default:
8991                           /* Wrong sort of reloc, or not a ld.  We may
8992                              as well clear ref_from_discarded too.  */
8993                           skip[val >> 3] = 0;
8994                         }
8995                     }
8996
8997                   if (sec != toc)
8998                     used[val >> 3] = 1;
8999                   /* For the toc section, we only mark as used if this
9000                      entry itself isn't unused.  */
9001                   else if ((used[rel->r_offset >> 3]
9002                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9003                            && !used[val >> 3])
9004                     {
9005                       /* Do all the relocs again, to catch reference
9006                          chains.  */
9007                       repeat = 1;
9008                       used[val >> 3] = 1;
9009                     }
9010                 }
9011             }
9012           while (repeat);
9013
9014           if (elf_section_data (sec)->relocs != relstart)
9015             free (relstart);
9016         }
9017
9018       /* Merge the used and skip arrays.  Assume that TOC
9019          doublewords not appearing as either used or unused belong
9020          to to an entry more than one doubleword in size.  */
9021       for (drop = skip, keep = used, last = 0, some_unused = 0;
9022            drop < skip + (toc->size + 7) / 8;
9023            ++drop, ++keep)
9024         {
9025           if (*keep)
9026             {
9027               *drop &= ~ref_from_discarded;
9028               if ((*drop & can_optimize) != 0)
9029                 some_unused = 1;
9030               last = 0;
9031             }
9032           else if ((*drop & ref_from_discarded) != 0)
9033             {
9034               some_unused = 1;
9035               last = ref_from_discarded;
9036             }
9037           else
9038             *drop = last;
9039         }
9040
9041       free (used);
9042
9043       if (some_unused)
9044         {
9045           bfd_byte *contents, *src;
9046           unsigned long off;
9047           Elf_Internal_Sym *sym;
9048           bfd_boolean local_toc_syms = FALSE;
9049
9050           /* Shuffle the toc contents, and at the same time convert the
9051              skip array from booleans into offsets.  */
9052           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9053             goto error_ret;
9054
9055           elf_section_data (toc)->this_hdr.contents = contents;
9056
9057           for (src = contents, off = 0, drop = skip;
9058                src < contents + toc->size;
9059                src += 8, ++drop)
9060             {
9061               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9062                 off += 8;
9063               else if (off != 0)
9064                 {
9065                   *drop = off;
9066                   memcpy (src - off, src, 8);
9067                 }
9068             }
9069           *drop = off;
9070           toc->rawsize = toc->size;
9071           toc->size = src - contents - off;
9072
9073           /* Adjust addends for relocs against the toc section sym,
9074              and optimize any accesses we can.  */
9075           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9076             {
9077               if (sec->reloc_count == 0
9078                   || discarded_section (sec))
9079                 continue;
9080
9081               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9082                                                     info->keep_memory);
9083               if (relstart == NULL)
9084                 goto error_ret;
9085
9086               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9087                 {
9088                   enum elf_ppc64_reloc_type r_type;
9089                   unsigned long r_symndx;
9090                   asection *sym_sec;
9091                   struct elf_link_hash_entry *h;
9092                   bfd_vma val;
9093
9094                   r_type = ELF64_R_TYPE (rel->r_info);
9095                   switch (r_type)
9096                     {
9097                     default:
9098                       continue;
9099
9100                     case R_PPC64_TOC16:
9101                     case R_PPC64_TOC16_LO:
9102                     case R_PPC64_TOC16_HI:
9103                     case R_PPC64_TOC16_HA:
9104                     case R_PPC64_TOC16_DS:
9105                     case R_PPC64_TOC16_LO_DS:
9106                     case R_PPC64_ADDR64:
9107                       break;
9108                     }
9109
9110                   r_symndx = ELF64_R_SYM (rel->r_info);
9111                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9112                                   r_symndx, ibfd))
9113                     goto error_ret;
9114
9115                   if (sym_sec != toc)
9116                     continue;
9117
9118                   if (h != NULL)
9119                     val = h->root.u.def.value;
9120                   else
9121                     {
9122                       val = sym->st_value;
9123                       if (val != 0)
9124                         local_toc_syms = TRUE;
9125                     }
9126
9127                   val += rel->r_addend;
9128
9129                   if (val > toc->rawsize)
9130                     val = toc->rawsize;
9131                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9132                     continue;
9133                   else if ((skip[val >> 3] & can_optimize) != 0)
9134                     {
9135                       Elf_Internal_Rela *tocrel
9136                         = toc_relocs + (skip[val >> 3] >> 2);
9137                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9138
9139                       switch (r_type)
9140                         {
9141                         case R_PPC64_TOC16_HA:
9142                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9143                           break;
9144
9145                         case R_PPC64_TOC16_LO_DS:
9146                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9147                           break;
9148
9149                         default:
9150                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9151                             ppc_howto_init ();
9152                           info->callbacks->einfo
9153                             (_("%P: %H: %s references "
9154                                "optimized away TOC entry\n"),
9155                              ibfd, sec, rel->r_offset,
9156                              ppc64_elf_howto_table[r_type]->name);
9157                           bfd_set_error (bfd_error_bad_value);
9158                           goto error_ret;
9159                         }
9160                       rel->r_addend = tocrel->r_addend;
9161                       elf_section_data (sec)->relocs = relstart;
9162                       continue;
9163                     }
9164
9165                   if (h != NULL || sym->st_value != 0)
9166                     continue;
9167
9168                   rel->r_addend -= skip[val >> 3];
9169                   elf_section_data (sec)->relocs = relstart;
9170                 }
9171
9172               if (elf_section_data (sec)->relocs != relstart)
9173                 free (relstart);
9174             }
9175
9176           /* We shouldn't have local or global symbols defined in the TOC,
9177              but handle them anyway.  */
9178           if (local_syms != NULL)
9179             for (sym = local_syms;
9180                  sym < local_syms + symtab_hdr->sh_info;
9181                  ++sym)
9182               if (sym->st_value != 0
9183                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9184                 {
9185                   unsigned long i;
9186
9187                   if (sym->st_value > toc->rawsize)
9188                     i = toc->rawsize >> 3;
9189                   else
9190                     i = sym->st_value >> 3;
9191
9192                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9193                     {
9194                       if (local_toc_syms)
9195                         (*_bfd_error_handler)
9196                           (_("%s defined on removed toc entry"),
9197                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9198                       do
9199                         ++i;
9200                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9201                       sym->st_value = (bfd_vma) i << 3;
9202                     }
9203
9204                   sym->st_value -= skip[i];
9205                   symtab_hdr->contents = (unsigned char *) local_syms;
9206                 }
9207
9208           /* Adjust any global syms defined in this toc input section.  */
9209           if (toc_inf.global_toc_syms)
9210             {
9211               toc_inf.toc = toc;
9212               toc_inf.skip = skip;
9213               toc_inf.global_toc_syms = FALSE;
9214               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9215                                       &toc_inf);
9216             }
9217
9218           if (toc->reloc_count != 0)
9219             {
9220               Elf_Internal_Shdr *rel_hdr;
9221               Elf_Internal_Rela *wrel;
9222               bfd_size_type sz;
9223
9224               /* Remove unused toc relocs, and adjust those we keep.  */
9225               if (toc_relocs == NULL)
9226                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9227                                                         info->keep_memory);
9228               if (toc_relocs == NULL)
9229                 goto error_ret;
9230
9231               wrel = toc_relocs;
9232               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9233                 if ((skip[rel->r_offset >> 3]
9234                      & (ref_from_discarded | can_optimize)) == 0)
9235                   {
9236                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9237                     wrel->r_info = rel->r_info;
9238                     wrel->r_addend = rel->r_addend;
9239                     ++wrel;
9240                   }
9241                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9242                                             &local_syms, NULL, NULL))
9243                   goto error_ret;
9244
9245               elf_section_data (toc)->relocs = toc_relocs;
9246               toc->reloc_count = wrel - toc_relocs;
9247               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9248               sz = rel_hdr->sh_entsize;
9249               rel_hdr->sh_size = toc->reloc_count * sz;
9250             }
9251         }
9252       else if (toc_relocs != NULL
9253                && elf_section_data (toc)->relocs != toc_relocs)
9254         free (toc_relocs);
9255
9256       if (local_syms != NULL
9257           && symtab_hdr->contents != (unsigned char *) local_syms)
9258         {
9259           if (!info->keep_memory)
9260             free (local_syms);
9261           else
9262             symtab_hdr->contents = (unsigned char *) local_syms;
9263         }
9264       free (skip);
9265     }
9266
9267   return TRUE;
9268 }
9269
9270 /* Return true iff input section I references the TOC using
9271    instructions limited to +/-32k offsets.  */
9272
9273 bfd_boolean
9274 ppc64_elf_has_small_toc_reloc (asection *i)
9275 {
9276   return (is_ppc64_elf (i->owner)
9277           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9278 }
9279
9280 /* Allocate space for one GOT entry.  */
9281
9282 static void
9283 allocate_got (struct elf_link_hash_entry *h,
9284               struct bfd_link_info *info,
9285               struct got_entry *gent)
9286 {
9287   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9288   bfd_boolean dyn;
9289   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9290   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9291                  ? 16 : 8);
9292   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9293                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9294   asection *got = ppc64_elf_tdata (gent->owner)->got;
9295
9296   gent->got.offset = got->size;
9297   got->size += entsize;
9298
9299   dyn = htab->elf.dynamic_sections_created;
9300   if (h->type == STT_GNU_IFUNC)
9301     {
9302       htab->elf.irelplt->size += rentsize;
9303       htab->got_reli_size += rentsize;
9304     }
9305   else if ((info->shared
9306             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9307            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9308                || h->root.type != bfd_link_hash_undefweak))
9309     {
9310       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9311       relgot->size += rentsize;
9312     }
9313 }
9314
9315 /* This function merges got entries in the same toc group.  */
9316
9317 static void
9318 merge_got_entries (struct got_entry **pent)
9319 {
9320   struct got_entry *ent, *ent2;
9321
9322   for (ent = *pent; ent != NULL; ent = ent->next)
9323     if (!ent->is_indirect)
9324       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9325         if (!ent2->is_indirect
9326             && ent2->addend == ent->addend
9327             && ent2->tls_type == ent->tls_type
9328             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9329           {
9330             ent2->is_indirect = TRUE;
9331             ent2->got.ent = ent;
9332           }
9333 }
9334
9335 /* Allocate space in .plt, .got and associated reloc sections for
9336    dynamic relocs.  */
9337
9338 static bfd_boolean
9339 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9340 {
9341   struct bfd_link_info *info;
9342   struct ppc_link_hash_table *htab;
9343   asection *s;
9344   struct ppc_link_hash_entry *eh;
9345   struct elf_dyn_relocs *p;
9346   struct got_entry **pgent, *gent;
9347
9348   if (h->root.type == bfd_link_hash_indirect)
9349     return TRUE;
9350
9351   info = (struct bfd_link_info *) inf;
9352   htab = ppc_hash_table (info);
9353   if (htab == NULL)
9354     return FALSE;
9355
9356   if ((htab->elf.dynamic_sections_created
9357        && h->dynindx != -1
9358        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9359       || h->type == STT_GNU_IFUNC)
9360     {
9361       struct plt_entry *pent;
9362       bfd_boolean doneone = FALSE;
9363       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9364         if (pent->plt.refcount > 0)
9365           {
9366             if (!htab->elf.dynamic_sections_created
9367                 || h->dynindx == -1)
9368               {
9369                 s = htab->elf.iplt;
9370                 pent->plt.offset = s->size;
9371                 s->size += PLT_ENTRY_SIZE (htab);
9372                 s = htab->elf.irelplt;
9373               }
9374             else
9375               {
9376                 /* If this is the first .plt entry, make room for the special
9377                    first entry.  */
9378                 s = htab->elf.splt;
9379                 if (s->size == 0)
9380                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9381
9382                 pent->plt.offset = s->size;
9383
9384                 /* Make room for this entry.  */
9385                 s->size += PLT_ENTRY_SIZE (htab);
9386
9387                 /* Make room for the .glink code.  */
9388                 s = htab->glink;
9389                 if (s->size == 0)
9390                   s->size += GLINK_CALL_STUB_SIZE;
9391                 if (htab->opd_abi)
9392                   {
9393                     /* We need bigger stubs past index 32767.  */
9394                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9395                       s->size += 4;
9396                     s->size += 2*4;
9397                   }
9398                 else
9399                   s->size += 4;
9400
9401                 /* We also need to make an entry in the .rela.plt section.  */
9402                 s = htab->elf.srelplt;
9403               }
9404             s->size += sizeof (Elf64_External_Rela);
9405             doneone = TRUE;
9406           }
9407         else
9408           pent->plt.offset = (bfd_vma) -1;
9409       if (!doneone)
9410         {
9411           h->plt.plist = NULL;
9412           h->needs_plt = 0;
9413         }
9414     }
9415   else
9416     {
9417       h->plt.plist = NULL;
9418       h->needs_plt = 0;
9419     }
9420
9421   eh = (struct ppc_link_hash_entry *) h;
9422   /* Run through the TLS GD got entries first if we're changing them
9423      to TPREL.  */
9424   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9425     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9426       if (gent->got.refcount > 0
9427           && (gent->tls_type & TLS_GD) != 0)
9428         {
9429           /* This was a GD entry that has been converted to TPREL.  If
9430              there happens to be a TPREL entry we can use that one.  */
9431           struct got_entry *ent;
9432           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9433             if (ent->got.refcount > 0
9434                 && (ent->tls_type & TLS_TPREL) != 0
9435                 && ent->addend == gent->addend
9436                 && ent->owner == gent->owner)
9437               {
9438                 gent->got.refcount = 0;
9439                 break;
9440               }
9441
9442           /* If not, then we'll be using our own TPREL entry.  */
9443           if (gent->got.refcount != 0)
9444             gent->tls_type = TLS_TLS | TLS_TPREL;
9445         }
9446
9447   /* Remove any list entry that won't generate a word in the GOT before
9448      we call merge_got_entries.  Otherwise we risk merging to empty
9449      entries.  */
9450   pgent = &h->got.glist;
9451   while ((gent = *pgent) != NULL)
9452     if (gent->got.refcount > 0)
9453       {
9454         if ((gent->tls_type & TLS_LD) != 0
9455             && !h->def_dynamic)
9456           {
9457             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9458             *pgent = gent->next;
9459           }
9460         else
9461           pgent = &gent->next;
9462       }
9463     else
9464       *pgent = gent->next;
9465
9466   if (!htab->do_multi_toc)
9467     merge_got_entries (&h->got.glist);
9468
9469   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9470     if (!gent->is_indirect)
9471       {
9472         /* Make sure this symbol is output as a dynamic symbol.
9473            Undefined weak syms won't yet be marked as dynamic,
9474            nor will all TLS symbols.  */
9475         if (h->dynindx == -1
9476             && !h->forced_local
9477             && h->type != STT_GNU_IFUNC
9478             && htab->elf.dynamic_sections_created)
9479           {
9480             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9481               return FALSE;
9482           }
9483
9484         if (!is_ppc64_elf (gent->owner))
9485           abort ();
9486
9487         allocate_got (h, info, gent);
9488       }
9489
9490   if (eh->dyn_relocs == NULL
9491       || (!htab->elf.dynamic_sections_created
9492           && h->type != STT_GNU_IFUNC))
9493     return TRUE;
9494
9495   /* In the shared -Bsymbolic case, discard space allocated for
9496      dynamic pc-relative relocs against symbols which turn out to be
9497      defined in regular objects.  For the normal shared case, discard
9498      space for relocs that have become local due to symbol visibility
9499      changes.  */
9500
9501   if (info->shared)
9502     {
9503       /* Relocs that use pc_count are those that appear on a call insn,
9504          or certain REL relocs (see must_be_dyn_reloc) that can be
9505          generated via assembly.  We want calls to protected symbols to
9506          resolve directly to the function rather than going via the plt.
9507          If people want function pointer comparisons to work as expected
9508          then they should avoid writing weird assembly.  */
9509       if (SYMBOL_CALLS_LOCAL (info, h))
9510         {
9511           struct elf_dyn_relocs **pp;
9512
9513           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9514             {
9515               p->count -= p->pc_count;
9516               p->pc_count = 0;
9517               if (p->count == 0)
9518                 *pp = p->next;
9519               else
9520                 pp = &p->next;
9521             }
9522         }
9523
9524       /* Also discard relocs on undefined weak syms with non-default
9525          visibility.  */
9526       if (eh->dyn_relocs != NULL
9527           && h->root.type == bfd_link_hash_undefweak)
9528         {
9529           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9530             eh->dyn_relocs = NULL;
9531
9532           /* Make sure this symbol is output as a dynamic symbol.
9533              Undefined weak syms won't yet be marked as dynamic.  */
9534           else if (h->dynindx == -1
9535                    && !h->forced_local)
9536             {
9537               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9538                 return FALSE;
9539             }
9540         }
9541     }
9542   else if (h->type == STT_GNU_IFUNC)
9543     {
9544       if (!h->non_got_ref)
9545         eh->dyn_relocs = NULL;
9546     }
9547   else if (ELIMINATE_COPY_RELOCS)
9548     {
9549       /* For the non-shared case, discard space for relocs against
9550          symbols which turn out to need copy relocs or are not
9551          dynamic.  */
9552
9553       if (!h->non_got_ref
9554           && !h->def_regular)
9555         {
9556           /* Make sure this symbol is output as a dynamic symbol.
9557              Undefined weak syms won't yet be marked as dynamic.  */
9558           if (h->dynindx == -1
9559               && !h->forced_local)
9560             {
9561               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9562                 return FALSE;
9563             }
9564
9565           /* If that succeeded, we know we'll be keeping all the
9566              relocs.  */
9567           if (h->dynindx != -1)
9568             goto keep;
9569         }
9570
9571       eh->dyn_relocs = NULL;
9572
9573     keep: ;
9574     }
9575
9576   /* Finally, allocate space.  */
9577   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9578     {
9579       asection *sreloc = elf_section_data (p->sec)->sreloc;
9580       if (eh->elf.type == STT_GNU_IFUNC)
9581         sreloc = htab->elf.irelplt;
9582       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9583     }
9584
9585   return TRUE;
9586 }
9587
9588 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9589    to set up space for global entry stubs.  These are put in glink,
9590    after the branch table.  */
9591
9592 static bfd_boolean
9593 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9594 {
9595   struct bfd_link_info *info;
9596   struct ppc_link_hash_table *htab;
9597   struct plt_entry *pent;
9598   asection *s;
9599
9600   if (h->root.type == bfd_link_hash_indirect)
9601     return TRUE;
9602
9603   if (!h->pointer_equality_needed)
9604     return TRUE;
9605
9606   if (h->def_regular)
9607     return TRUE;
9608
9609   info = inf;
9610   htab = ppc_hash_table (info);
9611   if (htab == NULL)
9612     return FALSE;
9613
9614   s = htab->glink;
9615   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9616     if (pent->plt.offset != (bfd_vma) -1
9617         && pent->addend == 0)
9618       {
9619         /* For ELFv2, if this symbol is not defined in a regular file
9620            and we are not generating a shared library or pie, then we
9621            need to define the symbol in the executable on a call stub.
9622            This is to avoid text relocations.  */
9623         s->size = (s->size + 15) & -16;
9624         h->root.u.def.section = s;
9625         h->root.u.def.value = s->size;
9626         s->size += 16;
9627         break;
9628       }
9629   return TRUE;
9630 }
9631
9632 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9633    read-only sections.  */
9634
9635 static bfd_boolean
9636 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9637 {
9638   if (h->root.type == bfd_link_hash_indirect)
9639     return TRUE;
9640
9641   if (readonly_dynrelocs (h))
9642     {
9643       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9644
9645       /* Not an error, just cut short the traversal.  */
9646       return FALSE;
9647     }
9648   return TRUE;
9649 }
9650
9651 /* Set the sizes of the dynamic sections.  */
9652
9653 static bfd_boolean
9654 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9655                                  struct bfd_link_info *info)
9656 {
9657   struct ppc_link_hash_table *htab;
9658   bfd *dynobj;
9659   asection *s;
9660   bfd_boolean relocs;
9661   bfd *ibfd;
9662   struct got_entry *first_tlsld;
9663
9664   htab = ppc_hash_table (info);
9665   if (htab == NULL)
9666     return FALSE;
9667
9668   dynobj = htab->elf.dynobj;
9669   if (dynobj == NULL)
9670     abort ();
9671
9672   if (htab->elf.dynamic_sections_created)
9673     {
9674       /* Set the contents of the .interp section to the interpreter.  */
9675       if (info->executable)
9676         {
9677           s = bfd_get_linker_section (dynobj, ".interp");
9678           if (s == NULL)
9679             abort ();
9680           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9681           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9682         }
9683     }
9684
9685   /* Set up .got offsets for local syms, and space for local dynamic
9686      relocs.  */
9687   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9688     {
9689       struct got_entry **lgot_ents;
9690       struct got_entry **end_lgot_ents;
9691       struct plt_entry **local_plt;
9692       struct plt_entry **end_local_plt;
9693       unsigned char *lgot_masks;
9694       bfd_size_type locsymcount;
9695       Elf_Internal_Shdr *symtab_hdr;
9696
9697       if (!is_ppc64_elf (ibfd))
9698         continue;
9699
9700       for (s = ibfd->sections; s != NULL; s = s->next)
9701         {
9702           struct ppc_dyn_relocs *p;
9703
9704           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9705             {
9706               if (!bfd_is_abs_section (p->sec)
9707                   && bfd_is_abs_section (p->sec->output_section))
9708                 {
9709                   /* Input section has been discarded, either because
9710                      it is a copy of a linkonce section or due to
9711                      linker script /DISCARD/, so we'll be discarding
9712                      the relocs too.  */
9713                 }
9714               else if (p->count != 0)
9715                 {
9716                   asection *srel = elf_section_data (p->sec)->sreloc;
9717                   if (p->ifunc)
9718                     srel = htab->elf.irelplt;
9719                   srel->size += p->count * sizeof (Elf64_External_Rela);
9720                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9721                     info->flags |= DF_TEXTREL;
9722                 }
9723             }
9724         }
9725
9726       lgot_ents = elf_local_got_ents (ibfd);
9727       if (!lgot_ents)
9728         continue;
9729
9730       symtab_hdr = &elf_symtab_hdr (ibfd);
9731       locsymcount = symtab_hdr->sh_info;
9732       end_lgot_ents = lgot_ents + locsymcount;
9733       local_plt = (struct plt_entry **) end_lgot_ents;
9734       end_local_plt = local_plt + locsymcount;
9735       lgot_masks = (unsigned char *) end_local_plt;
9736       s = ppc64_elf_tdata (ibfd)->got;
9737       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9738         {
9739           struct got_entry **pent, *ent;
9740
9741           pent = lgot_ents;
9742           while ((ent = *pent) != NULL)
9743             if (ent->got.refcount > 0)
9744               {
9745                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9746                   {
9747                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9748                     *pent = ent->next;
9749                   }
9750                 else
9751                   {
9752                     unsigned int ent_size = 8;
9753                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9754
9755                     ent->got.offset = s->size;
9756                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9757                       {
9758                         ent_size *= 2;
9759                         rel_size *= 2;
9760                       }
9761                     s->size += ent_size;
9762                     if ((*lgot_masks & PLT_IFUNC) != 0)
9763                       {
9764                         htab->elf.irelplt->size += rel_size;
9765                         htab->got_reli_size += rel_size;
9766                       }
9767                     else if (info->shared)
9768                       {
9769                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9770                         srel->size += rel_size;
9771                       }
9772                     pent = &ent->next;
9773                   }
9774               }
9775             else
9776               *pent = ent->next;
9777         }
9778
9779       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9780       for (; local_plt < end_local_plt; ++local_plt)
9781         {
9782           struct plt_entry *ent;
9783
9784           for (ent = *local_plt; ent != NULL; ent = ent->next)
9785             if (ent->plt.refcount > 0)
9786               {
9787                 s = htab->elf.iplt;
9788                 ent->plt.offset = s->size;
9789                 s->size += PLT_ENTRY_SIZE (htab);
9790
9791                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9792               }
9793             else
9794               ent->plt.offset = (bfd_vma) -1;
9795         }
9796     }
9797
9798   /* Allocate global sym .plt and .got entries, and space for global
9799      sym dynamic relocs.  */
9800   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9801   /* Stash the end of glink branch table.  */
9802   if (htab->glink != NULL)
9803     htab->glink->rawsize = htab->glink->size;
9804
9805   if (!htab->opd_abi && !info->shared)
9806     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9807
9808   first_tlsld = NULL;
9809   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9810     {
9811       struct got_entry *ent;
9812
9813       if (!is_ppc64_elf (ibfd))
9814         continue;
9815
9816       ent = ppc64_tlsld_got (ibfd);
9817       if (ent->got.refcount > 0)
9818         {
9819           if (!htab->do_multi_toc && first_tlsld != NULL)
9820             {
9821               ent->is_indirect = TRUE;
9822               ent->got.ent = first_tlsld;
9823             }
9824           else
9825             {
9826               if (first_tlsld == NULL)
9827                 first_tlsld = ent;
9828               s = ppc64_elf_tdata (ibfd)->got;
9829               ent->got.offset = s->size;
9830               ent->owner = ibfd;
9831               s->size += 16;
9832               if (info->shared)
9833                 {
9834                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9835                   srel->size += sizeof (Elf64_External_Rela);
9836                 }
9837             }
9838         }
9839       else
9840         ent->got.offset = (bfd_vma) -1;
9841     }
9842
9843   /* We now have determined the sizes of the various dynamic sections.
9844      Allocate memory for them.  */
9845   relocs = FALSE;
9846   for (s = dynobj->sections; s != NULL; s = s->next)
9847     {
9848       if ((s->flags & SEC_LINKER_CREATED) == 0)
9849         continue;
9850
9851       if (s == htab->brlt || s == htab->relbrlt)
9852         /* These haven't been allocated yet;  don't strip.  */
9853         continue;
9854       else if (s == htab->elf.sgot
9855                || s == htab->elf.splt
9856                || s == htab->elf.iplt
9857                || s == htab->glink
9858                || s == htab->dynbss)
9859         {
9860           /* Strip this section if we don't need it; see the
9861              comment below.  */
9862         }
9863       else if (s == htab->glink_eh_frame)
9864         {
9865           if (!bfd_is_abs_section (s->output_section))
9866             /* Not sized yet.  */
9867             continue;
9868         }
9869       else if (CONST_STRNEQ (s->name, ".rela"))
9870         {
9871           if (s->size != 0)
9872             {
9873               if (s != htab->elf.srelplt)
9874                 relocs = TRUE;
9875
9876               /* We use the reloc_count field as a counter if we need
9877                  to copy relocs into the output file.  */
9878               s->reloc_count = 0;
9879             }
9880         }
9881       else
9882         {
9883           /* It's not one of our sections, so don't allocate space.  */
9884           continue;
9885         }
9886
9887       if (s->size == 0)
9888         {
9889           /* If we don't need this section, strip it from the
9890              output file.  This is mostly to handle .rela.bss and
9891              .rela.plt.  We must create both sections in
9892              create_dynamic_sections, because they must be created
9893              before the linker maps input sections to output
9894              sections.  The linker does that before
9895              adjust_dynamic_symbol is called, and it is that
9896              function which decides whether anything needs to go
9897              into these sections.  */
9898           s->flags |= SEC_EXCLUDE;
9899           continue;
9900         }
9901
9902       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9903         continue;
9904
9905       /* Allocate memory for the section contents.  We use bfd_zalloc
9906          here in case unused entries are not reclaimed before the
9907          section's contents are written out.  This should not happen,
9908          but this way if it does we get a R_PPC64_NONE reloc in .rela
9909          sections instead of garbage.
9910          We also rely on the section contents being zero when writing
9911          the GOT.  */
9912       s->contents = bfd_zalloc (dynobj, s->size);
9913       if (s->contents == NULL)
9914         return FALSE;
9915     }
9916
9917   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9918     {
9919       if (!is_ppc64_elf (ibfd))
9920         continue;
9921
9922       s = ppc64_elf_tdata (ibfd)->got;
9923       if (s != NULL && s != htab->elf.sgot)
9924         {
9925           if (s->size == 0)
9926             s->flags |= SEC_EXCLUDE;
9927           else
9928             {
9929               s->contents = bfd_zalloc (ibfd, s->size);
9930               if (s->contents == NULL)
9931                 return FALSE;
9932             }
9933         }
9934       s = ppc64_elf_tdata (ibfd)->relgot;
9935       if (s != NULL)
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               relocs = TRUE;
9945               s->reloc_count = 0;
9946             }
9947         }
9948     }
9949
9950   if (htab->elf.dynamic_sections_created)
9951     {
9952       bfd_boolean tls_opt;
9953
9954       /* Add some entries to the .dynamic section.  We fill in the
9955          values later, in ppc64_elf_finish_dynamic_sections, but we
9956          must add the entries now so that we get the correct size for
9957          the .dynamic section.  The DT_DEBUG entry is filled in by the
9958          dynamic linker and used by the debugger.  */
9959 #define add_dynamic_entry(TAG, VAL) \
9960   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9961
9962       if (info->executable)
9963         {
9964           if (!add_dynamic_entry (DT_DEBUG, 0))
9965             return FALSE;
9966         }
9967
9968       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9969         {
9970           if (!add_dynamic_entry (DT_PLTGOT, 0)
9971               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9972               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9973               || !add_dynamic_entry (DT_JMPREL, 0)
9974               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9975             return FALSE;
9976         }
9977
9978       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9979         {
9980           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9981               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9982             return FALSE;
9983         }
9984
9985       tls_opt = (!htab->params->no_tls_get_addr_opt
9986                  && htab->tls_get_addr_fd != NULL
9987                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9988       if (tls_opt || !htab->opd_abi)
9989         {
9990           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9991             return FALSE;
9992         }
9993
9994       if (relocs)
9995         {
9996           if (!add_dynamic_entry (DT_RELA, 0)
9997               || !add_dynamic_entry (DT_RELASZ, 0)
9998               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9999             return FALSE;
10000
10001           /* If any dynamic relocs apply to a read-only section,
10002              then we need a DT_TEXTREL entry.  */
10003           if ((info->flags & DF_TEXTREL) == 0)
10004             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10005
10006           if ((info->flags & DF_TEXTREL) != 0)
10007             {
10008               if (!add_dynamic_entry (DT_TEXTREL, 0))
10009                 return FALSE;
10010             }
10011         }
10012     }
10013 #undef add_dynamic_entry
10014
10015   return TRUE;
10016 }
10017
10018 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10019
10020 static bfd_boolean
10021 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10022 {
10023   if (h->plt.plist != NULL
10024       && !h->def_regular
10025       && !h->pointer_equality_needed)
10026     return FALSE;
10027
10028   return _bfd_elf_hash_symbol (h);
10029 }
10030
10031 /* Determine the type of stub needed, if any, for a call.  */
10032
10033 static inline enum ppc_stub_type
10034 ppc_type_of_stub (asection *input_sec,
10035                   const Elf_Internal_Rela *rel,
10036                   struct ppc_link_hash_entry **hash,
10037                   struct plt_entry **plt_ent,
10038                   bfd_vma destination,
10039                   unsigned long local_off)
10040 {
10041   struct ppc_link_hash_entry *h = *hash;
10042   bfd_vma location;
10043   bfd_vma branch_offset;
10044   bfd_vma max_branch_offset;
10045   enum elf_ppc64_reloc_type r_type;
10046
10047   if (h != NULL)
10048     {
10049       struct plt_entry *ent;
10050       struct ppc_link_hash_entry *fdh = h;
10051       if (h->oh != NULL
10052           && h->oh->is_func_descriptor)
10053         {
10054           fdh = ppc_follow_link (h->oh);
10055           *hash = fdh;
10056         }
10057
10058       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10059         if (ent->addend == rel->r_addend
10060             && ent->plt.offset != (bfd_vma) -1)
10061           {
10062             *plt_ent = ent;
10063             return ppc_stub_plt_call;
10064           }
10065
10066       /* Here, we know we don't have a plt entry.  If we don't have a
10067          either a defined function descriptor or a defined entry symbol
10068          in a regular object file, then it is pointless trying to make
10069          any other type of stub.  */
10070       if (!is_static_defined (&fdh->elf)
10071           && !is_static_defined (&h->elf))
10072         return ppc_stub_none;
10073     }
10074   else if (elf_local_got_ents (input_sec->owner) != NULL)
10075     {
10076       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10077       struct plt_entry **local_plt = (struct plt_entry **)
10078         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10079       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10080
10081       if (local_plt[r_symndx] != NULL)
10082         {
10083           struct plt_entry *ent;
10084
10085           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10086             if (ent->addend == rel->r_addend
10087                 && ent->plt.offset != (bfd_vma) -1)
10088               {
10089                 *plt_ent = ent;
10090                 return ppc_stub_plt_call;
10091               }
10092         }
10093     }
10094
10095   /* Determine where the call point is.  */
10096   location = (input_sec->output_offset
10097               + input_sec->output_section->vma
10098               + rel->r_offset);
10099
10100   branch_offset = destination - location;
10101   r_type = ELF64_R_TYPE (rel->r_info);
10102
10103   /* Determine if a long branch stub is needed.  */
10104   max_branch_offset = 1 << 25;
10105   if (r_type != R_PPC64_REL24)
10106     max_branch_offset = 1 << 15;
10107
10108   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10109     /* We need a stub.  Figure out whether a long_branch or plt_branch
10110        is needed later.  */
10111     return ppc_stub_long_branch;
10112
10113   return ppc_stub_none;
10114 }
10115
10116 /* With power7 weakly ordered memory model, it is possible for ld.so
10117    to update a plt entry in one thread and have another thread see a
10118    stale zero toc entry.  To avoid this we need some sort of acquire
10119    barrier in the call stub.  One solution is to make the load of the
10120    toc word seem to appear to depend on the load of the function entry
10121    word.  Another solution is to test for r2 being zero, and branch to
10122    the appropriate glink entry if so.
10123
10124    .    fake dep barrier        compare
10125    .    ld 12,xxx(2)            ld 12,xxx(2)
10126    .    mtctr 12                mtctr 12
10127    .    xor 11,12,12            ld 2,xxx+8(2)
10128    .    add 2,2,11              cmpldi 2,0
10129    .    ld 2,xxx+8(2)           bnectr+
10130    .    bctr                    b <glink_entry>
10131
10132    The solution involving the compare turns out to be faster, so
10133    that's what we use unless the branch won't reach.  */
10134
10135 #define ALWAYS_USE_FAKE_DEP 0
10136 #define ALWAYS_EMIT_R2SAVE 0
10137
10138 #define PPC_LO(v) ((v) & 0xffff)
10139 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10140 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10141
10142 static inline unsigned int
10143 plt_stub_size (struct ppc_link_hash_table *htab,
10144                struct ppc_stub_hash_entry *stub_entry,
10145                bfd_vma off)
10146 {
10147   unsigned size = 12;
10148
10149   if (ALWAYS_EMIT_R2SAVE
10150       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10151     size += 4;
10152   if (PPC_HA (off) != 0)
10153     size += 4;
10154   if (htab->opd_abi)
10155     {
10156       size += 4;
10157       if (htab->params->plt_static_chain)
10158         size += 4;
10159       if (htab->params->plt_thread_safe)
10160         size += 8;
10161       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10162         size += 4;
10163     }
10164   if (stub_entry->h != NULL
10165       && (stub_entry->h == htab->tls_get_addr_fd
10166           || stub_entry->h == htab->tls_get_addr)
10167       && !htab->params->no_tls_get_addr_opt)
10168     size += 13 * 4;
10169   return size;
10170 }
10171
10172 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10173    then return the padding needed to do so.  */
10174 static inline unsigned int
10175 plt_stub_pad (struct ppc_link_hash_table *htab,
10176               struct ppc_stub_hash_entry *stub_entry,
10177               bfd_vma plt_off)
10178 {
10179   int stub_align = 1 << htab->params->plt_stub_align;
10180   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10181   bfd_vma stub_off = stub_entry->stub_sec->size;
10182
10183   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10184       > (stub_size & -stub_align))
10185     return stub_align - (stub_off & (stub_align - 1));
10186   return 0;
10187 }
10188
10189 /* Build a .plt call stub.  */
10190
10191 static inline bfd_byte *
10192 build_plt_stub (struct ppc_link_hash_table *htab,
10193                 struct ppc_stub_hash_entry *stub_entry,
10194                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10195 {
10196   bfd *obfd = htab->params->stub_bfd;
10197   bfd_boolean plt_load_toc = htab->opd_abi;
10198   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10199   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10200   bfd_boolean use_fake_dep = plt_thread_safe;
10201   bfd_vma cmp_branch_off = 0;
10202
10203   if (!ALWAYS_USE_FAKE_DEP
10204       && plt_load_toc
10205       && plt_thread_safe
10206       && !(stub_entry->h != NULL
10207            && (stub_entry->h == htab->tls_get_addr_fd
10208                || stub_entry->h == htab->tls_get_addr)
10209            && !htab->params->no_tls_get_addr_opt))
10210     {
10211       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10212       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10213                           / PLT_ENTRY_SIZE (htab));
10214       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10215       bfd_vma to, from;
10216
10217       if (pltindex > 32768)
10218         glinkoff += (pltindex - 32768) * 4;
10219       to = (glinkoff
10220             + htab->glink->output_offset
10221             + htab->glink->output_section->vma);
10222       from = (p - stub_entry->stub_sec->contents
10223               + 4 * (ALWAYS_EMIT_R2SAVE
10224                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10225               + 4 * (PPC_HA (offset) != 0)
10226               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10227                      != PPC_HA (offset))
10228               + 4 * (plt_static_chain != 0)
10229               + 20
10230               + stub_entry->stub_sec->output_offset
10231               + stub_entry->stub_sec->output_section->vma);
10232       cmp_branch_off = to - from;
10233       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10234     }
10235
10236   if (PPC_HA (offset) != 0)
10237     {
10238       if (r != NULL)
10239         {
10240           if (ALWAYS_EMIT_R2SAVE
10241               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10242             r[0].r_offset += 4;
10243           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10244           r[1].r_offset = r[0].r_offset + 4;
10245           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10246           r[1].r_addend = r[0].r_addend;
10247           if (plt_load_toc)
10248             {
10249               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10250                 {
10251                   r[2].r_offset = r[1].r_offset + 4;
10252                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10253                   r[2].r_addend = r[0].r_addend;
10254                 }
10255               else
10256                 {
10257                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10258                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10259                   r[2].r_addend = r[0].r_addend + 8;
10260                   if (plt_static_chain)
10261                     {
10262                       r[3].r_offset = r[2].r_offset + 4;
10263                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10264                       r[3].r_addend = r[0].r_addend + 16;
10265                     }
10266                 }
10267             }
10268         }
10269       if (ALWAYS_EMIT_R2SAVE
10270           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10271         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10272       if (plt_load_toc)
10273         {
10274           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10275           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10276         }
10277       else
10278         {
10279           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10280           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10281         }
10282       if (plt_load_toc
10283           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10284         {
10285           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10286           offset = 0;
10287         }
10288       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10289       if (plt_load_toc)
10290         {
10291           if (use_fake_dep)
10292             {
10293               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10294               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10295             }
10296           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10297           if (plt_static_chain)
10298             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10299         }
10300     }
10301   else
10302     {
10303       if (r != NULL)
10304         {
10305           if (ALWAYS_EMIT_R2SAVE
10306               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10307             r[0].r_offset += 4;
10308           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10309           if (plt_load_toc)
10310             {
10311               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10312                 {
10313                   r[1].r_offset = r[0].r_offset + 4;
10314                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10315                   r[1].r_addend = r[0].r_addend;
10316                 }
10317               else
10318                 {
10319                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10320                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10321                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10322                   if (plt_static_chain)
10323                     {
10324                       r[2].r_offset = r[1].r_offset + 4;
10325                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10326                       r[2].r_addend = r[0].r_addend + 8;
10327                     }
10328                 }
10329             }
10330         }
10331       if (ALWAYS_EMIT_R2SAVE
10332           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10333         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10334       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10335       if (plt_load_toc
10336           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10337         {
10338           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10339           offset = 0;
10340         }
10341       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10342       if (plt_load_toc)
10343         {
10344           if (use_fake_dep)
10345             {
10346               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10347               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10348             }
10349           if (plt_static_chain)
10350             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10351           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10352         }
10353     }
10354   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10355     {
10356       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10357       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10358       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10359     }
10360   else
10361     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10362   return p;
10363 }
10364
10365 /* Build a special .plt call stub for __tls_get_addr.  */
10366
10367 #define LD_R11_0R3      0xe9630000
10368 #define LD_R12_0R3      0xe9830000
10369 #define MR_R0_R3        0x7c601b78
10370 #define CMPDI_R11_0     0x2c2b0000
10371 #define ADD_R3_R12_R13  0x7c6c6a14
10372 #define BEQLR           0x4d820020
10373 #define MR_R3_R0        0x7c030378
10374 #define STD_R11_0R1     0xf9610000
10375 #define BCTRL           0x4e800421
10376 #define LD_R11_0R1      0xe9610000
10377 #define MTLR_R11        0x7d6803a6
10378
10379 static inline bfd_byte *
10380 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10381                          struct ppc_stub_hash_entry *stub_entry,
10382                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10383 {
10384   bfd *obfd = htab->params->stub_bfd;
10385
10386   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10387   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10388   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10389   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10390   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10391   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10392   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10393   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10394   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10395
10396   if (r != NULL)
10397     r[0].r_offset += 9 * 4;
10398   p = build_plt_stub (htab, stub_entry, p, offset, r);
10399   bfd_put_32 (obfd, BCTRL, p - 4);
10400
10401   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10402   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10403   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10404   bfd_put_32 (obfd, BLR, p),                    p += 4;
10405
10406   return p;
10407 }
10408
10409 static Elf_Internal_Rela *
10410 get_relocs (asection *sec, int count)
10411 {
10412   Elf_Internal_Rela *relocs;
10413   struct bfd_elf_section_data *elfsec_data;
10414
10415   elfsec_data = elf_section_data (sec);
10416   relocs = elfsec_data->relocs;
10417   if (relocs == NULL)
10418     {
10419       bfd_size_type relsize;
10420       relsize = sec->reloc_count * sizeof (*relocs);
10421       relocs = bfd_alloc (sec->owner, relsize);
10422       if (relocs == NULL)
10423         return NULL;
10424       elfsec_data->relocs = relocs;
10425       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10426                                           sizeof (Elf_Internal_Shdr));
10427       if (elfsec_data->rela.hdr == NULL)
10428         return NULL;
10429       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10430                                         * sizeof (Elf64_External_Rela));
10431       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10432       sec->reloc_count = 0;
10433     }
10434   relocs += sec->reloc_count;
10435   sec->reloc_count += count;
10436   return relocs;
10437 }
10438
10439 static bfd_vma
10440 get_r2off (struct bfd_link_info *info,
10441            struct ppc_stub_hash_entry *stub_entry)
10442 {
10443   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10444   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10445
10446   if (r2off == 0)
10447     {
10448       /* Support linking -R objects.  Get the toc pointer from the
10449          opd entry.  */
10450       char buf[8];
10451       if (!htab->opd_abi)
10452         return r2off;
10453       asection *opd = stub_entry->h->elf.root.u.def.section;
10454       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10455
10456       if (strcmp (opd->name, ".opd") != 0
10457           || opd->reloc_count != 0)
10458         {
10459           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10460                                   stub_entry->h->elf.root.root.string);
10461           bfd_set_error (bfd_error_bad_value);
10462           return 0;
10463         }
10464       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10465         return 0;
10466       r2off = bfd_get_64 (opd->owner, buf);
10467       r2off -= elf_gp (info->output_bfd);
10468     }
10469   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10470   return r2off;
10471 }
10472
10473 static bfd_boolean
10474 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10475 {
10476   struct ppc_stub_hash_entry *stub_entry;
10477   struct ppc_branch_hash_entry *br_entry;
10478   struct bfd_link_info *info;
10479   struct ppc_link_hash_table *htab;
10480   bfd_byte *loc;
10481   bfd_byte *p;
10482   bfd_vma dest, off;
10483   int size;
10484   Elf_Internal_Rela *r;
10485   asection *plt;
10486
10487   /* Massage our args to the form they really have.  */
10488   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10489   info = in_arg;
10490
10491   htab = ppc_hash_table (info);
10492   if (htab == NULL)
10493     return FALSE;
10494
10495   /* Make a note of the offset within the stubs for this entry.  */
10496   stub_entry->stub_offset = stub_entry->stub_sec->size;
10497   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10498
10499   htab->stub_count[stub_entry->stub_type - 1] += 1;
10500   switch (stub_entry->stub_type)
10501     {
10502     case ppc_stub_long_branch:
10503     case ppc_stub_long_branch_r2off:
10504       /* Branches are relative.  This is where we are going to.  */
10505       dest = (stub_entry->target_value
10506               + stub_entry->target_section->output_offset
10507               + stub_entry->target_section->output_section->vma);
10508       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10509       off = dest;
10510
10511       /* And this is where we are coming from.  */
10512       off -= (stub_entry->stub_offset
10513               + stub_entry->stub_sec->output_offset
10514               + stub_entry->stub_sec->output_section->vma);
10515
10516       size = 4;
10517       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10518         {
10519           bfd_vma r2off = get_r2off (info, stub_entry);
10520
10521           if (r2off == 0)
10522             {
10523               htab->stub_error = TRUE;
10524               return FALSE;
10525             }
10526           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10527           loc += 4;
10528           size = 12;
10529           if (PPC_HA (r2off) != 0)
10530             {
10531               size = 16;
10532               bfd_put_32 (htab->params->stub_bfd,
10533                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10534               loc += 4;
10535             }
10536           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10537           loc += 4;
10538           off -= size - 4;
10539         }
10540       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10541
10542       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10543         {
10544           info->callbacks->einfo
10545             (_("%P: long branch stub `%s' offset overflow\n"),
10546              stub_entry->root.string);
10547           htab->stub_error = TRUE;
10548           return FALSE;
10549         }
10550
10551       if (info->emitrelocations)
10552         {
10553           r = get_relocs (stub_entry->stub_sec, 1);
10554           if (r == NULL)
10555             return FALSE;
10556           r->r_offset = loc - stub_entry->stub_sec->contents;
10557           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10558           r->r_addend = dest;
10559           if (stub_entry->h != NULL)
10560             {
10561               struct elf_link_hash_entry **hashes;
10562               unsigned long symndx;
10563               struct ppc_link_hash_entry *h;
10564
10565               hashes = elf_sym_hashes (htab->params->stub_bfd);
10566               if (hashes == NULL)
10567                 {
10568                   bfd_size_type hsize;
10569
10570                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10571                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10572                   if (hashes == NULL)
10573                     return FALSE;
10574                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10575                   htab->stub_globals = 1;
10576                 }
10577               symndx = htab->stub_globals++;
10578               h = stub_entry->h;
10579               hashes[symndx] = &h->elf;
10580               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10581               if (h->oh != NULL && h->oh->is_func)
10582                 h = ppc_follow_link (h->oh);
10583               if (h->elf.root.u.def.section != stub_entry->target_section)
10584                 /* H is an opd symbol.  The addend must be zero.  */
10585                 r->r_addend = 0;
10586               else
10587                 {
10588                   off = (h->elf.root.u.def.value
10589                          + h->elf.root.u.def.section->output_offset
10590                          + h->elf.root.u.def.section->output_section->vma);
10591                   r->r_addend -= off;
10592                 }
10593             }
10594         }
10595       break;
10596
10597     case ppc_stub_plt_branch:
10598     case ppc_stub_plt_branch_r2off:
10599       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10600                                          stub_entry->root.string + 9,
10601                                          FALSE, FALSE);
10602       if (br_entry == NULL)
10603         {
10604           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10605                                   stub_entry->root.string);
10606           htab->stub_error = TRUE;
10607           return FALSE;
10608         }
10609
10610       dest = (stub_entry->target_value
10611               + stub_entry->target_section->output_offset
10612               + stub_entry->target_section->output_section->vma);
10613       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10614         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10615
10616       bfd_put_64 (htab->brlt->owner, dest,
10617                   htab->brlt->contents + br_entry->offset);
10618
10619       if (br_entry->iter == htab->stub_iteration)
10620         {
10621           br_entry->iter = 0;
10622
10623           if (htab->relbrlt != NULL)
10624             {
10625               /* Create a reloc for the branch lookup table entry.  */
10626               Elf_Internal_Rela rela;
10627               bfd_byte *rl;
10628
10629               rela.r_offset = (br_entry->offset
10630                                + htab->brlt->output_offset
10631                                + htab->brlt->output_section->vma);
10632               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10633               rela.r_addend = dest;
10634
10635               rl = htab->relbrlt->contents;
10636               rl += (htab->relbrlt->reloc_count++
10637                      * sizeof (Elf64_External_Rela));
10638               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10639             }
10640           else if (info->emitrelocations)
10641             {
10642               r = get_relocs (htab->brlt, 1);
10643               if (r == NULL)
10644                 return FALSE;
10645               /* brlt, being SEC_LINKER_CREATED does not go through the
10646                  normal reloc processing.  Symbols and offsets are not
10647                  translated from input file to output file form, so
10648                  set up the offset per the output file.  */
10649               r->r_offset = (br_entry->offset
10650                              + htab->brlt->output_offset
10651                              + htab->brlt->output_section->vma);
10652               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10653               r->r_addend = dest;
10654             }
10655         }
10656
10657       dest = (br_entry->offset
10658               + htab->brlt->output_offset
10659               + htab->brlt->output_section->vma);
10660
10661       off = (dest
10662              - elf_gp (htab->brlt->output_section->owner)
10663              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10664
10665       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10666         {
10667           info->callbacks->einfo
10668             (_("%P: linkage table error against `%T'\n"),
10669              stub_entry->root.string);
10670           bfd_set_error (bfd_error_bad_value);
10671           htab->stub_error = TRUE;
10672           return FALSE;
10673         }
10674
10675       if (info->emitrelocations)
10676         {
10677           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10678           if (r == NULL)
10679             return FALSE;
10680           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10681           if (bfd_big_endian (info->output_bfd))
10682             r[0].r_offset += 2;
10683           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10684             r[0].r_offset += 4;
10685           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10686           r[0].r_addend = dest;
10687           if (PPC_HA (off) != 0)
10688             {
10689               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10690               r[1].r_offset = r[0].r_offset + 4;
10691               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10692               r[1].r_addend = r[0].r_addend;
10693             }
10694         }
10695
10696       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10697         {
10698           if (PPC_HA (off) != 0)
10699             {
10700               size = 16;
10701               bfd_put_32 (htab->params->stub_bfd,
10702                           ADDIS_R12_R2 | PPC_HA (off), loc);
10703               loc += 4;
10704               bfd_put_32 (htab->params->stub_bfd,
10705                           LD_R12_0R12 | PPC_LO (off), loc);
10706             }
10707           else
10708             {
10709               size = 12;
10710               bfd_put_32 (htab->params->stub_bfd,
10711                           LD_R12_0R2 | PPC_LO (off), loc);
10712             }
10713         }
10714       else
10715         {
10716           bfd_vma r2off = get_r2off (info, stub_entry);
10717
10718           if (r2off == 0 && htab->opd_abi)
10719             {
10720               htab->stub_error = TRUE;
10721               return FALSE;
10722             }
10723
10724           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10725           loc += 4;
10726           size = 16;
10727           if (PPC_HA (off) != 0)
10728             {
10729               size += 4;
10730               bfd_put_32 (htab->params->stub_bfd,
10731                           ADDIS_R12_R2 | PPC_HA (off), loc);
10732               loc += 4;
10733               bfd_put_32 (htab->params->stub_bfd,
10734                           LD_R12_0R12 | PPC_LO (off), loc);
10735             }
10736           else
10737             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10738
10739           if (PPC_HA (r2off) != 0)
10740             {
10741               size += 4;
10742               loc += 4;
10743               bfd_put_32 (htab->params->stub_bfd,
10744                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10745             }
10746           if (PPC_LO (r2off) != 0)
10747             {
10748               size += 4;
10749               loc += 4;
10750               bfd_put_32 (htab->params->stub_bfd,
10751                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10752             }
10753         }
10754       loc += 4;
10755       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10756       loc += 4;
10757       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10758       break;
10759
10760     case ppc_stub_plt_call:
10761     case ppc_stub_plt_call_r2save:
10762       if (stub_entry->h != NULL
10763           && stub_entry->h->is_func_descriptor
10764           && stub_entry->h->oh != NULL)
10765         {
10766           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10767
10768           /* If the old-ABI "dot-symbol" is undefined make it weak so
10769              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10770              FIXME: We used to define the symbol on one of the call
10771              stubs instead, which is why we test symbol section id
10772              against htab->top_id in various places.  Likely all
10773              these checks could now disappear.  */
10774           if (fh->elf.root.type == bfd_link_hash_undefined)
10775             fh->elf.root.type = bfd_link_hash_undefweak;
10776           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10777           fh->was_undefined = 0;
10778         }
10779
10780       /* Now build the stub.  */
10781       dest = stub_entry->plt_ent->plt.offset & ~1;
10782       if (dest >= (bfd_vma) -2)
10783         abort ();
10784
10785       plt = htab->elf.splt;
10786       if (!htab->elf.dynamic_sections_created
10787           || stub_entry->h == NULL
10788           || stub_entry->h->elf.dynindx == -1)
10789         plt = htab->elf.iplt;
10790
10791       dest += plt->output_offset + plt->output_section->vma;
10792
10793       if (stub_entry->h == NULL
10794           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10795         {
10796           Elf_Internal_Rela rela;
10797           bfd_byte *rl;
10798
10799           rela.r_offset = dest;
10800           if (htab->opd_abi)
10801             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10802           else
10803             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10804           rela.r_addend = (stub_entry->target_value
10805                            + stub_entry->target_section->output_offset
10806                            + stub_entry->target_section->output_section->vma);
10807
10808           rl = (htab->elf.irelplt->contents
10809                 + (htab->elf.irelplt->reloc_count++
10810                    * sizeof (Elf64_External_Rela)));
10811           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10812           stub_entry->plt_ent->plt.offset |= 1;
10813         }
10814
10815       off = (dest
10816              - elf_gp (plt->output_section->owner)
10817              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10818
10819       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10820         {
10821           info->callbacks->einfo
10822             (_("%P: linkage table error against `%T'\n"),
10823              stub_entry->h != NULL
10824              ? stub_entry->h->elf.root.root.string
10825              : "<local sym>");
10826           bfd_set_error (bfd_error_bad_value);
10827           htab->stub_error = TRUE;
10828           return FALSE;
10829         }
10830
10831       if (htab->params->plt_stub_align != 0)
10832         {
10833           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10834
10835           stub_entry->stub_sec->size += pad;
10836           stub_entry->stub_offset = stub_entry->stub_sec->size;
10837           loc += pad;
10838         }
10839
10840       r = NULL;
10841       if (info->emitrelocations)
10842         {
10843           r = get_relocs (stub_entry->stub_sec,
10844                           ((PPC_HA (off) != 0)
10845                            + (htab->opd_abi
10846                               ? 2 + (htab->params->plt_static_chain
10847                                      && PPC_HA (off + 16) == PPC_HA (off))
10848                               : 1)));
10849           if (r == NULL)
10850             return FALSE;
10851           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10852           if (bfd_big_endian (info->output_bfd))
10853             r[0].r_offset += 2;
10854           r[0].r_addend = dest;
10855         }
10856       if (stub_entry->h != NULL
10857           && (stub_entry->h == htab->tls_get_addr_fd
10858               || stub_entry->h == htab->tls_get_addr)
10859           && !htab->params->no_tls_get_addr_opt)
10860         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10861       else
10862         p = build_plt_stub (htab, stub_entry, loc, off, r);
10863       size = p - loc;
10864       break;
10865
10866     default:
10867       BFD_FAIL ();
10868       return FALSE;
10869     }
10870
10871   stub_entry->stub_sec->size += size;
10872
10873   if (htab->params->emit_stub_syms)
10874     {
10875       struct elf_link_hash_entry *h;
10876       size_t len1, len2;
10877       char *name;
10878       const char *const stub_str[] = { "long_branch",
10879                                        "long_branch_r2off",
10880                                        "plt_branch",
10881                                        "plt_branch_r2off",
10882                                        "plt_call",
10883                                        "plt_call" };
10884
10885       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10886       len2 = strlen (stub_entry->root.string);
10887       name = bfd_malloc (len1 + len2 + 2);
10888       if (name == NULL)
10889         return FALSE;
10890       memcpy (name, stub_entry->root.string, 9);
10891       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10892       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10893       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10894       if (h == NULL)
10895         return FALSE;
10896       if (h->root.type == bfd_link_hash_new)
10897         {
10898           h->root.type = bfd_link_hash_defined;
10899           h->root.u.def.section = stub_entry->stub_sec;
10900           h->root.u.def.value = stub_entry->stub_offset;
10901           h->ref_regular = 1;
10902           h->def_regular = 1;
10903           h->ref_regular_nonweak = 1;
10904           h->forced_local = 1;
10905           h->non_elf = 0;
10906         }
10907     }
10908
10909   return TRUE;
10910 }
10911
10912 /* As above, but don't actually build the stub.  Just bump offset so
10913    we know stub section sizes, and select plt_branch stubs where
10914    long_branch stubs won't do.  */
10915
10916 static bfd_boolean
10917 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10918 {
10919   struct ppc_stub_hash_entry *stub_entry;
10920   struct bfd_link_info *info;
10921   struct ppc_link_hash_table *htab;
10922   bfd_vma off;
10923   int size;
10924
10925   /* Massage our args to the form they really have.  */
10926   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10927   info = in_arg;
10928
10929   htab = ppc_hash_table (info);
10930   if (htab == NULL)
10931     return FALSE;
10932
10933   if (stub_entry->stub_type == ppc_stub_plt_call
10934       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10935     {
10936       asection *plt;
10937       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10938       if (off >= (bfd_vma) -2)
10939         abort ();
10940       plt = htab->elf.splt;
10941       if (!htab->elf.dynamic_sections_created
10942           || stub_entry->h == NULL
10943           || stub_entry->h->elf.dynindx == -1)
10944         plt = htab->elf.iplt;
10945       off += (plt->output_offset
10946               + plt->output_section->vma
10947               - elf_gp (plt->output_section->owner)
10948               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10949
10950       size = plt_stub_size (htab, stub_entry, off);
10951       if (htab->params->plt_stub_align)
10952         size += plt_stub_pad (htab, stub_entry, off);
10953       if (info->emitrelocations)
10954         {
10955           stub_entry->stub_sec->reloc_count
10956             += ((PPC_HA (off) != 0)
10957                 + (htab->opd_abi
10958                    ? 2 + (htab->params->plt_static_chain
10959                           && PPC_HA (off + 16) == PPC_HA (off))
10960                    : 1));
10961           stub_entry->stub_sec->flags |= SEC_RELOC;
10962         }
10963     }
10964   else
10965     {
10966       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10967          variants.  */
10968       bfd_vma r2off = 0;
10969       bfd_vma local_off = 0;
10970
10971       off = (stub_entry->target_value
10972              + stub_entry->target_section->output_offset
10973              + stub_entry->target_section->output_section->vma);
10974       off -= (stub_entry->stub_sec->size
10975               + stub_entry->stub_sec->output_offset
10976               + stub_entry->stub_sec->output_section->vma);
10977
10978       /* Reset the stub type from the plt variant in case we now
10979          can reach with a shorter stub.  */
10980       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10981         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10982
10983       size = 4;
10984       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10985         {
10986           r2off = get_r2off (info, stub_entry);
10987           if (r2off == 0 && htab->opd_abi)
10988             {
10989               htab->stub_error = TRUE;
10990               return FALSE;
10991             }
10992           size = 12;
10993           if (PPC_HA (r2off) != 0)
10994             size = 16;
10995           off -= size - 4;
10996         }
10997
10998       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10999
11000       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11001          Do the same for -R objects without function descriptors.  */
11002       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11003           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11004               && r2off == 0))
11005         {
11006           struct ppc_branch_hash_entry *br_entry;
11007
11008           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11009                                              stub_entry->root.string + 9,
11010                                              TRUE, FALSE);
11011           if (br_entry == NULL)
11012             {
11013               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11014                                       stub_entry->root.string);
11015               htab->stub_error = TRUE;
11016               return FALSE;
11017             }
11018
11019           if (br_entry->iter != htab->stub_iteration)
11020             {
11021               br_entry->iter = htab->stub_iteration;
11022               br_entry->offset = htab->brlt->size;
11023               htab->brlt->size += 8;
11024
11025               if (htab->relbrlt != NULL)
11026                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11027               else if (info->emitrelocations)
11028                 {
11029                   htab->brlt->reloc_count += 1;
11030                   htab->brlt->flags |= SEC_RELOC;
11031                 }
11032             }
11033
11034           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11035           off = (br_entry->offset
11036                  + htab->brlt->output_offset
11037                  + htab->brlt->output_section->vma
11038                  - elf_gp (htab->brlt->output_section->owner)
11039                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11040
11041           if (info->emitrelocations)
11042             {
11043               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11044               stub_entry->stub_sec->flags |= SEC_RELOC;
11045             }
11046
11047           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11048             {
11049               size = 12;
11050               if (PPC_HA (off) != 0)
11051                 size = 16;
11052             }
11053           else
11054             {
11055               size = 16;
11056               if (PPC_HA (off) != 0)
11057                 size += 4;
11058
11059               if (PPC_HA (r2off) != 0)
11060                 size += 4;
11061               if (PPC_LO (r2off) != 0)
11062                 size += 4;
11063             }
11064         }
11065       else if (info->emitrelocations)
11066         {
11067           stub_entry->stub_sec->reloc_count += 1;
11068           stub_entry->stub_sec->flags |= SEC_RELOC;
11069         }
11070     }
11071
11072   stub_entry->stub_sec->size += size;
11073   return TRUE;
11074 }
11075
11076 /* Set up various things so that we can make a list of input sections
11077    for each output section included in the link.  Returns -1 on error,
11078    0 when no stubs will be needed, and 1 on success.  */
11079
11080 int
11081 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11082 {
11083   bfd *input_bfd;
11084   int top_id, top_index, id;
11085   asection *section;
11086   asection **input_list;
11087   bfd_size_type amt;
11088   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11089
11090   if (htab == NULL)
11091     return -1;
11092
11093   /* Find the top input section id.  */
11094   for (input_bfd = info->input_bfds, top_id = 3;
11095        input_bfd != NULL;
11096        input_bfd = input_bfd->link.next)
11097     {
11098       for (section = input_bfd->sections;
11099            section != NULL;
11100            section = section->next)
11101         {
11102           if (top_id < section->id)
11103             top_id = section->id;
11104         }
11105     }
11106
11107   htab->top_id = top_id;
11108   amt = sizeof (struct map_stub) * (top_id + 1);
11109   htab->stub_group = bfd_zmalloc (amt);
11110   if (htab->stub_group == NULL)
11111     return -1;
11112
11113   /* Set toc_off for com, und, abs and ind sections.  */
11114   for (id = 0; id < 3; id++)
11115     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11116
11117   /* We can't use output_bfd->section_count here to find the top output
11118      section index as some sections may have been removed, and
11119      strip_excluded_output_sections doesn't renumber the indices.  */
11120   for (section = info->output_bfd->sections, top_index = 0;
11121        section != NULL;
11122        section = section->next)
11123     {
11124       if (top_index < section->index)
11125         top_index = section->index;
11126     }
11127
11128   htab->top_index = top_index;
11129   amt = sizeof (asection *) * (top_index + 1);
11130   input_list = bfd_zmalloc (amt);
11131   htab->input_list = input_list;
11132   if (input_list == NULL)
11133     return -1;
11134
11135   return 1;
11136 }
11137
11138 /* Set up for first pass at multitoc partitioning.  */
11139
11140 void
11141 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11142 {
11143   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11144
11145   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11146   htab->toc_bfd = NULL;
11147   htab->toc_first_sec = NULL;
11148 }
11149
11150 /* The linker repeatedly calls this function for each TOC input section
11151    and linker generated GOT section.  Group input bfds such that the toc
11152    within a group is less than 64k in size.  */
11153
11154 bfd_boolean
11155 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11156 {
11157   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11158   bfd_vma addr, off, limit;
11159
11160   if (htab == NULL)
11161     return FALSE;
11162
11163   if (!htab->second_toc_pass)
11164     {
11165       /* Keep track of the first .toc or .got section for this input bfd.  */
11166       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11167
11168       if (new_bfd)
11169         {
11170           htab->toc_bfd = isec->owner;
11171           htab->toc_first_sec = isec;
11172         }
11173
11174       addr = isec->output_offset + isec->output_section->vma;
11175       off = addr - htab->toc_curr;
11176       limit = 0x80008000;
11177       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11178         limit = 0x10000;
11179       if (off + isec->size > limit)
11180         {
11181           addr = (htab->toc_first_sec->output_offset
11182                   + htab->toc_first_sec->output_section->vma);
11183           htab->toc_curr = addr;
11184         }
11185
11186       /* toc_curr is the base address of this toc group.  Set elf_gp
11187          for the input section to be the offset relative to the
11188          output toc base plus 0x8000.  Making the input elf_gp an
11189          offset allows us to move the toc as a whole without
11190          recalculating input elf_gp.  */
11191       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11192       off += TOC_BASE_OFF;
11193
11194       /* Die if someone uses a linker script that doesn't keep input
11195          file .toc and .got together.  */
11196       if (new_bfd
11197           && elf_gp (isec->owner) != 0
11198           && elf_gp (isec->owner) != off)
11199         return FALSE;
11200
11201       elf_gp (isec->owner) = off;
11202       return TRUE;
11203     }
11204
11205   /* During the second pass toc_first_sec points to the start of
11206      a toc group, and toc_curr is used to track the old elf_gp.
11207      We use toc_bfd to ensure we only look at each bfd once.  */
11208   if (htab->toc_bfd == isec->owner)
11209     return TRUE;
11210   htab->toc_bfd = isec->owner;
11211
11212   if (htab->toc_first_sec == NULL
11213       || htab->toc_curr != elf_gp (isec->owner))
11214     {
11215       htab->toc_curr = elf_gp (isec->owner);
11216       htab->toc_first_sec = isec;
11217     }
11218   addr = (htab->toc_first_sec->output_offset
11219           + htab->toc_first_sec->output_section->vma);
11220   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11221   elf_gp (isec->owner) = off;
11222
11223   return TRUE;
11224 }
11225
11226 /* Called via elf_link_hash_traverse to merge GOT entries for global
11227    symbol H.  */
11228
11229 static bfd_boolean
11230 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11231 {
11232   if (h->root.type == bfd_link_hash_indirect)
11233     return TRUE;
11234
11235   merge_got_entries (&h->got.glist);
11236
11237   return TRUE;
11238 }
11239
11240 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11241    symbol H.  */
11242
11243 static bfd_boolean
11244 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11245 {
11246   struct got_entry *gent;
11247
11248   if (h->root.type == bfd_link_hash_indirect)
11249     return TRUE;
11250
11251   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11252     if (!gent->is_indirect)
11253       allocate_got (h, (struct bfd_link_info *) inf, gent);
11254   return TRUE;
11255 }
11256
11257 /* Called on the first multitoc pass after the last call to
11258    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11259    entries.  */
11260
11261 bfd_boolean
11262 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11263 {
11264   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11265   struct bfd *ibfd, *ibfd2;
11266   bfd_boolean done_something;
11267
11268   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11269
11270   if (!htab->do_multi_toc)
11271     return FALSE;
11272
11273   /* Merge global sym got entries within a toc group.  */
11274   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11275
11276   /* And tlsld_got.  */
11277   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11278     {
11279       struct got_entry *ent, *ent2;
11280
11281       if (!is_ppc64_elf (ibfd))
11282         continue;
11283
11284       ent = ppc64_tlsld_got (ibfd);
11285       if (!ent->is_indirect
11286           && ent->got.offset != (bfd_vma) -1)
11287         {
11288           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11289             {
11290               if (!is_ppc64_elf (ibfd2))
11291                 continue;
11292
11293               ent2 = ppc64_tlsld_got (ibfd2);
11294               if (!ent2->is_indirect
11295                   && ent2->got.offset != (bfd_vma) -1
11296                   && elf_gp (ibfd2) == elf_gp (ibfd))
11297                 {
11298                   ent2->is_indirect = TRUE;
11299                   ent2->got.ent = ent;
11300                 }
11301             }
11302         }
11303     }
11304
11305   /* Zap sizes of got sections.  */
11306   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11307   htab->elf.irelplt->size -= htab->got_reli_size;
11308   htab->got_reli_size = 0;
11309
11310   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11311     {
11312       asection *got, *relgot;
11313
11314       if (!is_ppc64_elf (ibfd))
11315         continue;
11316
11317       got = ppc64_elf_tdata (ibfd)->got;
11318       if (got != NULL)
11319         {
11320           got->rawsize = got->size;
11321           got->size = 0;
11322           relgot = ppc64_elf_tdata (ibfd)->relgot;
11323           relgot->rawsize = relgot->size;
11324           relgot->size = 0;
11325         }
11326     }
11327
11328   /* Now reallocate the got, local syms first.  We don't need to
11329      allocate section contents again since we never increase size.  */
11330   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11331     {
11332       struct got_entry **lgot_ents;
11333       struct got_entry **end_lgot_ents;
11334       struct plt_entry **local_plt;
11335       struct plt_entry **end_local_plt;
11336       unsigned char *lgot_masks;
11337       bfd_size_type locsymcount;
11338       Elf_Internal_Shdr *symtab_hdr;
11339       asection *s;
11340
11341       if (!is_ppc64_elf (ibfd))
11342         continue;
11343
11344       lgot_ents = elf_local_got_ents (ibfd);
11345       if (!lgot_ents)
11346         continue;
11347
11348       symtab_hdr = &elf_symtab_hdr (ibfd);
11349       locsymcount = symtab_hdr->sh_info;
11350       end_lgot_ents = lgot_ents + locsymcount;
11351       local_plt = (struct plt_entry **) end_lgot_ents;
11352       end_local_plt = local_plt + locsymcount;
11353       lgot_masks = (unsigned char *) end_local_plt;
11354       s = ppc64_elf_tdata (ibfd)->got;
11355       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11356         {
11357           struct got_entry *ent;
11358
11359           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11360             {
11361               unsigned int ent_size = 8;
11362               unsigned int rel_size = sizeof (Elf64_External_Rela);
11363
11364               ent->got.offset = s->size;
11365               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11366                 {
11367                   ent_size *= 2;
11368                   rel_size *= 2;
11369                 }
11370               s->size += ent_size;
11371               if ((*lgot_masks & PLT_IFUNC) != 0)
11372                 {
11373                   htab->elf.irelplt->size += rel_size;
11374                   htab->got_reli_size += rel_size;
11375                 }
11376               else if (info->shared)
11377                 {
11378                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11379                   srel->size += rel_size;
11380                 }
11381             }
11382         }
11383     }
11384
11385   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11386
11387   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11388     {
11389       struct got_entry *ent;
11390
11391       if (!is_ppc64_elf (ibfd))
11392         continue;
11393
11394       ent = ppc64_tlsld_got (ibfd);
11395       if (!ent->is_indirect
11396           && ent->got.offset != (bfd_vma) -1)
11397         {
11398           asection *s = ppc64_elf_tdata (ibfd)->got;
11399           ent->got.offset = s->size;
11400           s->size += 16;
11401           if (info->shared)
11402             {
11403               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11404               srel->size += sizeof (Elf64_External_Rela);
11405             }
11406         }
11407     }
11408
11409   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11410   if (!done_something)
11411     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11412       {
11413         asection *got;
11414
11415         if (!is_ppc64_elf (ibfd))
11416           continue;
11417
11418         got = ppc64_elf_tdata (ibfd)->got;
11419         if (got != NULL)
11420           {
11421             done_something = got->rawsize != got->size;
11422             if (done_something)
11423               break;
11424           }
11425       }
11426
11427   if (done_something)
11428     (*htab->params->layout_sections_again) ();
11429
11430   /* Set up for second pass over toc sections to recalculate elf_gp
11431      on input sections.  */
11432   htab->toc_bfd = NULL;
11433   htab->toc_first_sec = NULL;
11434   htab->second_toc_pass = TRUE;
11435   return done_something;
11436 }
11437
11438 /* Called after second pass of multitoc partitioning.  */
11439
11440 void
11441 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11442 {
11443   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11444
11445   /* After the second pass, toc_curr tracks the TOC offset used
11446      for code sections below in ppc64_elf_next_input_section.  */
11447   htab->toc_curr = TOC_BASE_OFF;
11448 }
11449
11450 /* No toc references were found in ISEC.  If the code in ISEC makes no
11451    calls, then there's no need to use toc adjusting stubs when branching
11452    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11453    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11454    needed, and 2 if a cyclical call-graph was found but no other reason
11455    for a stub was detected.  If called from the top level, a return of
11456    2 means the same as a return of 0.  */
11457
11458 static int
11459 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11460 {
11461   int ret;
11462
11463   /* Mark this section as checked.  */
11464   isec->call_check_done = 1;
11465
11466   /* We know none of our code bearing sections will need toc stubs.  */
11467   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11468     return 0;
11469
11470   if (isec->size == 0)
11471     return 0;
11472
11473   if (isec->output_section == NULL)
11474     return 0;
11475
11476   ret = 0;
11477   if (isec->reloc_count != 0)
11478     {
11479       Elf_Internal_Rela *relstart, *rel;
11480       Elf_Internal_Sym *local_syms;
11481       struct ppc_link_hash_table *htab;
11482
11483       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11484                                             info->keep_memory);
11485       if (relstart == NULL)
11486         return -1;
11487
11488       /* Look for branches to outside of this section.  */
11489       local_syms = NULL;
11490       htab = ppc_hash_table (info);
11491       if (htab == NULL)
11492         return -1;
11493
11494       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11495         {
11496           enum elf_ppc64_reloc_type r_type;
11497           unsigned long r_symndx;
11498           struct elf_link_hash_entry *h;
11499           struct ppc_link_hash_entry *eh;
11500           Elf_Internal_Sym *sym;
11501           asection *sym_sec;
11502           struct _opd_sec_data *opd;
11503           bfd_vma sym_value;
11504           bfd_vma dest;
11505
11506           r_type = ELF64_R_TYPE (rel->r_info);
11507           if (r_type != R_PPC64_REL24
11508               && r_type != R_PPC64_REL14
11509               && r_type != R_PPC64_REL14_BRTAKEN
11510               && r_type != R_PPC64_REL14_BRNTAKEN)
11511             continue;
11512
11513           r_symndx = ELF64_R_SYM (rel->r_info);
11514           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11515                           isec->owner))
11516             {
11517               ret = -1;
11518               break;
11519             }
11520
11521           /* Calls to dynamic lib functions go through a plt call stub
11522              that uses r2.  */
11523           eh = (struct ppc_link_hash_entry *) h;
11524           if (eh != NULL
11525               && (eh->elf.plt.plist != NULL
11526                   || (eh->oh != NULL
11527                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11528             {
11529               ret = 1;
11530               break;
11531             }
11532
11533           if (sym_sec == NULL)
11534             /* Ignore other undefined symbols.  */
11535             continue;
11536
11537           /* Assume branches to other sections not included in the
11538              link need stubs too, to cover -R and absolute syms.  */
11539           if (sym_sec->output_section == NULL)
11540             {
11541               ret = 1;
11542               break;
11543             }
11544
11545           if (h == NULL)
11546             sym_value = sym->st_value;
11547           else
11548             {
11549               if (h->root.type != bfd_link_hash_defined
11550                   && h->root.type != bfd_link_hash_defweak)
11551                 abort ();
11552               sym_value = h->root.u.def.value;
11553             }
11554           sym_value += rel->r_addend;
11555
11556           /* If this branch reloc uses an opd sym, find the code section.  */
11557           opd = get_opd_info (sym_sec);
11558           if (opd != NULL)
11559             {
11560               if (h == NULL && opd->adjust != NULL)
11561                 {
11562                   long adjust;
11563
11564                   adjust = opd->adjust[sym->st_value / 8];
11565                   if (adjust == -1)
11566                     /* Assume deleted functions won't ever be called.  */
11567                     continue;
11568                   sym_value += adjust;
11569                 }
11570
11571               dest = opd_entry_value (sym_sec, sym_value,
11572                                       &sym_sec, NULL, FALSE);
11573               if (dest == (bfd_vma) -1)
11574                 continue;
11575             }
11576           else
11577             dest = (sym_value
11578                     + sym_sec->output_offset
11579                     + sym_sec->output_section->vma);
11580
11581           /* Ignore branch to self.  */
11582           if (sym_sec == isec)
11583             continue;
11584
11585           /* If the called function uses the toc, we need a stub.  */
11586           if (sym_sec->has_toc_reloc
11587               || sym_sec->makes_toc_func_call)
11588             {
11589               ret = 1;
11590               break;
11591             }
11592
11593           /* Assume any branch that needs a long branch stub might in fact
11594              need a plt_branch stub.  A plt_branch stub uses r2.  */
11595           else if (dest - (isec->output_offset
11596                            + isec->output_section->vma
11597                            + rel->r_offset) + (1 << 25)
11598                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11599                                                              ? h->other
11600                                                              : sym->st_other))
11601             {
11602               ret = 1;
11603               break;
11604             }
11605
11606           /* If calling back to a section in the process of being
11607              tested, we can't say for sure that no toc adjusting stubs
11608              are needed, so don't return zero.  */
11609           else if (sym_sec->call_check_in_progress)
11610             ret = 2;
11611
11612           /* Branches to another section that itself doesn't have any TOC
11613              references are OK.  Recursively call ourselves to check.  */
11614           else if (!sym_sec->call_check_done)
11615             {
11616               int recur;
11617
11618               /* Mark current section as indeterminate, so that other
11619                  sections that call back to current won't be marked as
11620                  known.  */
11621               isec->call_check_in_progress = 1;
11622               recur = toc_adjusting_stub_needed (info, sym_sec);
11623               isec->call_check_in_progress = 0;
11624
11625               if (recur != 0)
11626                 {
11627                   ret = recur;
11628                   if (recur != 2)
11629                     break;
11630                 }
11631             }
11632         }
11633
11634       if (local_syms != NULL
11635           && (elf_symtab_hdr (isec->owner).contents
11636               != (unsigned char *) local_syms))
11637         free (local_syms);
11638       if (elf_section_data (isec)->relocs != relstart)
11639         free (relstart);
11640     }
11641
11642   if ((ret & 1) == 0
11643       && isec->map_head.s != NULL
11644       && (strcmp (isec->output_section->name, ".init") == 0
11645           || strcmp (isec->output_section->name, ".fini") == 0))
11646     {
11647       if (isec->map_head.s->has_toc_reloc
11648           || isec->map_head.s->makes_toc_func_call)
11649         ret = 1;
11650       else if (!isec->map_head.s->call_check_done)
11651         {
11652           int recur;
11653           isec->call_check_in_progress = 1;
11654           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11655           isec->call_check_in_progress = 0;
11656           if (recur != 0)
11657             ret = recur;
11658         }
11659     }
11660
11661   if (ret == 1)
11662     isec->makes_toc_func_call = 1;
11663
11664   return ret;
11665 }
11666
11667 /* The linker repeatedly calls this function for each input section,
11668    in the order that input sections are linked into output sections.
11669    Build lists of input sections to determine groupings between which
11670    we may insert linker stubs.  */
11671
11672 bfd_boolean
11673 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11674 {
11675   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11676
11677   if (htab == NULL)
11678     return FALSE;
11679
11680   if ((isec->output_section->flags & SEC_CODE) != 0
11681       && isec->output_section->index <= htab->top_index)
11682     {
11683       asection **list = htab->input_list + isec->output_section->index;
11684       /* Steal the link_sec pointer for our list.  */
11685 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11686       /* This happens to make the list in reverse order,
11687          which is what we want.  */
11688       PREV_SEC (isec) = *list;
11689       *list = isec;
11690     }
11691
11692   if (htab->multi_toc_needed)
11693     {
11694       /* Analyse sections that aren't already flagged as needing a
11695          valid toc pointer.  Exclude .fixup for the linux kernel.
11696          .fixup contains branches, but only back to the function that
11697          hit an exception.  */
11698       if (!(isec->has_toc_reloc
11699             || (isec->flags & SEC_CODE) == 0
11700             || strcmp (isec->name, ".fixup") == 0
11701             || isec->call_check_done))
11702         {
11703           if (toc_adjusting_stub_needed (info, isec) < 0)
11704             return FALSE;
11705         }
11706       /* Make all sections use the TOC assigned for this object file.
11707          This will be wrong for pasted sections;  We fix that in
11708          check_pasted_section().  */
11709       if (elf_gp (isec->owner) != 0)
11710         htab->toc_curr = elf_gp (isec->owner);
11711     }
11712
11713   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11714   return TRUE;
11715 }
11716
11717 /* Check that all .init and .fini sections use the same toc, if they
11718    have toc relocs.  */
11719
11720 static bfd_boolean
11721 check_pasted_section (struct bfd_link_info *info, const char *name)
11722 {
11723   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11724
11725   if (o != NULL)
11726     {
11727       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11728       bfd_vma toc_off = 0;
11729       asection *i;
11730
11731       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11732         if (i->has_toc_reloc)
11733           {
11734             if (toc_off == 0)
11735               toc_off = htab->stub_group[i->id].toc_off;
11736             else if (toc_off != htab->stub_group[i->id].toc_off)
11737               return FALSE;
11738           }
11739
11740       if (toc_off == 0)
11741         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11742           if (i->makes_toc_func_call)
11743             {
11744               toc_off = htab->stub_group[i->id].toc_off;
11745               break;
11746             }
11747
11748       /* Make sure the whole pasted function uses the same toc offset.  */
11749       if (toc_off != 0)
11750         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11751           htab->stub_group[i->id].toc_off = toc_off;
11752     }
11753   return TRUE;
11754 }
11755
11756 bfd_boolean
11757 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11758 {
11759   return (check_pasted_section (info, ".init")
11760           & check_pasted_section (info, ".fini"));
11761 }
11762
11763 /* See whether we can group stub sections together.  Grouping stub
11764    sections may result in fewer stubs.  More importantly, we need to
11765    put all .init* and .fini* stubs at the beginning of the .init or
11766    .fini output sections respectively, because glibc splits the
11767    _init and _fini functions into multiple parts.  Putting a stub in
11768    the middle of a function is not a good idea.  */
11769
11770 static void
11771 group_sections (struct ppc_link_hash_table *htab,
11772                 bfd_size_type stub_group_size,
11773                 bfd_boolean stubs_always_before_branch)
11774 {
11775   asection **list;
11776   bfd_size_type stub14_group_size;
11777   bfd_boolean suppress_size_errors;
11778
11779   suppress_size_errors = FALSE;
11780   stub14_group_size = stub_group_size;
11781   if (stub_group_size == 1)
11782     {
11783       /* Default values.  */
11784       if (stubs_always_before_branch)
11785         {
11786           stub_group_size = 0x1e00000;
11787           stub14_group_size = 0x7800;
11788         }
11789       else
11790         {
11791           stub_group_size = 0x1c00000;
11792           stub14_group_size = 0x7000;
11793         }
11794       suppress_size_errors = TRUE;
11795     }
11796
11797   list = htab->input_list + htab->top_index;
11798   do
11799     {
11800       asection *tail = *list;
11801       while (tail != NULL)
11802         {
11803           asection *curr;
11804           asection *prev;
11805           bfd_size_type total;
11806           bfd_boolean big_sec;
11807           bfd_vma curr_toc;
11808
11809           curr = tail;
11810           total = tail->size;
11811           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11812                              && ppc64_elf_section_data (tail)->has_14bit_branch
11813                              ? stub14_group_size : stub_group_size);
11814           if (big_sec && !suppress_size_errors)
11815             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11816                                      tail->owner, tail);
11817           curr_toc = htab->stub_group[tail->id].toc_off;
11818
11819           while ((prev = PREV_SEC (curr)) != NULL
11820                  && ((total += curr->output_offset - prev->output_offset)
11821                      < (ppc64_elf_section_data (prev) != NULL
11822                         && ppc64_elf_section_data (prev)->has_14bit_branch
11823                         ? stub14_group_size : stub_group_size))
11824                  && htab->stub_group[prev->id].toc_off == curr_toc)
11825             curr = prev;
11826
11827           /* OK, the size from the start of CURR to the end is less
11828              than stub_group_size and thus can be handled by one stub
11829              section.  (or the tail section is itself larger than
11830              stub_group_size, in which case we may be toast.)  We
11831              should really be keeping track of the total size of stubs
11832              added here, as stubs contribute to the final output
11833              section size.  That's a little tricky, and this way will
11834              only break if stubs added make the total size more than
11835              2^25, ie. for the default stub_group_size, if stubs total
11836              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11837           do
11838             {
11839               prev = PREV_SEC (tail);
11840               /* Set up this stub group.  */
11841               htab->stub_group[tail->id].link_sec = curr;
11842             }
11843           while (tail != curr && (tail = prev) != NULL);
11844
11845           /* But wait, there's more!  Input sections up to stub_group_size
11846              bytes before the stub section can be handled by it too.
11847              Don't do this if we have a really large section after the
11848              stubs, as adding more stubs increases the chance that
11849              branches may not reach into the stub section.  */
11850           if (!stubs_always_before_branch && !big_sec)
11851             {
11852               total = 0;
11853               while (prev != NULL
11854                      && ((total += tail->output_offset - prev->output_offset)
11855                          < (ppc64_elf_section_data (prev) != NULL
11856                             && ppc64_elf_section_data (prev)->has_14bit_branch
11857                             ? stub14_group_size : stub_group_size))
11858                      && htab->stub_group[prev->id].toc_off == curr_toc)
11859                 {
11860                   tail = prev;
11861                   prev = PREV_SEC (tail);
11862                   htab->stub_group[tail->id].link_sec = curr;
11863                 }
11864             }
11865           tail = prev;
11866         }
11867     }
11868   while (list-- != htab->input_list);
11869   free (htab->input_list);
11870 #undef PREV_SEC
11871 }
11872
11873 static const unsigned char glink_eh_frame_cie[] =
11874 {
11875   0, 0, 0, 16,                          /* length.  */
11876   0, 0, 0, 0,                           /* id.  */
11877   1,                                    /* CIE version.  */
11878   'z', 'R', 0,                          /* Augmentation string.  */
11879   4,                                    /* Code alignment.  */
11880   0x78,                                 /* Data alignment.  */
11881   65,                                   /* RA reg.  */
11882   1,                                    /* Augmentation size.  */
11883   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11884   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11885 };
11886
11887 /* Stripping output sections is normally done before dynamic section
11888    symbols have been allocated.  This function is called later, and
11889    handles cases like htab->brlt which is mapped to its own output
11890    section.  */
11891
11892 static void
11893 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11894 {
11895   if (isec->size == 0
11896       && isec->output_section->size == 0
11897       && !(isec->output_section->flags & SEC_KEEP)
11898       && !bfd_section_removed_from_list (info->output_bfd,
11899                                          isec->output_section)
11900       && elf_section_data (isec->output_section)->dynindx == 0)
11901     {
11902       isec->output_section->flags |= SEC_EXCLUDE;
11903       bfd_section_list_remove (info->output_bfd, isec->output_section);
11904       info->output_bfd->section_count--;
11905     }
11906 }
11907
11908 /* Determine and set the size of the stub section for a final link.
11909
11910    The basic idea here is to examine all the relocations looking for
11911    PC-relative calls to a target that is unreachable with a "bl"
11912    instruction.  */
11913
11914 bfd_boolean
11915 ppc64_elf_size_stubs (struct bfd_link_info *info)
11916 {
11917   bfd_size_type stub_group_size;
11918   bfd_boolean stubs_always_before_branch;
11919   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11920
11921   if (htab == NULL)
11922     return FALSE;
11923
11924   if (htab->params->plt_thread_safe == -1 && !info->executable)
11925     htab->params->plt_thread_safe = 1;
11926   if (!htab->opd_abi)
11927     htab->params->plt_thread_safe = 0;
11928   else if (htab->params->plt_thread_safe == -1)
11929     {
11930       static const char *const thread_starter[] =
11931         {
11932           "pthread_create",
11933           /* libstdc++ */
11934           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11935           /* librt */
11936           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11937           "mq_notify", "create_timer",
11938           /* libanl */
11939           "getaddrinfo_a",
11940           /* libgomp */
11941           "GOMP_parallel_start",
11942           "GOMP_parallel_loop_static_start",
11943           "GOMP_parallel_loop_dynamic_start",
11944           "GOMP_parallel_loop_guided_start",
11945           "GOMP_parallel_loop_runtime_start",
11946           "GOMP_parallel_sections_start",
11947         };
11948       unsigned i;
11949
11950       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11951         {
11952           struct elf_link_hash_entry *h;
11953           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11954                                     FALSE, FALSE, TRUE);
11955           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11956           if (htab->params->plt_thread_safe)
11957             break;
11958         }
11959     }
11960   stubs_always_before_branch = htab->params->group_size < 0;
11961   if (htab->params->group_size < 0)
11962     stub_group_size = -htab->params->group_size;
11963   else
11964     stub_group_size = htab->params->group_size;
11965
11966   group_sections (htab, stub_group_size, stubs_always_before_branch);
11967
11968   while (1)
11969     {
11970       bfd *input_bfd;
11971       unsigned int bfd_indx;
11972       asection *stub_sec;
11973
11974       htab->stub_iteration += 1;
11975
11976       for (input_bfd = info->input_bfds, bfd_indx = 0;
11977            input_bfd != NULL;
11978            input_bfd = input_bfd->link.next, bfd_indx++)
11979         {
11980           Elf_Internal_Shdr *symtab_hdr;
11981           asection *section;
11982           Elf_Internal_Sym *local_syms = NULL;
11983
11984           if (!is_ppc64_elf (input_bfd))
11985             continue;
11986
11987           /* We'll need the symbol table in a second.  */
11988           symtab_hdr = &elf_symtab_hdr (input_bfd);
11989           if (symtab_hdr->sh_info == 0)
11990             continue;
11991
11992           /* Walk over each section attached to the input bfd.  */
11993           for (section = input_bfd->sections;
11994                section != NULL;
11995                section = section->next)
11996             {
11997               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11998
11999               /* If there aren't any relocs, then there's nothing more
12000                  to do.  */
12001               if ((section->flags & SEC_RELOC) == 0
12002                   || (section->flags & SEC_ALLOC) == 0
12003                   || (section->flags & SEC_LOAD) == 0
12004                   || (section->flags & SEC_CODE) == 0
12005                   || section->reloc_count == 0)
12006                 continue;
12007
12008               /* If this section is a link-once section that will be
12009                  discarded, then don't create any stubs.  */
12010               if (section->output_section == NULL
12011                   || section->output_section->owner != info->output_bfd)
12012                 continue;
12013
12014               /* Get the relocs.  */
12015               internal_relocs
12016                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12017                                              info->keep_memory);
12018               if (internal_relocs == NULL)
12019                 goto error_ret_free_local;
12020
12021               /* Now examine each relocation.  */
12022               irela = internal_relocs;
12023               irelaend = irela + section->reloc_count;
12024               for (; irela < irelaend; irela++)
12025                 {
12026                   enum elf_ppc64_reloc_type r_type;
12027                   unsigned int r_indx;
12028                   enum ppc_stub_type stub_type;
12029                   struct ppc_stub_hash_entry *stub_entry;
12030                   asection *sym_sec, *code_sec;
12031                   bfd_vma sym_value, code_value;
12032                   bfd_vma destination;
12033                   unsigned long local_off;
12034                   bfd_boolean ok_dest;
12035                   struct ppc_link_hash_entry *hash;
12036                   struct ppc_link_hash_entry *fdh;
12037                   struct elf_link_hash_entry *h;
12038                   Elf_Internal_Sym *sym;
12039                   char *stub_name;
12040                   const asection *id_sec;
12041                   struct _opd_sec_data *opd;
12042                   struct plt_entry *plt_ent;
12043
12044                   r_type = ELF64_R_TYPE (irela->r_info);
12045                   r_indx = ELF64_R_SYM (irela->r_info);
12046
12047                   if (r_type >= R_PPC64_max)
12048                     {
12049                       bfd_set_error (bfd_error_bad_value);
12050                       goto error_ret_free_internal;
12051                     }
12052
12053                   /* Only look for stubs on branch instructions.  */
12054                   if (r_type != R_PPC64_REL24
12055                       && r_type != R_PPC64_REL14
12056                       && r_type != R_PPC64_REL14_BRTAKEN
12057                       && r_type != R_PPC64_REL14_BRNTAKEN)
12058                     continue;
12059
12060                   /* Now determine the call target, its name, value,
12061                      section.  */
12062                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12063                                   r_indx, input_bfd))
12064                     goto error_ret_free_internal;
12065                   hash = (struct ppc_link_hash_entry *) h;
12066
12067                   ok_dest = FALSE;
12068                   fdh = NULL;
12069                   sym_value = 0;
12070                   if (hash == NULL)
12071                     {
12072                       sym_value = sym->st_value;
12073                       ok_dest = TRUE;
12074                     }
12075                   else if (hash->elf.root.type == bfd_link_hash_defined
12076                            || hash->elf.root.type == bfd_link_hash_defweak)
12077                     {
12078                       sym_value = hash->elf.root.u.def.value;
12079                       if (sym_sec->output_section != NULL)
12080                         ok_dest = TRUE;
12081                     }
12082                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12083                            || hash->elf.root.type == bfd_link_hash_undefined)
12084                     {
12085                       /* Recognise an old ABI func code entry sym, and
12086                          use the func descriptor sym instead if it is
12087                          defined.  */
12088                       if (hash->elf.root.root.string[0] == '.'
12089                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12090                         {
12091                           if (fdh->elf.root.type == bfd_link_hash_defined
12092                               || fdh->elf.root.type == bfd_link_hash_defweak)
12093                             {
12094                               sym_sec = fdh->elf.root.u.def.section;
12095                               sym_value = fdh->elf.root.u.def.value;
12096                               if (sym_sec->output_section != NULL)
12097                                 ok_dest = TRUE;
12098                             }
12099                           else
12100                             fdh = NULL;
12101                         }
12102                     }
12103                   else
12104                     {
12105                       bfd_set_error (bfd_error_bad_value);
12106                       goto error_ret_free_internal;
12107                     }
12108
12109                   destination = 0;
12110                   local_off = 0;
12111                   if (ok_dest)
12112                     {
12113                       sym_value += irela->r_addend;
12114                       destination = (sym_value
12115                                      + sym_sec->output_offset
12116                                      + sym_sec->output_section->vma);
12117                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12118                                                             ? hash->elf.other
12119                                                             : sym->st_other);
12120                     }
12121
12122                   code_sec = sym_sec;
12123                   code_value = sym_value;
12124                   opd = get_opd_info (sym_sec);
12125                   if (opd != NULL)
12126                     {
12127                       bfd_vma dest;
12128
12129                       if (hash == NULL && opd->adjust != NULL)
12130                         {
12131                           long adjust = opd->adjust[sym_value / 8];
12132                           if (adjust == -1)
12133                             continue;
12134                           code_value += adjust;
12135                           sym_value += adjust;
12136                         }
12137                       dest = opd_entry_value (sym_sec, sym_value,
12138                                               &code_sec, &code_value, FALSE);
12139                       if (dest != (bfd_vma) -1)
12140                         {
12141                           destination = dest;
12142                           if (fdh != NULL)
12143                             {
12144                               /* Fixup old ABI sym to point at code
12145                                  entry.  */
12146                               hash->elf.root.type = bfd_link_hash_defweak;
12147                               hash->elf.root.u.def.section = code_sec;
12148                               hash->elf.root.u.def.value = code_value;
12149                             }
12150                         }
12151                     }
12152
12153                   /* Determine what (if any) linker stub is needed.  */
12154                   plt_ent = NULL;
12155                   stub_type = ppc_type_of_stub (section, irela, &hash,
12156                                                 &plt_ent, destination,
12157                                                 local_off);
12158
12159                   if (stub_type != ppc_stub_plt_call)
12160                     {
12161                       /* Check whether we need a TOC adjusting stub.
12162                          Since the linker pastes together pieces from
12163                          different object files when creating the
12164                          _init and _fini functions, it may be that a
12165                          call to what looks like a local sym is in
12166                          fact a call needing a TOC adjustment.  */
12167                       if (code_sec != NULL
12168                           && code_sec->output_section != NULL
12169                           && (htab->stub_group[code_sec->id].toc_off
12170                               != htab->stub_group[section->id].toc_off)
12171                           && (code_sec->has_toc_reloc
12172                               || code_sec->makes_toc_func_call))
12173                         stub_type = ppc_stub_long_branch_r2off;
12174                     }
12175
12176                   if (stub_type == ppc_stub_none)
12177                     continue;
12178
12179                   /* __tls_get_addr calls might be eliminated.  */
12180                   if (stub_type != ppc_stub_plt_call
12181                       && hash != NULL
12182                       && (hash == htab->tls_get_addr
12183                           || hash == htab->tls_get_addr_fd)
12184                       && section->has_tls_reloc
12185                       && irela != internal_relocs)
12186                     {
12187                       /* Get tls info.  */
12188                       unsigned char *tls_mask;
12189
12190                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12191                                          irela - 1, input_bfd))
12192                         goto error_ret_free_internal;
12193                       if (*tls_mask != 0)
12194                         continue;
12195                     }
12196
12197                   if (stub_type == ppc_stub_plt_call
12198                       && irela + 1 < irelaend
12199                       && irela[1].r_offset == irela->r_offset + 4
12200                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12201                     {
12202                       if (!tocsave_find (htab, INSERT,
12203                                          &local_syms, irela + 1, input_bfd))
12204                         goto error_ret_free_internal;
12205                     }
12206                   else if (stub_type == ppc_stub_plt_call)
12207                     stub_type = ppc_stub_plt_call_r2save;
12208
12209                   /* Support for grouping stub sections.  */
12210                   id_sec = htab->stub_group[section->id].link_sec;
12211
12212                   /* Get the name of this stub.  */
12213                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12214                   if (!stub_name)
12215                     goto error_ret_free_internal;
12216
12217                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12218                                                      stub_name, FALSE, FALSE);
12219                   if (stub_entry != NULL)
12220                     {
12221                       /* The proper stub has already been created.  */
12222                       free (stub_name);
12223                       if (stub_type == ppc_stub_plt_call_r2save)
12224                         stub_entry->stub_type = stub_type;
12225                       continue;
12226                     }
12227
12228                   stub_entry = ppc_add_stub (stub_name, section, info);
12229                   if (stub_entry == NULL)
12230                     {
12231                       free (stub_name);
12232                     error_ret_free_internal:
12233                       if (elf_section_data (section)->relocs == NULL)
12234                         free (internal_relocs);
12235                     error_ret_free_local:
12236                       if (local_syms != NULL
12237                           && (symtab_hdr->contents
12238                               != (unsigned char *) local_syms))
12239                         free (local_syms);
12240                       return FALSE;
12241                     }
12242
12243                   stub_entry->stub_type = stub_type;
12244                   if (stub_type != ppc_stub_plt_call
12245                       && stub_type != ppc_stub_plt_call_r2save)
12246                     {
12247                       stub_entry->target_value = code_value;
12248                       stub_entry->target_section = code_sec;
12249                     }
12250                   else
12251                     {
12252                       stub_entry->target_value = sym_value;
12253                       stub_entry->target_section = sym_sec;
12254                     }
12255                   stub_entry->h = hash;
12256                   stub_entry->plt_ent = plt_ent;
12257                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12258
12259                   if (stub_entry->h != NULL)
12260                     htab->stub_globals += 1;
12261                 }
12262
12263               /* We're done with the internal relocs, free them.  */
12264               if (elf_section_data (section)->relocs != internal_relocs)
12265                 free (internal_relocs);
12266             }
12267
12268           if (local_syms != NULL
12269               && symtab_hdr->contents != (unsigned char *) local_syms)
12270             {
12271               if (!info->keep_memory)
12272                 free (local_syms);
12273               else
12274                 symtab_hdr->contents = (unsigned char *) local_syms;
12275             }
12276         }
12277
12278       /* We may have added some stubs.  Find out the new size of the
12279          stub sections.  */
12280       for (stub_sec = htab->params->stub_bfd->sections;
12281            stub_sec != NULL;
12282            stub_sec = stub_sec->next)
12283         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12284           {
12285             stub_sec->rawsize = stub_sec->size;
12286             stub_sec->size = 0;
12287             stub_sec->reloc_count = 0;
12288             stub_sec->flags &= ~SEC_RELOC;
12289           }
12290
12291       htab->brlt->size = 0;
12292       htab->brlt->reloc_count = 0;
12293       htab->brlt->flags &= ~SEC_RELOC;
12294       if (htab->relbrlt != NULL)
12295         htab->relbrlt->size = 0;
12296
12297       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12298
12299       if (info->emitrelocations
12300           && htab->glink != NULL && htab->glink->size != 0)
12301         {
12302           htab->glink->reloc_count = 1;
12303           htab->glink->flags |= SEC_RELOC;
12304         }
12305
12306       if (htab->glink_eh_frame != NULL
12307           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12308           && htab->glink_eh_frame->output_section->size != 0)
12309         {
12310           size_t size = 0, align;
12311
12312           for (stub_sec = htab->params->stub_bfd->sections;
12313                stub_sec != NULL;
12314                stub_sec = stub_sec->next)
12315             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12316               size += 20;
12317           if (htab->glink != NULL && htab->glink->size != 0)
12318             size += 24;
12319           if (size != 0)
12320             size += sizeof (glink_eh_frame_cie);
12321           align = 1;
12322           align <<= htab->glink_eh_frame->output_section->alignment_power;
12323           align -= 1;
12324           size = (size + align) & ~align;
12325           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12326           htab->glink_eh_frame->size = size;
12327         }
12328
12329       if (htab->params->plt_stub_align != 0)
12330         for (stub_sec = htab->params->stub_bfd->sections;
12331              stub_sec != NULL;
12332              stub_sec = stub_sec->next)
12333           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12334             stub_sec->size = ((stub_sec->size
12335                                + (1 << htab->params->plt_stub_align) - 1)
12336                               & (-1 << htab->params->plt_stub_align));
12337
12338       for (stub_sec = htab->params->stub_bfd->sections;
12339            stub_sec != NULL;
12340            stub_sec = stub_sec->next)
12341         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12342             && stub_sec->rawsize != stub_sec->size)
12343           break;
12344
12345       /* Exit from this loop when no stubs have been added, and no stubs
12346          have changed size.  */
12347       if (stub_sec == NULL
12348           && (htab->glink_eh_frame == NULL
12349               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12350         break;
12351
12352       /* Ask the linker to do its stuff.  */
12353       (*htab->params->layout_sections_again) ();
12354     }
12355
12356   maybe_strip_output (info, htab->brlt);
12357   if (htab->glink_eh_frame != NULL)
12358     maybe_strip_output (info, htab->glink_eh_frame);
12359
12360   return TRUE;
12361 }
12362
12363 /* Called after we have determined section placement.  If sections
12364    move, we'll be called again.  Provide a value for TOCstart.  */
12365
12366 bfd_vma
12367 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12368 {
12369   asection *s;
12370   bfd_vma TOCstart;
12371
12372   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12373      order.  The TOC starts where the first of these sections starts.  */
12374   s = bfd_get_section_by_name (obfd, ".got");
12375   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12376     s = bfd_get_section_by_name (obfd, ".toc");
12377   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12378     s = bfd_get_section_by_name (obfd, ".tocbss");
12379   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12380     s = bfd_get_section_by_name (obfd, ".plt");
12381   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12382     {
12383       /* This may happen for
12384          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12385          .toc directive
12386          o  bad linker script
12387          o --gc-sections and empty TOC sections
12388
12389          FIXME: Warn user?  */
12390
12391       /* Look for a likely section.  We probably won't even be
12392          using TOCstart.  */
12393       for (s = obfd->sections; s != NULL; s = s->next)
12394         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12395                          | SEC_EXCLUDE))
12396             == (SEC_ALLOC | SEC_SMALL_DATA))
12397           break;
12398       if (s == NULL)
12399         for (s = obfd->sections; s != NULL; s = s->next)
12400           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12401               == (SEC_ALLOC | SEC_SMALL_DATA))
12402             break;
12403       if (s == NULL)
12404         for (s = obfd->sections; s != NULL; s = s->next)
12405           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12406               == SEC_ALLOC)
12407             break;
12408       if (s == NULL)
12409         for (s = obfd->sections; s != NULL; s = s->next)
12410           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12411             break;
12412     }
12413
12414   TOCstart = 0;
12415   if (s != NULL)
12416     TOCstart = s->output_section->vma + s->output_offset;
12417
12418   _bfd_set_gp_value (obfd, TOCstart);
12419
12420   if (info != NULL && s != NULL)
12421     {
12422       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12423
12424       if (htab != NULL)
12425         {
12426           if (htab->elf.hgot != NULL)
12427             {
12428               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12429               htab->elf.hgot->root.u.def.section = s;
12430             }
12431         }
12432       else
12433         {
12434           struct bfd_link_hash_entry *bh = NULL;
12435           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12436                                             s, TOC_BASE_OFF, NULL, FALSE,
12437                                             FALSE, &bh);
12438         }
12439     }
12440   return TOCstart;
12441 }
12442
12443 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12444    write out any global entry stubs.  */
12445
12446 static bfd_boolean
12447 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12448 {
12449   struct bfd_link_info *info;
12450   struct ppc_link_hash_table *htab;
12451   struct plt_entry *pent;
12452   asection *s;
12453
12454   if (h->root.type == bfd_link_hash_indirect)
12455     return TRUE;
12456
12457   if (!h->pointer_equality_needed)
12458     return TRUE;
12459
12460   if (h->def_regular)
12461     return TRUE;
12462
12463   info = inf;
12464   htab = ppc_hash_table (info);
12465   if (htab == NULL)
12466     return FALSE;
12467
12468   s = htab->glink;
12469   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12470     if (pent->plt.offset != (bfd_vma) -1
12471         && pent->addend == 0)
12472       {
12473         bfd_byte *p;
12474         asection *plt;
12475         bfd_vma off;
12476
12477         p = s->contents + h->root.u.def.value;
12478         plt = htab->elf.splt;
12479         if (!htab->elf.dynamic_sections_created
12480             || h->dynindx == -1)
12481           plt = htab->elf.iplt;
12482         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12483         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12484
12485         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12486           {
12487             info->callbacks->einfo
12488               (_("%P: linkage table error against `%T'\n"),
12489                h->root.root.string);
12490             bfd_set_error (bfd_error_bad_value);
12491             htab->stub_error = TRUE;
12492           }
12493
12494         if (PPC_HA (off) != 0)
12495           {
12496             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12497             p += 4;
12498           }
12499         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12500         p += 4;
12501         bfd_put_32 (s->owner, MTCTR_R12, p);
12502         p += 4;
12503         bfd_put_32 (s->owner, BCTR, p);
12504         break;
12505       }
12506   return TRUE;
12507 }
12508
12509 /* Build all the stubs associated with the current output file.
12510    The stubs are kept in a hash table attached to the main linker
12511    hash table.  This function is called via gldelf64ppc_finish.  */
12512
12513 bfd_boolean
12514 ppc64_elf_build_stubs (struct bfd_link_info *info,
12515                        char **stats)
12516 {
12517   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12518   asection *stub_sec;
12519   bfd_byte *p;
12520   int stub_sec_count = 0;
12521
12522   if (htab == NULL)
12523     return FALSE;
12524
12525   /* Allocate memory to hold the linker stubs.  */
12526   for (stub_sec = htab->params->stub_bfd->sections;
12527        stub_sec != NULL;
12528        stub_sec = stub_sec->next)
12529     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12530         && stub_sec->size != 0)
12531       {
12532         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12533         if (stub_sec->contents == NULL)
12534           return FALSE;
12535         /* We want to check that built size is the same as calculated
12536            size.  rawsize is a convenient location to use.  */
12537         stub_sec->rawsize = stub_sec->size;
12538         stub_sec->size = 0;
12539       }
12540
12541   if (htab->glink != NULL && htab->glink->size != 0)
12542     {
12543       unsigned int indx;
12544       bfd_vma plt0;
12545
12546       /* Build the .glink plt call stub.  */
12547       if (htab->params->emit_stub_syms)
12548         {
12549           struct elf_link_hash_entry *h;
12550           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12551                                     TRUE, FALSE, FALSE);
12552           if (h == NULL)
12553             return FALSE;
12554           if (h->root.type == bfd_link_hash_new)
12555             {
12556               h->root.type = bfd_link_hash_defined;
12557               h->root.u.def.section = htab->glink;
12558               h->root.u.def.value = 8;
12559               h->ref_regular = 1;
12560               h->def_regular = 1;
12561               h->ref_regular_nonweak = 1;
12562               h->forced_local = 1;
12563               h->non_elf = 0;
12564             }
12565         }
12566       plt0 = (htab->elf.splt->output_section->vma
12567               + htab->elf.splt->output_offset
12568               - 16);
12569       if (info->emitrelocations)
12570         {
12571           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12572           if (r == NULL)
12573             return FALSE;
12574           r->r_offset = (htab->glink->output_offset
12575                          + htab->glink->output_section->vma);
12576           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12577           r->r_addend = plt0;
12578         }
12579       p = htab->glink->contents;
12580       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12581       bfd_put_64 (htab->glink->owner, plt0, p);
12582       p += 8;
12583       if (htab->opd_abi)
12584         {
12585           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12586           p += 4;
12587           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12588           p += 4;
12589           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12590           p += 4;
12591           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12592           p += 4;
12593           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12594           p += 4;
12595           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12596           p += 4;
12597           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12598           p += 4;
12599           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12600           p += 4;
12601           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12602           p += 4;
12603           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12604           p += 4;
12605         }
12606       else
12607         {
12608           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12609           p += 4;
12610           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12611           p += 4;
12612           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12613           p += 4;
12614           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12615           p += 4;
12616           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12617           p += 4;
12618           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12619           p += 4;
12620           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12621           p += 4;
12622           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12623           p += 4;
12624           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12625           p += 4;
12626           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12627           p += 4;
12628           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12629           p += 4;
12630           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12631           p += 4;
12632         }
12633       bfd_put_32 (htab->glink->owner, BCTR, p);
12634       p += 4;
12635       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12636         {
12637           bfd_put_32 (htab->glink->owner, NOP, p);
12638           p += 4;
12639         }
12640
12641       /* Build the .glink lazy link call stubs.  */
12642       indx = 0;
12643       while (p < htab->glink->contents + htab->glink->rawsize)
12644         {
12645           if (htab->opd_abi)
12646             {
12647               if (indx < 0x8000)
12648                 {
12649                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12650                   p += 4;
12651                 }
12652               else
12653                 {
12654                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12655                   p += 4;
12656                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12657                               p);
12658                   p += 4;
12659                 }
12660             }
12661           bfd_put_32 (htab->glink->owner,
12662                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12663           indx++;
12664           p += 4;
12665         }
12666
12667       /* Build .glink global entry stubs.  */
12668       if (htab->glink->size > htab->glink->rawsize)
12669         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12670     }
12671
12672   if (htab->brlt->size != 0)
12673     {
12674       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12675                                          htab->brlt->size);
12676       if (htab->brlt->contents == NULL)
12677         return FALSE;
12678     }
12679   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12680     {
12681       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12682                                             htab->relbrlt->size);
12683       if (htab->relbrlt->contents == NULL)
12684         return FALSE;
12685     }
12686
12687   if (htab->glink_eh_frame != NULL
12688       && htab->glink_eh_frame->size != 0)
12689     {
12690       bfd_vma val;
12691       bfd_byte *last_fde;
12692       size_t last_fde_len, size, align, pad;
12693
12694       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12695       if (p == NULL)
12696         return FALSE;
12697       htab->glink_eh_frame->contents = p;
12698       last_fde = p;
12699
12700       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12701
12702       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12703       /* CIE length (rewrite in case little-endian).  */
12704       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12705       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12706       p += sizeof (glink_eh_frame_cie);
12707
12708       for (stub_sec = htab->params->stub_bfd->sections;
12709            stub_sec != NULL;
12710            stub_sec = stub_sec->next)
12711         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12712           {
12713             last_fde = p;
12714             last_fde_len = 16;
12715             /* FDE length.  */
12716             bfd_put_32 (htab->elf.dynobj, 16, p);
12717             p += 4;
12718             /* CIE pointer.  */
12719             val = p - htab->glink_eh_frame->contents;
12720             bfd_put_32 (htab->elf.dynobj, val, p);
12721             p += 4;
12722             /* Offset to stub section.  */
12723             val = (stub_sec->output_section->vma
12724                    + stub_sec->output_offset);
12725             val -= (htab->glink_eh_frame->output_section->vma
12726                     + htab->glink_eh_frame->output_offset);
12727             val -= p - htab->glink_eh_frame->contents;
12728             if (val + 0x80000000 > 0xffffffff)
12729               {
12730                 info->callbacks->einfo
12731                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12732                    stub_sec->name);
12733                 return FALSE;
12734               }
12735             bfd_put_32 (htab->elf.dynobj, val, p);
12736             p += 4;
12737             /* stub section size.  */
12738             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12739             p += 4;
12740             /* Augmentation.  */
12741             p += 1;
12742             /* Pad.  */
12743             p += 3;
12744           }
12745       if (htab->glink != NULL && htab->glink->size != 0)
12746         {
12747           last_fde = p;
12748           last_fde_len = 20;
12749           /* FDE length.  */
12750           bfd_put_32 (htab->elf.dynobj, 20, p);
12751           p += 4;
12752           /* CIE pointer.  */
12753           val = p - htab->glink_eh_frame->contents;
12754           bfd_put_32 (htab->elf.dynobj, val, p);
12755           p += 4;
12756           /* Offset to .glink.  */
12757           val = (htab->glink->output_section->vma
12758                  + htab->glink->output_offset
12759                  + 8);
12760           val -= (htab->glink_eh_frame->output_section->vma
12761                   + htab->glink_eh_frame->output_offset);
12762           val -= p - htab->glink_eh_frame->contents;
12763           if (val + 0x80000000 > 0xffffffff)
12764             {
12765               info->callbacks->einfo
12766                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12767                  htab->glink->name);
12768               return FALSE;
12769             }
12770           bfd_put_32 (htab->elf.dynobj, val, p);
12771           p += 4;
12772           /* .glink size.  */
12773           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12774           p += 4;
12775           /* Augmentation.  */
12776           p += 1;
12777
12778           *p++ = DW_CFA_advance_loc + 1;
12779           *p++ = DW_CFA_register;
12780           *p++ = 65;
12781           *p++ = 12;
12782           *p++ = DW_CFA_advance_loc + 4;
12783           *p++ = DW_CFA_restore_extended;
12784           *p++ = 65;
12785         }
12786       /* Subsume any padding into the last FDE if user .eh_frame
12787          sections are aligned more than glink_eh_frame.  Otherwise any
12788          zero padding will be seen as a terminator.  */
12789       size = p - htab->glink_eh_frame->contents;
12790       align = 1;
12791       align <<= htab->glink_eh_frame->output_section->alignment_power;
12792       align -= 1;
12793       pad = ((size + align) & ~align) - size;
12794       htab->glink_eh_frame->size = size + pad;
12795       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12796     }
12797
12798   /* Build the stubs as directed by the stub hash table.  */
12799   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12800
12801   if (htab->relbrlt != NULL)
12802     htab->relbrlt->reloc_count = 0;
12803
12804   if (htab->params->plt_stub_align != 0)
12805     for (stub_sec = htab->params->stub_bfd->sections;
12806          stub_sec != NULL;
12807          stub_sec = stub_sec->next)
12808       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12809         stub_sec->size = ((stub_sec->size
12810                            + (1 << htab->params->plt_stub_align) - 1)
12811                           & (-1 << htab->params->plt_stub_align));
12812
12813   for (stub_sec = htab->params->stub_bfd->sections;
12814        stub_sec != NULL;
12815        stub_sec = stub_sec->next)
12816     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12817       {
12818         stub_sec_count += 1;
12819         if (stub_sec->rawsize != stub_sec->size)
12820           break;
12821       }
12822
12823   if (stub_sec != NULL
12824       || (htab->glink_eh_frame != NULL
12825           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12826     {
12827       htab->stub_error = TRUE;
12828       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12829     }
12830
12831   if (htab->stub_error)
12832     return FALSE;
12833
12834   if (stats != NULL)
12835     {
12836       *stats = bfd_malloc (500);
12837       if (*stats == NULL)
12838         return FALSE;
12839
12840       sprintf (*stats, _("linker stubs in %u group%s\n"
12841                          "  branch       %lu\n"
12842                          "  toc adjust   %lu\n"
12843                          "  long branch  %lu\n"
12844                          "  long toc adj %lu\n"
12845                          "  plt call     %lu\n"
12846                          "  plt call toc %lu"),
12847                stub_sec_count,
12848                stub_sec_count == 1 ? "" : "s",
12849                htab->stub_count[ppc_stub_long_branch - 1],
12850                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12851                htab->stub_count[ppc_stub_plt_branch - 1],
12852                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12853                htab->stub_count[ppc_stub_plt_call - 1],
12854                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12855     }
12856   return TRUE;
12857 }
12858
12859 /* This function undoes the changes made by add_symbol_adjust.  */
12860
12861 static bfd_boolean
12862 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12863 {
12864   struct ppc_link_hash_entry *eh;
12865
12866   if (h->root.type == bfd_link_hash_indirect)
12867     return TRUE;
12868
12869   eh = (struct ppc_link_hash_entry *) h;
12870   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12871     return TRUE;
12872
12873   eh->elf.root.type = bfd_link_hash_undefined;
12874   return TRUE;
12875 }
12876
12877 void
12878 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12879 {
12880   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12881
12882   if (htab != NULL)
12883     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12884 }
12885
12886 /* What to do when ld finds relocations against symbols defined in
12887    discarded sections.  */
12888
12889 static unsigned int
12890 ppc64_elf_action_discarded (asection *sec)
12891 {
12892   if (strcmp (".opd", sec->name) == 0)
12893     return 0;
12894
12895   if (strcmp (".toc", sec->name) == 0)
12896     return 0;
12897
12898   if (strcmp (".toc1", sec->name) == 0)
12899     return 0;
12900
12901   return _bfd_elf_default_action_discarded (sec);
12902 }
12903
12904 /* The RELOCATE_SECTION function is called by the ELF backend linker
12905    to handle the relocations for a section.
12906
12907    The relocs are always passed as Rela structures; if the section
12908    actually uses Rel structures, the r_addend field will always be
12909    zero.
12910
12911    This function is responsible for adjust the section contents as
12912    necessary, and (if using Rela relocs and generating a
12913    relocatable output file) adjusting the reloc addend as
12914    necessary.
12915
12916    This function does not have to worry about setting the reloc
12917    address or the reloc symbol index.
12918
12919    LOCAL_SYMS is a pointer to the swapped in local symbols.
12920
12921    LOCAL_SECTIONS is an array giving the section in the input file
12922    corresponding to the st_shndx field of each local symbol.
12923
12924    The global hash table entry for the global symbols can be found
12925    via elf_sym_hashes (input_bfd).
12926
12927    When generating relocatable output, this function must handle
12928    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12929    going to be the section symbol corresponding to the output
12930    section, which means that the addend must be adjusted
12931    accordingly.  */
12932
12933 static bfd_boolean
12934 ppc64_elf_relocate_section (bfd *output_bfd,
12935                             struct bfd_link_info *info,
12936                             bfd *input_bfd,
12937                             asection *input_section,
12938                             bfd_byte *contents,
12939                             Elf_Internal_Rela *relocs,
12940                             Elf_Internal_Sym *local_syms,
12941                             asection **local_sections)
12942 {
12943   struct ppc_link_hash_table *htab;
12944   Elf_Internal_Shdr *symtab_hdr;
12945   struct elf_link_hash_entry **sym_hashes;
12946   Elf_Internal_Rela *rel;
12947   Elf_Internal_Rela *relend;
12948   Elf_Internal_Rela outrel;
12949   bfd_byte *loc;
12950   struct got_entry **local_got_ents;
12951   bfd_vma TOCstart;
12952   bfd_boolean ret = TRUE;
12953   bfd_boolean is_opd;
12954   /* Assume 'at' branch hints.  */
12955   bfd_boolean is_isa_v2 = TRUE;
12956   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12957
12958   /* Initialize howto table if needed.  */
12959   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12960     ppc_howto_init ();
12961
12962   htab = ppc_hash_table (info);
12963   if (htab == NULL)
12964     return FALSE;
12965
12966   /* Don't relocate stub sections.  */
12967   if (input_section->owner == htab->params->stub_bfd)
12968     return TRUE;
12969
12970   BFD_ASSERT (is_ppc64_elf (input_bfd));
12971
12972   local_got_ents = elf_local_got_ents (input_bfd);
12973   TOCstart = elf_gp (output_bfd);
12974   symtab_hdr = &elf_symtab_hdr (input_bfd);
12975   sym_hashes = elf_sym_hashes (input_bfd);
12976   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12977
12978   rel = relocs;
12979   relend = relocs + input_section->reloc_count;
12980   for (; rel < relend; rel++)
12981     {
12982       enum elf_ppc64_reloc_type r_type;
12983       bfd_vma addend;
12984       bfd_reloc_status_type r;
12985       Elf_Internal_Sym *sym;
12986       asection *sec;
12987       struct elf_link_hash_entry *h_elf;
12988       struct ppc_link_hash_entry *h;
12989       struct ppc_link_hash_entry *fdh;
12990       const char *sym_name;
12991       unsigned long r_symndx, toc_symndx;
12992       bfd_vma toc_addend;
12993       unsigned char tls_mask, tls_gd, tls_type;
12994       unsigned char sym_type;
12995       bfd_vma relocation;
12996       bfd_boolean unresolved_reloc;
12997       bfd_boolean warned;
12998       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12999       unsigned int insn;
13000       unsigned int mask;
13001       struct ppc_stub_hash_entry *stub_entry;
13002       bfd_vma max_br_offset;
13003       bfd_vma from;
13004       const Elf_Internal_Rela orig_rel = *rel;
13005       reloc_howto_type *howto;
13006       struct reloc_howto_struct alt_howto;
13007
13008       r_type = ELF64_R_TYPE (rel->r_info);
13009       r_symndx = ELF64_R_SYM (rel->r_info);
13010
13011       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13012          symbol of the previous ADDR64 reloc.  The symbol gives us the
13013          proper TOC base to use.  */
13014       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13015           && rel != relocs
13016           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
13017           && is_opd)
13018         r_symndx = ELF64_R_SYM (rel[-1].r_info);
13019
13020       sym = NULL;
13021       sec = NULL;
13022       h_elf = NULL;
13023       sym_name = NULL;
13024       unresolved_reloc = FALSE;
13025       warned = FALSE;
13026
13027       if (r_symndx < symtab_hdr->sh_info)
13028         {
13029           /* It's a local symbol.  */
13030           struct _opd_sec_data *opd;
13031
13032           sym = local_syms + r_symndx;
13033           sec = local_sections[r_symndx];
13034           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13035           sym_type = ELF64_ST_TYPE (sym->st_info);
13036           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13037           opd = get_opd_info (sec);
13038           if (opd != NULL && opd->adjust != NULL)
13039             {
13040               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13041               if (adjust == -1)
13042                 relocation = 0;
13043               else
13044                 {
13045                   /* If this is a relocation against the opd section sym
13046                      and we have edited .opd, adjust the reloc addend so
13047                      that ld -r and ld --emit-relocs output is correct.
13048                      If it is a reloc against some other .opd symbol,
13049                      then the symbol value will be adjusted later.  */
13050                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13051                     rel->r_addend += adjust;
13052                   else
13053                     relocation += adjust;
13054                 }
13055             }
13056         }
13057       else
13058         {
13059           bfd_boolean ignored;
13060
13061           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13062                                    r_symndx, symtab_hdr, sym_hashes,
13063                                    h_elf, sec, relocation,
13064                                    unresolved_reloc, warned, ignored);
13065           sym_name = h_elf->root.root.string;
13066           sym_type = h_elf->type;
13067           if (sec != NULL
13068               && sec->owner == output_bfd
13069               && strcmp (sec->name, ".opd") == 0)
13070             {
13071               /* This is a symbol defined in a linker script.  All
13072                  such are defined in output sections, even those
13073                  defined by simple assignment from a symbol defined in
13074                  an input section.  Transfer the symbol to an
13075                  appropriate input .opd section, so that a branch to
13076                  this symbol will be mapped to the location specified
13077                  by the opd entry.  */
13078               struct bfd_link_order *lo;
13079               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13080                 if (lo->type == bfd_indirect_link_order)
13081                   {
13082                     asection *isec = lo->u.indirect.section;
13083                     if (h_elf->root.u.def.value >= isec->output_offset
13084                         && h_elf->root.u.def.value < (isec->output_offset
13085                                                       + isec->size))
13086                       {
13087                         h_elf->root.u.def.value -= isec->output_offset;
13088                         h_elf->root.u.def.section = isec;
13089                         sec = isec;
13090                         break;
13091                       }
13092                   }
13093             }
13094         }
13095       h = (struct ppc_link_hash_entry *) h_elf;
13096
13097       if (sec != NULL && discarded_section (sec))
13098         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13099                                          rel, 1, relend,
13100                                          ppc64_elf_howto_table[r_type], 0,
13101                                          contents);
13102
13103       if (info->relocatable)
13104         continue;
13105
13106       if (h != NULL && &h->elf == htab->elf.hgot)
13107         {
13108           relocation = (TOCstart
13109                         + htab->stub_group[input_section->id].toc_off);
13110           sec = bfd_abs_section_ptr;
13111           unresolved_reloc = FALSE;
13112         }
13113
13114       /* TLS optimizations.  Replace instruction sequences and relocs
13115          based on information we collected in tls_optimize.  We edit
13116          RELOCS so that --emit-relocs will output something sensible
13117          for the final instruction stream.  */
13118       tls_mask = 0;
13119       tls_gd = 0;
13120       toc_symndx = 0;
13121       if (h != NULL)
13122         tls_mask = h->tls_mask;
13123       else if (local_got_ents != NULL)
13124         {
13125           struct plt_entry **local_plt = (struct plt_entry **)
13126             (local_got_ents + symtab_hdr->sh_info);
13127           unsigned char *lgot_masks = (unsigned char *)
13128             (local_plt + symtab_hdr->sh_info);
13129           tls_mask = lgot_masks[r_symndx];
13130         }
13131       if (tls_mask == 0
13132           && (r_type == R_PPC64_TLS
13133               || r_type == R_PPC64_TLSGD
13134               || r_type == R_PPC64_TLSLD))
13135         {
13136           /* Check for toc tls entries.  */
13137           unsigned char *toc_tls;
13138
13139           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13140                              &local_syms, rel, input_bfd))
13141             return FALSE;
13142
13143           if (toc_tls)
13144             tls_mask = *toc_tls;
13145         }
13146
13147       /* Check that tls relocs are used with tls syms, and non-tls
13148          relocs are used with non-tls syms.  */
13149       if (r_symndx != STN_UNDEF
13150           && r_type != R_PPC64_NONE
13151           && (h == NULL
13152               || h->elf.root.type == bfd_link_hash_defined
13153               || h->elf.root.type == bfd_link_hash_defweak)
13154           && (IS_PPC64_TLS_RELOC (r_type)
13155               != (sym_type == STT_TLS
13156                   || (sym_type == STT_SECTION
13157                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13158         {
13159           if (tls_mask != 0
13160               && (r_type == R_PPC64_TLS
13161                   || r_type == R_PPC64_TLSGD
13162                   || r_type == R_PPC64_TLSLD))
13163             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13164             ;
13165           else
13166             info->callbacks->einfo
13167               (!IS_PPC64_TLS_RELOC (r_type)
13168                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13169                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13170                input_bfd, input_section, rel->r_offset,
13171                ppc64_elf_howto_table[r_type]->name,
13172                sym_name);
13173         }
13174
13175       /* Ensure reloc mapping code below stays sane.  */
13176       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13177           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13178           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13179           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13180           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13181           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13182           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13183           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13184           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13185           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13186         abort ();
13187
13188       switch (r_type)
13189         {
13190         default:
13191           break;
13192
13193         case R_PPC64_LO_DS_OPT:
13194           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13195           if ((insn & (0x3f << 26)) != 58u << 26)
13196             abort ();
13197           insn += (14u << 26) - (58u << 26);
13198           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13199           r_type = R_PPC64_TOC16_LO;
13200           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13201           break;
13202
13203         case R_PPC64_TOC16:
13204         case R_PPC64_TOC16_LO:
13205         case R_PPC64_TOC16_DS:
13206         case R_PPC64_TOC16_LO_DS:
13207           {
13208             /* Check for toc tls entries.  */
13209             unsigned char *toc_tls;
13210             int retval;
13211
13212             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13213                                    &local_syms, rel, input_bfd);
13214             if (retval == 0)
13215               return FALSE;
13216
13217             if (toc_tls)
13218               {
13219                 tls_mask = *toc_tls;
13220                 if (r_type == R_PPC64_TOC16_DS
13221                     || r_type == R_PPC64_TOC16_LO_DS)
13222                   {
13223                     if (tls_mask != 0
13224                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13225                       goto toctprel;
13226                   }
13227                 else
13228                   {
13229                     /* If we found a GD reloc pair, then we might be
13230                        doing a GD->IE transition.  */
13231                     if (retval == 2)
13232                       {
13233                         tls_gd = TLS_TPRELGD;
13234                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13235                           goto tls_ldgd_opt;
13236                       }
13237                     else if (retval == 3)
13238                       {
13239                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13240                           goto tls_ldgd_opt;
13241                       }
13242                   }
13243               }
13244           }
13245           break;
13246
13247         case R_PPC64_GOT_TPREL16_HI:
13248         case R_PPC64_GOT_TPREL16_HA:
13249           if (tls_mask != 0
13250               && (tls_mask & TLS_TPREL) == 0)
13251             {
13252               rel->r_offset -= d_offset;
13253               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13254               r_type = R_PPC64_NONE;
13255               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13256             }
13257           break;
13258
13259         case R_PPC64_GOT_TPREL16_DS:
13260         case R_PPC64_GOT_TPREL16_LO_DS:
13261           if (tls_mask != 0
13262               && (tls_mask & TLS_TPREL) == 0)
13263             {
13264             toctprel:
13265               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13266               insn &= 31 << 21;
13267               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13268               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13269               r_type = R_PPC64_TPREL16_HA;
13270               if (toc_symndx != 0)
13271                 {
13272                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13273                   rel->r_addend = toc_addend;
13274                   /* We changed the symbol.  Start over in order to
13275                      get h, sym, sec etc. right.  */
13276                   rel--;
13277                   continue;
13278                 }
13279               else
13280                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13281             }
13282           break;
13283
13284         case R_PPC64_TLS:
13285           if (tls_mask != 0
13286               && (tls_mask & TLS_TPREL) == 0)
13287             {
13288               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13289               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13290               if (insn == 0)
13291                 abort ();
13292               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13293               /* Was PPC64_TLS which sits on insn boundary, now
13294                  PPC64_TPREL16_LO which is at low-order half-word.  */
13295               rel->r_offset += d_offset;
13296               r_type = R_PPC64_TPREL16_LO;
13297               if (toc_symndx != 0)
13298                 {
13299                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13300                   rel->r_addend = toc_addend;
13301                   /* We changed the symbol.  Start over in order to
13302                      get h, sym, sec etc. right.  */
13303                   rel--;
13304                   continue;
13305                 }
13306               else
13307                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13308             }
13309           break;
13310
13311         case R_PPC64_GOT_TLSGD16_HI:
13312         case R_PPC64_GOT_TLSGD16_HA:
13313           tls_gd = TLS_TPRELGD;
13314           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13315             goto tls_gdld_hi;
13316           break;
13317
13318         case R_PPC64_GOT_TLSLD16_HI:
13319         case R_PPC64_GOT_TLSLD16_HA:
13320           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13321             {
13322             tls_gdld_hi:
13323               if ((tls_mask & tls_gd) != 0)
13324                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13325                           + R_PPC64_GOT_TPREL16_DS);
13326               else
13327                 {
13328                   rel->r_offset -= d_offset;
13329                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13330                   r_type = R_PPC64_NONE;
13331                 }
13332               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13333             }
13334           break;
13335
13336         case R_PPC64_GOT_TLSGD16:
13337         case R_PPC64_GOT_TLSGD16_LO:
13338           tls_gd = TLS_TPRELGD;
13339           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13340             goto tls_ldgd_opt;
13341           break;
13342
13343         case R_PPC64_GOT_TLSLD16:
13344         case R_PPC64_GOT_TLSLD16_LO:
13345           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13346             {
13347               unsigned int insn1, insn2, insn3;
13348               bfd_vma offset;
13349
13350             tls_ldgd_opt:
13351               offset = (bfd_vma) -1;
13352               /* If not using the newer R_PPC64_TLSGD/LD to mark
13353                  __tls_get_addr calls, we must trust that the call
13354                  stays with its arg setup insns, ie. that the next
13355                  reloc is the __tls_get_addr call associated with
13356                  the current reloc.  Edit both insns.  */
13357               if (input_section->has_tls_get_addr_call
13358                   && rel + 1 < relend
13359                   && branch_reloc_hash_match (input_bfd, rel + 1,
13360                                               htab->tls_get_addr,
13361                                               htab->tls_get_addr_fd))
13362                 offset = rel[1].r_offset;
13363               if ((tls_mask & tls_gd) != 0)
13364                 {
13365                   /* IE */
13366                   insn1 = bfd_get_32 (output_bfd,
13367                                       contents + rel->r_offset - d_offset);
13368                   insn1 &= (1 << 26) - (1 << 2);
13369                   insn1 |= 58 << 26;    /* ld */
13370                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13371                   if (offset != (bfd_vma) -1)
13372                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13373                   if ((tls_mask & TLS_EXPLICIT) == 0)
13374                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13375                               + R_PPC64_GOT_TPREL16_DS);
13376                   else
13377                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13378                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379                 }
13380               else
13381                 {
13382                   /* LE */
13383                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13384                   insn2 = 0x38630000;   /* addi 3,3,0 */
13385                   if (tls_gd == 0)
13386                     {
13387                       /* Was an LD reloc.  */
13388                       if (toc_symndx)
13389                         sec = local_sections[toc_symndx];
13390                       for (r_symndx = 0;
13391                            r_symndx < symtab_hdr->sh_info;
13392                            r_symndx++)
13393                         if (local_sections[r_symndx] == sec)
13394                           break;
13395                       if (r_symndx >= symtab_hdr->sh_info)
13396                         r_symndx = STN_UNDEF;
13397                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13398                       if (r_symndx != STN_UNDEF)
13399                         rel->r_addend -= (local_syms[r_symndx].st_value
13400                                           + sec->output_offset
13401                                           + sec->output_section->vma);
13402                     }
13403                   else if (toc_symndx != 0)
13404                     {
13405                       r_symndx = toc_symndx;
13406                       rel->r_addend = toc_addend;
13407                     }
13408                   r_type = R_PPC64_TPREL16_HA;
13409                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13410                   if (offset != (bfd_vma) -1)
13411                     {
13412                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13413                                                     R_PPC64_TPREL16_LO);
13414                       rel[1].r_offset = offset + d_offset;
13415                       rel[1].r_addend = rel->r_addend;
13416                     }
13417                 }
13418               bfd_put_32 (output_bfd, insn1,
13419                           contents + rel->r_offset - d_offset);
13420               if (offset != (bfd_vma) -1)
13421                 {
13422                   insn3 = bfd_get_32 (output_bfd,
13423                                       contents + offset + 4);
13424                   if (insn3 == NOP
13425                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13426                     {
13427                       rel[1].r_offset += 4;
13428                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13429                       insn2 = NOP;
13430                     }
13431                   bfd_put_32 (output_bfd, insn2, contents + offset);
13432                 }
13433               if ((tls_mask & tls_gd) == 0
13434                   && (tls_gd == 0 || toc_symndx != 0))
13435                 {
13436                   /* We changed the symbol.  Start over in order
13437                      to get h, sym, sec etc. right.  */
13438                   rel--;
13439                   continue;
13440                 }
13441             }
13442           break;
13443
13444         case R_PPC64_TLSGD:
13445           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13446             {
13447               unsigned int insn2, insn3;
13448               bfd_vma offset = rel->r_offset;
13449
13450               if ((tls_mask & TLS_TPRELGD) != 0)
13451                 {
13452                   /* IE */
13453                   r_type = R_PPC64_NONE;
13454                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13455                 }
13456               else
13457                 {
13458                   /* LE */
13459                   if (toc_symndx != 0)
13460                     {
13461                       r_symndx = toc_symndx;
13462                       rel->r_addend = toc_addend;
13463                     }
13464                   r_type = R_PPC64_TPREL16_LO;
13465                   rel->r_offset = offset + d_offset;
13466                   insn2 = 0x38630000;   /* addi 3,3,0 */
13467                 }
13468               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13469               /* Zap the reloc on the _tls_get_addr call too.  */
13470               BFD_ASSERT (offset == rel[1].r_offset);
13471               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13472               insn3 = bfd_get_32 (output_bfd,
13473                                   contents + offset + 4);
13474               if (insn3 == NOP
13475                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13476                 {
13477                   rel->r_offset += 4;
13478                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13479                   insn2 = NOP;
13480                 }
13481               bfd_put_32 (output_bfd, insn2, contents + offset);
13482               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13483                 {
13484                   rel--;
13485                   continue;
13486                 }
13487             }
13488           break;
13489
13490         case R_PPC64_TLSLD:
13491           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13492             {
13493               unsigned int insn2, insn3;
13494               bfd_vma offset = rel->r_offset;
13495
13496               if (toc_symndx)
13497                 sec = local_sections[toc_symndx];
13498               for (r_symndx = 0;
13499                    r_symndx < symtab_hdr->sh_info;
13500                    r_symndx++)
13501                 if (local_sections[r_symndx] == sec)
13502                   break;
13503               if (r_symndx >= symtab_hdr->sh_info)
13504                 r_symndx = STN_UNDEF;
13505               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13506               if (r_symndx != STN_UNDEF)
13507                 rel->r_addend -= (local_syms[r_symndx].st_value
13508                                   + sec->output_offset
13509                                   + sec->output_section->vma);
13510
13511               r_type = R_PPC64_TPREL16_LO;
13512               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13513               rel->r_offset = offset + d_offset;
13514               /* Zap the reloc on the _tls_get_addr call too.  */
13515               BFD_ASSERT (offset == rel[1].r_offset);
13516               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13517               insn2 = 0x38630000;       /* addi 3,3,0 */
13518               insn3 = bfd_get_32 (output_bfd,
13519                                   contents + offset + 4);
13520               if (insn3 == NOP
13521                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13522                 {
13523                   rel->r_offset += 4;
13524                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13525                   insn2 = NOP;
13526                 }
13527               bfd_put_32 (output_bfd, insn2, contents + offset);
13528               rel--;
13529               continue;
13530             }
13531           break;
13532
13533         case R_PPC64_DTPMOD64:
13534           if (rel + 1 < relend
13535               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13536               && rel[1].r_offset == rel->r_offset + 8)
13537             {
13538               if ((tls_mask & TLS_GD) == 0)
13539                 {
13540                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13541                   if ((tls_mask & TLS_TPRELGD) != 0)
13542                     r_type = R_PPC64_TPREL64;
13543                   else
13544                     {
13545                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13546                       r_type = R_PPC64_NONE;
13547                     }
13548                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13549                 }
13550             }
13551           else
13552             {
13553               if ((tls_mask & TLS_LD) == 0)
13554                 {
13555                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13556                   r_type = R_PPC64_NONE;
13557                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13558                 }
13559             }
13560           break;
13561
13562         case R_PPC64_TPREL64:
13563           if ((tls_mask & TLS_TPREL) == 0)
13564             {
13565               r_type = R_PPC64_NONE;
13566               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13567             }
13568           break;
13569
13570         case R_PPC64_REL16_HA:
13571           /* If we are generating a non-PIC executable, edit
13572              .  0:      addis 2,12,.TOC.-0b@ha
13573              .          addi 2,2,.TOC.-0b@l
13574              used by ELFv2 global entry points to set up r2, to
13575              .          lis 2,.TOC.@ha
13576              .          addi 2,2,.TOC.@l
13577              if .TOC. is in range.  */
13578           if (!info->shared
13579               && !info->traditional_format
13580               && h != NULL && &h->elf == htab->elf.hgot
13581               && rel + 1 < relend
13582               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13583               && rel[1].r_offset == rel->r_offset + 4
13584               && rel[1].r_addend == rel->r_addend + 4
13585               && relocation + 0x80008000 <= 0xffffffff)
13586             {
13587               unsigned int insn1, insn2;
13588               bfd_vma offset = rel->r_offset - d_offset;
13589               insn1 = bfd_get_32 (output_bfd, contents + offset);
13590               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13591               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13592                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13593                 {
13594                   r_type = R_PPC64_ADDR16_HA;
13595                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13596                   rel->r_addend -= d_offset;
13597                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13598                   rel[1].r_addend -= d_offset + 4;
13599                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13600                 }
13601             }
13602           break;
13603         }
13604
13605       /* Handle other relocations that tweak non-addend part of insn.  */
13606       insn = 0;
13607       max_br_offset = 1 << 25;
13608       addend = rel->r_addend;
13609       reloc_dest = DEST_NORMAL;
13610       switch (r_type)
13611         {
13612         default:
13613           break;
13614
13615         case R_PPC64_TOCSAVE:
13616           if (relocation + addend == (rel->r_offset
13617                                       + input_section->output_offset
13618                                       + input_section->output_section->vma)
13619               && tocsave_find (htab, NO_INSERT,
13620                                &local_syms, rel, input_bfd))
13621             {
13622               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13623               if (insn == NOP
13624                   || insn == CROR_151515 || insn == CROR_313131)
13625                 bfd_put_32 (input_bfd,
13626                             STD_R2_0R1 + STK_TOC (htab),
13627                             contents + rel->r_offset);
13628             }
13629           break;
13630
13631           /* Branch taken prediction relocations.  */
13632         case R_PPC64_ADDR14_BRTAKEN:
13633         case R_PPC64_REL14_BRTAKEN:
13634           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13635           /* Fall thru.  */
13636
13637           /* Branch not taken prediction relocations.  */
13638         case R_PPC64_ADDR14_BRNTAKEN:
13639         case R_PPC64_REL14_BRNTAKEN:
13640           insn |= bfd_get_32 (output_bfd,
13641                               contents + rel->r_offset) & ~(0x01 << 21);
13642           /* Fall thru.  */
13643
13644         case R_PPC64_REL14:
13645           max_br_offset = 1 << 15;
13646           /* Fall thru.  */
13647
13648         case R_PPC64_REL24:
13649           /* Calls to functions with a different TOC, such as calls to
13650              shared objects, need to alter the TOC pointer.  This is
13651              done using a linkage stub.  A REL24 branching to these
13652              linkage stubs needs to be followed by a nop, as the nop
13653              will be replaced with an instruction to restore the TOC
13654              base pointer.  */
13655           fdh = h;
13656           if (h != NULL
13657               && h->oh != NULL
13658               && h->oh->is_func_descriptor)
13659             fdh = ppc_follow_link (h->oh);
13660           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13661                                            htab);
13662           if (stub_entry != NULL
13663               && (stub_entry->stub_type == ppc_stub_plt_call
13664                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13665                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13666                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13667             {
13668               bfd_boolean can_plt_call = FALSE;
13669
13670               /* All of these stubs will modify r2, so there must be a
13671                  branch and link followed by a nop.  The nop is
13672                  replaced by an insn to restore r2.  */
13673               if (rel->r_offset + 8 <= input_section->size)
13674                 {
13675                   unsigned long br;
13676
13677                   br = bfd_get_32 (input_bfd,
13678                                    contents + rel->r_offset);
13679                   if ((br & 1) != 0)
13680                     {
13681                       unsigned long nop;
13682
13683                       nop = bfd_get_32 (input_bfd,
13684                                         contents + rel->r_offset + 4);
13685                       if (nop == NOP
13686                           || nop == CROR_151515 || nop == CROR_313131)
13687                         {
13688                           if (h != NULL
13689                               && (h == htab->tls_get_addr_fd
13690                                   || h == htab->tls_get_addr)
13691                               && !htab->params->no_tls_get_addr_opt)
13692                             {
13693                               /* Special stub used, leave nop alone.  */
13694                             }
13695                           else
13696                             bfd_put_32 (input_bfd,
13697                                         LD_R2_0R1 + STK_TOC (htab),
13698                                         contents + rel->r_offset + 4);
13699                           can_plt_call = TRUE;
13700                         }
13701                     }
13702                 }
13703
13704               if (!can_plt_call && h != NULL)
13705                 {
13706                   const char *name = h->elf.root.root.string;
13707
13708                   if (*name == '.')
13709                     ++name;
13710
13711                   if (strncmp (name, "__libc_start_main", 17) == 0
13712                       && (name[17] == 0 || name[17] == '@'))
13713                     {
13714                       /* Allow crt1 branch to go via a toc adjusting
13715                          stub.  Other calls that never return could do
13716                          the same, if we could detect such.  */
13717                       can_plt_call = TRUE;
13718                     }
13719                 }
13720
13721               if (!can_plt_call)
13722                 {
13723                   /* g++ as of 20130507 emits self-calls without a
13724                      following nop.  This is arguably wrong since we
13725                      have conflicting information.  On the one hand a
13726                      global symbol and on the other a local call
13727                      sequence, but don't error for this special case.
13728                      It isn't possible to cheaply verify we have
13729                      exactly such a call.  Allow all calls to the same
13730                      section.  */
13731                   asection *code_sec = sec;
13732
13733                   if (get_opd_info (sec) != NULL)
13734                     {
13735                       bfd_vma off = (relocation + addend
13736                                      - sec->output_section->vma
13737                                      - sec->output_offset);
13738
13739                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13740                     }
13741                   if (code_sec == input_section)
13742                     can_plt_call = TRUE;
13743                 }
13744
13745               if (!can_plt_call)
13746                 {
13747                   info->callbacks->einfo
13748                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13749                        "recompile with -fPIC\n"),
13750                      input_bfd, input_section, rel->r_offset, sym_name);
13751
13752                   bfd_set_error (bfd_error_bad_value);
13753                   ret = FALSE;
13754                 }
13755
13756               if (can_plt_call
13757                   && (stub_entry->stub_type == ppc_stub_plt_call
13758                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13759                 unresolved_reloc = FALSE;
13760             }
13761
13762           if ((stub_entry == NULL
13763                || stub_entry->stub_type == ppc_stub_long_branch
13764                || stub_entry->stub_type == ppc_stub_plt_branch)
13765               && get_opd_info (sec) != NULL)
13766             {
13767               /* The branch destination is the value of the opd entry. */
13768               bfd_vma off = (relocation + addend
13769                              - sec->output_section->vma
13770                              - sec->output_offset);
13771               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13772               if (dest != (bfd_vma) -1)
13773                 {
13774                   relocation = dest;
13775                   addend = 0;
13776                   reloc_dest = DEST_OPD;
13777                 }
13778             }
13779
13780           /* If the branch is out of reach we ought to have a long
13781              branch stub.  */
13782           from = (rel->r_offset
13783                   + input_section->output_offset
13784                   + input_section->output_section->vma);
13785
13786           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13787                                                   ? fdh->elf.other
13788                                                   : sym->st_other);
13789
13790           if (stub_entry != NULL
13791               && (stub_entry->stub_type == ppc_stub_long_branch
13792                   || stub_entry->stub_type == ppc_stub_plt_branch)
13793               && (r_type == R_PPC64_ADDR14_BRTAKEN
13794                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13795                   || (relocation + addend - from + max_br_offset
13796                       < 2 * max_br_offset)))
13797             /* Don't use the stub if this branch is in range.  */
13798             stub_entry = NULL;
13799
13800           if (stub_entry != NULL)
13801             {
13802               /* Munge up the value and addend so that we call the stub
13803                  rather than the procedure directly.  */
13804               relocation = (stub_entry->stub_offset
13805                             + stub_entry->stub_sec->output_offset
13806                             + stub_entry->stub_sec->output_section->vma);
13807               addend = 0;
13808               reloc_dest = DEST_STUB;
13809
13810               if ((stub_entry->stub_type == ppc_stub_plt_call
13811                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13812                   && (ALWAYS_EMIT_R2SAVE
13813                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13814                   && rel + 1 < relend
13815                   && rel[1].r_offset == rel->r_offset + 4
13816                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13817                 relocation += 4;
13818             }
13819
13820           if (insn != 0)
13821             {
13822               if (is_isa_v2)
13823                 {
13824                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13825                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13826                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13827                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13828                     insn |= 0x02 << 21;
13829                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13830                     insn |= 0x08 << 21;
13831                   else
13832                     break;
13833                 }
13834               else
13835                 {
13836                   /* Invert 'y' bit if not the default.  */
13837                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13838                     insn ^= 0x01 << 21;
13839                 }
13840
13841               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13842             }
13843
13844           /* NOP out calls to undefined weak functions.
13845              We can thus call a weak function without first
13846              checking whether the function is defined.  */
13847           else if (h != NULL
13848                    && h->elf.root.type == bfd_link_hash_undefweak
13849                    && h->elf.dynindx == -1
13850                    && r_type == R_PPC64_REL24
13851                    && relocation == 0
13852                    && addend == 0)
13853             {
13854               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13855               continue;
13856             }
13857           break;
13858         }
13859
13860       /* Set `addend'.  */
13861       tls_type = 0;
13862       switch (r_type)
13863         {
13864         default:
13865           info->callbacks->einfo
13866             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13867              input_bfd, (int) r_type, sym_name);
13868
13869           bfd_set_error (bfd_error_bad_value);
13870           ret = FALSE;
13871           continue;
13872
13873         case R_PPC64_NONE:
13874         case R_PPC64_TLS:
13875         case R_PPC64_TLSGD:
13876         case R_PPC64_TLSLD:
13877         case R_PPC64_TOCSAVE:
13878         case R_PPC64_GNU_VTINHERIT:
13879         case R_PPC64_GNU_VTENTRY:
13880           continue;
13881
13882           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13883              address in the GOT as relocation value instead of the
13884              symbol's value itself.  Also, create a GOT entry for the
13885              symbol and put the symbol value there.  */
13886         case R_PPC64_GOT_TLSGD16:
13887         case R_PPC64_GOT_TLSGD16_LO:
13888         case R_PPC64_GOT_TLSGD16_HI:
13889         case R_PPC64_GOT_TLSGD16_HA:
13890           tls_type = TLS_TLS | TLS_GD;
13891           goto dogot;
13892
13893         case R_PPC64_GOT_TLSLD16:
13894         case R_PPC64_GOT_TLSLD16_LO:
13895         case R_PPC64_GOT_TLSLD16_HI:
13896         case R_PPC64_GOT_TLSLD16_HA:
13897           tls_type = TLS_TLS | TLS_LD;
13898           goto dogot;
13899
13900         case R_PPC64_GOT_TPREL16_DS:
13901         case R_PPC64_GOT_TPREL16_LO_DS:
13902         case R_PPC64_GOT_TPREL16_HI:
13903         case R_PPC64_GOT_TPREL16_HA:
13904           tls_type = TLS_TLS | TLS_TPREL;
13905           goto dogot;
13906
13907         case R_PPC64_GOT_DTPREL16_DS:
13908         case R_PPC64_GOT_DTPREL16_LO_DS:
13909         case R_PPC64_GOT_DTPREL16_HI:
13910         case R_PPC64_GOT_DTPREL16_HA:
13911           tls_type = TLS_TLS | TLS_DTPREL;
13912           goto dogot;
13913
13914         case R_PPC64_GOT16:
13915         case R_PPC64_GOT16_LO:
13916         case R_PPC64_GOT16_HI:
13917         case R_PPC64_GOT16_HA:
13918         case R_PPC64_GOT16_DS:
13919         case R_PPC64_GOT16_LO_DS:
13920         dogot:
13921           {
13922             /* Relocation is to the entry for this symbol in the global
13923                offset table.  */
13924             asection *got;
13925             bfd_vma *offp;
13926             bfd_vma off;
13927             unsigned long indx = 0;
13928             struct got_entry *ent;
13929
13930             if (tls_type == (TLS_TLS | TLS_LD)
13931                 && (h == NULL
13932                     || !h->elf.def_dynamic))
13933               ent = ppc64_tlsld_got (input_bfd);
13934             else
13935               {
13936
13937                 if (h != NULL)
13938                   {
13939                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13940                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13941                                                           &h->elf)
13942                         || (info->shared
13943                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13944                       /* This is actually a static link, or it is a
13945                          -Bsymbolic link and the symbol is defined
13946                          locally, or the symbol was forced to be local
13947                          because of a version file.  */
13948                       ;
13949                     else
13950                       {
13951                         BFD_ASSERT (h->elf.dynindx != -1);
13952                         indx = h->elf.dynindx;
13953                         unresolved_reloc = FALSE;
13954                       }
13955                     ent = h->elf.got.glist;
13956                   }
13957                 else
13958                   {
13959                     if (local_got_ents == NULL)
13960                       abort ();
13961                     ent = local_got_ents[r_symndx];
13962                   }
13963
13964                 for (; ent != NULL; ent = ent->next)
13965                   if (ent->addend == orig_rel.r_addend
13966                       && ent->owner == input_bfd
13967                       && ent->tls_type == tls_type)
13968                     break;
13969               }
13970
13971             if (ent == NULL)
13972               abort ();
13973             if (ent->is_indirect)
13974               ent = ent->got.ent;
13975             offp = &ent->got.offset;
13976             got = ppc64_elf_tdata (ent->owner)->got;
13977             if (got == NULL)
13978               abort ();
13979
13980             /* The offset must always be a multiple of 8.  We use the
13981                least significant bit to record whether we have already
13982                processed this entry.  */
13983             off = *offp;
13984             if ((off & 1) != 0)
13985               off &= ~1;
13986             else
13987               {
13988                 /* Generate relocs for the dynamic linker, except in
13989                    the case of TLSLD where we'll use one entry per
13990                    module.  */
13991                 asection *relgot;
13992                 bfd_boolean ifunc;
13993
13994                 *offp = off | 1;
13995                 relgot = NULL;
13996                 ifunc = (h != NULL
13997                          ? h->elf.type == STT_GNU_IFUNC
13998                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13999                 if (ifunc)
14000                   relgot = htab->elf.irelplt;
14001                 else if ((info->shared || indx != 0)
14002                          && (h == NULL
14003                              || (tls_type == (TLS_TLS | TLS_LD)
14004                                  && !h->elf.def_dynamic)
14005                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14006                              || h->elf.root.type != bfd_link_hash_undefweak))
14007                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14008                 if (relgot != NULL)
14009                   {
14010                     outrel.r_offset = (got->output_section->vma
14011                                        + got->output_offset
14012                                        + off);
14013                     outrel.r_addend = addend;
14014                     if (tls_type & (TLS_LD | TLS_GD))
14015                       {
14016                         outrel.r_addend = 0;
14017                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14018                         if (tls_type == (TLS_TLS | TLS_GD))
14019                           {
14020                             loc = relgot->contents;
14021                             loc += (relgot->reloc_count++
14022                                     * sizeof (Elf64_External_Rela));
14023                             bfd_elf64_swap_reloca_out (output_bfd,
14024                                                        &outrel, loc);
14025                             outrel.r_offset += 8;
14026                             outrel.r_addend = addend;
14027                             outrel.r_info
14028                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14029                           }
14030                       }
14031                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14032                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14033                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14034                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14035                     else if (indx != 0)
14036                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14037                     else
14038                       {
14039                         if (ifunc)
14040                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14041                         else
14042                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14043
14044                         /* Write the .got section contents for the sake
14045                            of prelink.  */
14046                         loc = got->contents + off;
14047                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14048                                     loc);
14049                       }
14050
14051                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14052                       {
14053                         outrel.r_addend += relocation;
14054                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14055                           outrel.r_addend -= htab->elf.tls_sec->vma;
14056                       }
14057                     loc = relgot->contents;
14058                     loc += (relgot->reloc_count++
14059                             * sizeof (Elf64_External_Rela));
14060                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14061                   }
14062
14063                 /* Init the .got section contents here if we're not
14064                    emitting a reloc.  */
14065                 else
14066                   {
14067                     relocation += addend;
14068                     if (tls_type == (TLS_TLS | TLS_LD))
14069                       relocation = 1;
14070                     else if (tls_type != 0)
14071                       {
14072                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14073                         if (tls_type == (TLS_TLS | TLS_TPREL))
14074                           relocation += DTP_OFFSET - TP_OFFSET;
14075
14076                         if (tls_type == (TLS_TLS | TLS_GD))
14077                           {
14078                             bfd_put_64 (output_bfd, relocation,
14079                                         got->contents + off + 8);
14080                             relocation = 1;
14081                           }
14082                       }
14083
14084                     bfd_put_64 (output_bfd, relocation,
14085                                 got->contents + off);
14086                   }
14087               }
14088
14089             if (off >= (bfd_vma) -2)
14090               abort ();
14091
14092             relocation = got->output_section->vma + got->output_offset + off;
14093             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14094           }
14095           break;
14096
14097         case R_PPC64_PLT16_HA:
14098         case R_PPC64_PLT16_HI:
14099         case R_PPC64_PLT16_LO:
14100         case R_PPC64_PLT32:
14101         case R_PPC64_PLT64:
14102           /* Relocation is to the entry for this symbol in the
14103              procedure linkage table.  */
14104
14105           /* Resolve a PLT reloc against a local symbol directly,
14106              without using the procedure linkage table.  */
14107           if (h == NULL)
14108             break;
14109
14110           /* It's possible that we didn't make a PLT entry for this
14111              symbol.  This happens when statically linking PIC code,
14112              or when using -Bsymbolic.  Go find a match if there is a
14113              PLT entry.  */
14114           if (htab->elf.splt != NULL)
14115             {
14116               struct plt_entry *ent;
14117               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14118                 if (ent->plt.offset != (bfd_vma) -1
14119                     && ent->addend == orig_rel.r_addend)
14120                   {
14121                     relocation = (htab->elf.splt->output_section->vma
14122                                   + htab->elf.splt->output_offset
14123                                   + ent->plt.offset);
14124                     unresolved_reloc = FALSE;
14125                     break;
14126                   }
14127             }
14128           break;
14129
14130         case R_PPC64_TOC:
14131           /* Relocation value is TOC base.  */
14132           relocation = TOCstart;
14133           if (r_symndx == STN_UNDEF)
14134             relocation += htab->stub_group[input_section->id].toc_off;
14135           else if (unresolved_reloc)
14136             ;
14137           else if (sec != NULL && sec->id <= htab->top_id)
14138             relocation += htab->stub_group[sec->id].toc_off;
14139           else
14140             unresolved_reloc = TRUE;
14141           goto dodyn;
14142
14143           /* TOC16 relocs.  We want the offset relative to the TOC base,
14144              which is the address of the start of the TOC plus 0x8000.
14145              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14146              in this order.  */
14147         case R_PPC64_TOC16:
14148         case R_PPC64_TOC16_LO:
14149         case R_PPC64_TOC16_HI:
14150         case R_PPC64_TOC16_DS:
14151         case R_PPC64_TOC16_LO_DS:
14152         case R_PPC64_TOC16_HA:
14153           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14154           break;
14155
14156           /* Relocate against the beginning of the section.  */
14157         case R_PPC64_SECTOFF:
14158         case R_PPC64_SECTOFF_LO:
14159         case R_PPC64_SECTOFF_HI:
14160         case R_PPC64_SECTOFF_DS:
14161         case R_PPC64_SECTOFF_LO_DS:
14162         case R_PPC64_SECTOFF_HA:
14163           if (sec != NULL)
14164             addend -= sec->output_section->vma;
14165           break;
14166
14167         case R_PPC64_REL16:
14168         case R_PPC64_REL16_LO:
14169         case R_PPC64_REL16_HI:
14170         case R_PPC64_REL16_HA:
14171           break;
14172
14173         case R_PPC64_REL14:
14174         case R_PPC64_REL14_BRNTAKEN:
14175         case R_PPC64_REL14_BRTAKEN:
14176         case R_PPC64_REL24:
14177           break;
14178
14179         case R_PPC64_TPREL16:
14180         case R_PPC64_TPREL16_LO:
14181         case R_PPC64_TPREL16_HI:
14182         case R_PPC64_TPREL16_HA:
14183         case R_PPC64_TPREL16_DS:
14184         case R_PPC64_TPREL16_LO_DS:
14185         case R_PPC64_TPREL16_HIGH:
14186         case R_PPC64_TPREL16_HIGHA:
14187         case R_PPC64_TPREL16_HIGHER:
14188         case R_PPC64_TPREL16_HIGHERA:
14189         case R_PPC64_TPREL16_HIGHEST:
14190         case R_PPC64_TPREL16_HIGHESTA:
14191           if (h != NULL
14192               && h->elf.root.type == bfd_link_hash_undefweak
14193               && h->elf.dynindx == -1)
14194             {
14195               /* Make this relocation against an undefined weak symbol
14196                  resolve to zero.  This is really just a tweak, since
14197                  code using weak externs ought to check that they are
14198                  defined before using them.  */
14199               bfd_byte *p = contents + rel->r_offset - d_offset;
14200
14201               insn = bfd_get_32 (output_bfd, p);
14202               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14203               if (insn != 0)
14204                 bfd_put_32 (output_bfd, insn, p);
14205               break;
14206             }
14207           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14208           if (info->shared)
14209             /* The TPREL16 relocs shouldn't really be used in shared
14210                libs as they will result in DT_TEXTREL being set, but
14211                support them anyway.  */
14212             goto dodyn;
14213           break;
14214
14215         case R_PPC64_DTPREL16:
14216         case R_PPC64_DTPREL16_LO:
14217         case R_PPC64_DTPREL16_HI:
14218         case R_PPC64_DTPREL16_HA:
14219         case R_PPC64_DTPREL16_DS:
14220         case R_PPC64_DTPREL16_LO_DS:
14221         case R_PPC64_DTPREL16_HIGH:
14222         case R_PPC64_DTPREL16_HIGHA:
14223         case R_PPC64_DTPREL16_HIGHER:
14224         case R_PPC64_DTPREL16_HIGHERA:
14225         case R_PPC64_DTPREL16_HIGHEST:
14226         case R_PPC64_DTPREL16_HIGHESTA:
14227           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14228           break;
14229
14230         case R_PPC64_ADDR64_LOCAL:
14231           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14232                                               ? h->elf.other
14233                                               : sym->st_other);
14234           break;
14235
14236         case R_PPC64_DTPMOD64:
14237           relocation = 1;
14238           addend = 0;
14239           goto dodyn;
14240
14241         case R_PPC64_TPREL64:
14242           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14243           goto dodyn;
14244
14245         case R_PPC64_DTPREL64:
14246           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14247           /* Fall thru */
14248
14249           /* Relocations that may need to be propagated if this is a
14250              dynamic object.  */
14251         case R_PPC64_REL30:
14252         case R_PPC64_REL32:
14253         case R_PPC64_REL64:
14254         case R_PPC64_ADDR14:
14255         case R_PPC64_ADDR14_BRNTAKEN:
14256         case R_PPC64_ADDR14_BRTAKEN:
14257         case R_PPC64_ADDR16:
14258         case R_PPC64_ADDR16_DS:
14259         case R_PPC64_ADDR16_HA:
14260         case R_PPC64_ADDR16_HI:
14261         case R_PPC64_ADDR16_HIGH:
14262         case R_PPC64_ADDR16_HIGHA:
14263         case R_PPC64_ADDR16_HIGHER:
14264         case R_PPC64_ADDR16_HIGHERA:
14265         case R_PPC64_ADDR16_HIGHEST:
14266         case R_PPC64_ADDR16_HIGHESTA:
14267         case R_PPC64_ADDR16_LO:
14268         case R_PPC64_ADDR16_LO_DS:
14269         case R_PPC64_ADDR24:
14270         case R_PPC64_ADDR32:
14271         case R_PPC64_ADDR64:
14272         case R_PPC64_UADDR16:
14273         case R_PPC64_UADDR32:
14274         case R_PPC64_UADDR64:
14275         dodyn:
14276           if ((input_section->flags & SEC_ALLOC) == 0)
14277             break;
14278
14279           if (NO_OPD_RELOCS && is_opd)
14280             break;
14281
14282           if ((info->shared
14283                && (h == NULL
14284                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14285                    || h->elf.root.type != bfd_link_hash_undefweak)
14286                && (must_be_dyn_reloc (info, r_type)
14287                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14288               || (ELIMINATE_COPY_RELOCS
14289                   && !info->shared
14290                   && h != NULL
14291                   && h->elf.dynindx != -1
14292                   && !h->elf.non_got_ref
14293                   && !h->elf.def_regular)
14294               || (!info->shared
14295                   && (h != NULL
14296                       ? h->elf.type == STT_GNU_IFUNC
14297                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14298             {
14299               bfd_boolean skip, relocate;
14300               asection *sreloc;
14301               bfd_vma out_off;
14302
14303               /* When generating a dynamic object, these relocations
14304                  are copied into the output file to be resolved at run
14305                  time.  */
14306
14307               skip = FALSE;
14308               relocate = FALSE;
14309
14310               out_off = _bfd_elf_section_offset (output_bfd, info,
14311                                                  input_section, rel->r_offset);
14312               if (out_off == (bfd_vma) -1)
14313                 skip = TRUE;
14314               else if (out_off == (bfd_vma) -2)
14315                 skip = TRUE, relocate = TRUE;
14316               out_off += (input_section->output_section->vma
14317                           + input_section->output_offset);
14318               outrel.r_offset = out_off;
14319               outrel.r_addend = rel->r_addend;
14320
14321               /* Optimize unaligned reloc use.  */
14322               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14323                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14324                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14325               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14326                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14327                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14328               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14329                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14330                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14331
14332               if (skip)
14333                 memset (&outrel, 0, sizeof outrel);
14334               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14335                        && !is_opd
14336                        && r_type != R_PPC64_TOC)
14337                 {
14338                   BFD_ASSERT (h->elf.dynindx != -1);
14339                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14340                 }
14341               else
14342                 {
14343                   /* This symbol is local, or marked to become local,
14344                      or this is an opd section reloc which must point
14345                      at a local function.  */
14346                   outrel.r_addend += relocation;
14347                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14348                     {
14349                       if (is_opd && h != NULL)
14350                         {
14351                           /* Lie about opd entries.  This case occurs
14352                              when building shared libraries and we
14353                              reference a function in another shared
14354                              lib.  The same thing happens for a weak
14355                              definition in an application that's
14356                              overridden by a strong definition in a
14357                              shared lib.  (I believe this is a generic
14358                              bug in binutils handling of weak syms.)
14359                              In these cases we won't use the opd
14360                              entry in this lib.  */
14361                           unresolved_reloc = FALSE;
14362                         }
14363                       if (!is_opd
14364                           && r_type == R_PPC64_ADDR64
14365                           && (h != NULL
14366                               ? h->elf.type == STT_GNU_IFUNC
14367                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14368                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14369                       else
14370                         {
14371                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14372
14373                           /* We need to relocate .opd contents for ld.so.
14374                              Prelink also wants simple and consistent rules
14375                              for relocs.  This make all RELATIVE relocs have
14376                              *r_offset equal to r_addend.  */
14377                           relocate = TRUE;
14378                         }
14379                     }
14380                   else
14381                     {
14382                       long indx = 0;
14383
14384                       if (h != NULL
14385                           ? h->elf.type == STT_GNU_IFUNC
14386                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14387                         {
14388                           info->callbacks->einfo
14389                             (_("%P: %H: %s for indirect "
14390                                "function `%T' unsupported\n"),
14391                              input_bfd, input_section, rel->r_offset,
14392                              ppc64_elf_howto_table[r_type]->name,
14393                              sym_name);
14394                           ret = FALSE;
14395                         }
14396                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14397                         ;
14398                       else if (sec == NULL || sec->owner == NULL)
14399                         {
14400                           bfd_set_error (bfd_error_bad_value);
14401                           return FALSE;
14402                         }
14403                       else
14404                         {
14405                           asection *osec;
14406
14407                           osec = sec->output_section;
14408                           indx = elf_section_data (osec)->dynindx;
14409
14410                           if (indx == 0)
14411                             {
14412                               if ((osec->flags & SEC_READONLY) == 0
14413                                   && htab->elf.data_index_section != NULL)
14414                                 osec = htab->elf.data_index_section;
14415                               else
14416                                 osec = htab->elf.text_index_section;
14417                               indx = elf_section_data (osec)->dynindx;
14418                             }
14419                           BFD_ASSERT (indx != 0);
14420
14421                           /* We are turning this relocation into one
14422                              against a section symbol, so subtract out
14423                              the output section's address but not the
14424                              offset of the input section in the output
14425                              section.  */
14426                           outrel.r_addend -= osec->vma;
14427                         }
14428
14429                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14430                     }
14431                 }
14432
14433               sreloc = elf_section_data (input_section)->sreloc;
14434               if (h != NULL
14435                   ? h->elf.type == STT_GNU_IFUNC
14436                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14437                 sreloc = htab->elf.irelplt;
14438               if (sreloc == NULL)
14439                 abort ();
14440
14441               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14442                   >= sreloc->size)
14443                 abort ();
14444               loc = sreloc->contents;
14445               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14446               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14447
14448               /* If this reloc is against an external symbol, it will
14449                  be computed at runtime, so there's no need to do
14450                  anything now.  However, for the sake of prelink ensure
14451                  that the section contents are a known value.  */
14452               if (! relocate)
14453                 {
14454                   unresolved_reloc = FALSE;
14455                   /* The value chosen here is quite arbitrary as ld.so
14456                      ignores section contents except for the special
14457                      case of .opd where the contents might be accessed
14458                      before relocation.  Choose zero, as that won't
14459                      cause reloc overflow.  */
14460                   relocation = 0;
14461                   addend = 0;
14462                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14463                      to improve backward compatibility with older
14464                      versions of ld.  */
14465                   if (r_type == R_PPC64_ADDR64)
14466                     addend = outrel.r_addend;
14467                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14468                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14469                     addend = (input_section->output_section->vma
14470                               + input_section->output_offset
14471                               + rel->r_offset);
14472                 }
14473             }
14474           break;
14475
14476         case R_PPC64_COPY:
14477         case R_PPC64_GLOB_DAT:
14478         case R_PPC64_JMP_SLOT:
14479         case R_PPC64_JMP_IREL:
14480         case R_PPC64_RELATIVE:
14481           /* We shouldn't ever see these dynamic relocs in relocatable
14482              files.  */
14483           /* Fall through.  */
14484
14485         case R_PPC64_PLTGOT16:
14486         case R_PPC64_PLTGOT16_DS:
14487         case R_PPC64_PLTGOT16_HA:
14488         case R_PPC64_PLTGOT16_HI:
14489         case R_PPC64_PLTGOT16_LO:
14490         case R_PPC64_PLTGOT16_LO_DS:
14491         case R_PPC64_PLTREL32:
14492         case R_PPC64_PLTREL64:
14493           /* These ones haven't been implemented yet.  */
14494
14495           info->callbacks->einfo
14496             (_("%P: %B: %s is not supported for `%T'\n"),
14497              input_bfd,
14498              ppc64_elf_howto_table[r_type]->name, sym_name);
14499
14500           bfd_set_error (bfd_error_invalid_operation);
14501           ret = FALSE;
14502           continue;
14503         }
14504
14505       /* Multi-instruction sequences that access the TOC can be
14506          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14507          to             nop;           addi rb,r2,x;  */
14508       switch (r_type)
14509         {
14510         default:
14511           break;
14512
14513         case R_PPC64_GOT_TLSLD16_HI:
14514         case R_PPC64_GOT_TLSGD16_HI:
14515         case R_PPC64_GOT_TPREL16_HI:
14516         case R_PPC64_GOT_DTPREL16_HI:
14517         case R_PPC64_GOT16_HI:
14518         case R_PPC64_TOC16_HI:
14519           /* These relocs would only be useful if building up an
14520              offset to later add to r2, perhaps in an indexed
14521              addressing mode instruction.  Don't try to optimize.
14522              Unfortunately, the possibility of someone building up an
14523              offset like this or even with the HA relocs, means that
14524              we need to check the high insn when optimizing the low
14525              insn.  */
14526           break;
14527
14528         case R_PPC64_GOT_TLSLD16_HA:
14529         case R_PPC64_GOT_TLSGD16_HA:
14530         case R_PPC64_GOT_TPREL16_HA:
14531         case R_PPC64_GOT_DTPREL16_HA:
14532         case R_PPC64_GOT16_HA:
14533         case R_PPC64_TOC16_HA:
14534           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14535               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14536             {
14537               bfd_byte *p = contents + (rel->r_offset & ~3);
14538               bfd_put_32 (input_bfd, NOP, p);
14539             }
14540           break;
14541
14542         case R_PPC64_GOT_TLSLD16_LO:
14543         case R_PPC64_GOT_TLSGD16_LO:
14544         case R_PPC64_GOT_TPREL16_LO_DS:
14545         case R_PPC64_GOT_DTPREL16_LO_DS:
14546         case R_PPC64_GOT16_LO:
14547         case R_PPC64_GOT16_LO_DS:
14548         case R_PPC64_TOC16_LO:
14549         case R_PPC64_TOC16_LO_DS:
14550           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14551               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14552             {
14553               bfd_byte *p = contents + (rel->r_offset & ~3);
14554               insn = bfd_get_32 (input_bfd, p);
14555               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14556                 {
14557                   /* Transform addic to addi when we change reg.  */
14558                   insn &= ~((0x3f << 26) | (0x1f << 16));
14559                   insn |= (14u << 26) | (2 << 16);
14560                 }
14561               else
14562                 {
14563                   insn &= ~(0x1f << 16);
14564                   insn |= 2 << 16;
14565                 }
14566               bfd_put_32 (input_bfd, insn, p);
14567             }
14568           break;
14569         }
14570
14571       /* Do any further special processing.  */
14572       howto = ppc64_elf_howto_table[(int) r_type];
14573       switch (r_type)
14574         {
14575         default:
14576           break;
14577
14578         case R_PPC64_REL16_HA:
14579         case R_PPC64_ADDR16_HA:
14580         case R_PPC64_ADDR16_HIGHA:
14581         case R_PPC64_ADDR16_HIGHERA:
14582         case R_PPC64_ADDR16_HIGHESTA:
14583         case R_PPC64_TOC16_HA:
14584         case R_PPC64_SECTOFF_HA:
14585         case R_PPC64_TPREL16_HA:
14586         case R_PPC64_TPREL16_HIGHA:
14587         case R_PPC64_TPREL16_HIGHERA:
14588         case R_PPC64_TPREL16_HIGHESTA:
14589         case R_PPC64_DTPREL16_HA:
14590         case R_PPC64_DTPREL16_HIGHA:
14591         case R_PPC64_DTPREL16_HIGHERA:
14592         case R_PPC64_DTPREL16_HIGHESTA:
14593           /* It's just possible that this symbol is a weak symbol
14594              that's not actually defined anywhere. In that case,
14595              'sec' would be NULL, and we should leave the symbol
14596              alone (it will be set to zero elsewhere in the link).  */
14597           if (sec == NULL)
14598             break;
14599           /* Fall thru */
14600
14601         case R_PPC64_GOT16_HA:
14602         case R_PPC64_PLTGOT16_HA:
14603         case R_PPC64_PLT16_HA:
14604         case R_PPC64_GOT_TLSGD16_HA:
14605         case R_PPC64_GOT_TLSLD16_HA:
14606         case R_PPC64_GOT_TPREL16_HA:
14607         case R_PPC64_GOT_DTPREL16_HA:
14608           /* Add 0x10000 if sign bit in 0:15 is set.
14609              Bits 0:15 are not used.  */
14610           addend += 0x8000;
14611           break;
14612
14613         case R_PPC64_ADDR16_DS:
14614         case R_PPC64_ADDR16_LO_DS:
14615         case R_PPC64_GOT16_DS:
14616         case R_PPC64_GOT16_LO_DS:
14617         case R_PPC64_PLT16_LO_DS:
14618         case R_PPC64_SECTOFF_DS:
14619         case R_PPC64_SECTOFF_LO_DS:
14620         case R_PPC64_TOC16_DS:
14621         case R_PPC64_TOC16_LO_DS:
14622         case R_PPC64_PLTGOT16_DS:
14623         case R_PPC64_PLTGOT16_LO_DS:
14624         case R_PPC64_GOT_TPREL16_DS:
14625         case R_PPC64_GOT_TPREL16_LO_DS:
14626         case R_PPC64_GOT_DTPREL16_DS:
14627         case R_PPC64_GOT_DTPREL16_LO_DS:
14628         case R_PPC64_TPREL16_DS:
14629         case R_PPC64_TPREL16_LO_DS:
14630         case R_PPC64_DTPREL16_DS:
14631         case R_PPC64_DTPREL16_LO_DS:
14632           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14633           mask = 3;
14634           /* If this reloc is against an lq insn, then the value must be
14635              a multiple of 16.  This is somewhat of a hack, but the
14636              "correct" way to do this by defining _DQ forms of all the
14637              _DS relocs bloats all reloc switches in this file.  It
14638              doesn't seem to make much sense to use any of these relocs
14639              in data, so testing the insn should be safe.  */
14640           if ((insn & (0x3f << 26)) == (56u << 26))
14641             mask = 15;
14642           if (((relocation + addend) & mask) != 0)
14643             {
14644               info->callbacks->einfo
14645                 (_("%P: %H: error: %s not a multiple of %u\n"),
14646                  input_bfd, input_section, rel->r_offset,
14647                  howto->name,
14648                  mask + 1);
14649               bfd_set_error (bfd_error_bad_value);
14650               ret = FALSE;
14651               continue;
14652             }
14653           break;
14654         }
14655
14656       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14657          because such sections are not SEC_ALLOC and thus ld.so will
14658          not process them.  */
14659       if (unresolved_reloc
14660           && !((input_section->flags & SEC_DEBUGGING) != 0
14661                && h->elf.def_dynamic)
14662           && _bfd_elf_section_offset (output_bfd, info, input_section,
14663                                       rel->r_offset) != (bfd_vma) -1)
14664         {
14665           info->callbacks->einfo
14666             (_("%P: %H: unresolvable %s against `%T'\n"),
14667              input_bfd, input_section, rel->r_offset,
14668              howto->name,
14669              h->elf.root.root.string);
14670           ret = FALSE;
14671         }
14672
14673       /* 16-bit fields in insns mostly have signed values, but a
14674          few insns have 16-bit unsigned values.  Really, we should
14675          have different reloc types.  */
14676       if (howto->complain_on_overflow != complain_overflow_dont
14677           && howto->dst_mask == 0xffff
14678           && (input_section->flags & SEC_CODE) != 0)
14679         {
14680           enum complain_overflow complain = complain_overflow_signed;
14681
14682           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14683           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14684             complain = complain_overflow_bitfield;
14685           else if (howto->rightshift == 0
14686                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14687                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14688                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14689                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14690                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14691                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14692             complain = complain_overflow_unsigned;
14693           if (howto->complain_on_overflow != complain)
14694             {
14695               alt_howto = *howto;
14696               alt_howto.complain_on_overflow = complain;
14697               howto = &alt_howto;
14698             }
14699         }
14700
14701       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14702                                     rel->r_offset, relocation, addend);
14703
14704       if (r != bfd_reloc_ok)
14705         {
14706           char *more_info = NULL;
14707           const char *reloc_name = howto->name;
14708
14709           if (reloc_dest != DEST_NORMAL)
14710             {
14711               more_info = bfd_malloc (strlen (reloc_name) + 8);
14712               if (more_info != NULL)
14713                 {
14714                   strcpy (more_info, reloc_name);
14715                   strcat (more_info, (reloc_dest == DEST_OPD
14716                                       ? " (OPD)" : " (stub)"));
14717                   reloc_name = more_info;
14718                 }
14719             }
14720
14721           if (r == bfd_reloc_overflow)
14722             {
14723               if (warned)
14724                 continue;
14725               if (h != NULL
14726                   && h->elf.root.type == bfd_link_hash_undefweak
14727                   && howto->pc_relative)
14728                 {
14729                   /* Assume this is a call protected by other code that
14730                      detects the symbol is undefined.  If this is the case,
14731                      we can safely ignore the overflow.  If not, the
14732                      program is hosed anyway, and a little warning isn't
14733                      going to help.  */
14734
14735                   continue;
14736                 }
14737
14738               if (!((*info->callbacks->reloc_overflow)
14739                     (info, &h->elf.root, sym_name,
14740                      reloc_name, orig_rel.r_addend,
14741                      input_bfd, input_section, rel->r_offset)))
14742                 return FALSE;
14743             }
14744           else
14745             {
14746               info->callbacks->einfo
14747                 (_("%P: %H: %s against `%T': error %d\n"),
14748                  input_bfd, input_section, rel->r_offset,
14749                  reloc_name, sym_name, (int) r);
14750               ret = FALSE;
14751             }
14752           if (more_info != NULL)
14753             free (more_info);
14754         }
14755     }
14756
14757   /* If we're emitting relocations, then shortly after this function
14758      returns, reloc offsets and addends for this section will be
14759      adjusted.  Worse, reloc symbol indices will be for the output
14760      file rather than the input.  Save a copy of the relocs for
14761      opd_entry_value.  */
14762   if (is_opd && (info->emitrelocations || info->relocatable))
14763     {
14764       bfd_size_type amt;
14765       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14766       rel = bfd_alloc (input_bfd, amt);
14767       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14768       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14769       if (rel == NULL)
14770         return FALSE;
14771       memcpy (rel, relocs, amt);
14772     }
14773   return ret;
14774 }
14775
14776 /* Adjust the value of any local symbols in opd sections.  */
14777
14778 static int
14779 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14780                               const char *name ATTRIBUTE_UNUSED,
14781                               Elf_Internal_Sym *elfsym,
14782                               asection *input_sec,
14783                               struct elf_link_hash_entry *h)
14784 {
14785   struct _opd_sec_data *opd;
14786   long adjust;
14787   bfd_vma value;
14788
14789   if (h != NULL)
14790     return 1;
14791
14792   opd = get_opd_info (input_sec);
14793   if (opd == NULL || opd->adjust == NULL)
14794     return 1;
14795
14796   value = elfsym->st_value - input_sec->output_offset;
14797   if (!info->relocatable)
14798     value -= input_sec->output_section->vma;
14799
14800   adjust = opd->adjust[value / 8];
14801   if (adjust == -1)
14802     return 2;
14803
14804   elfsym->st_value += adjust;
14805   return 1;
14806 }
14807
14808 /* Finish up dynamic symbol handling.  We set the contents of various
14809    dynamic sections here.  */
14810
14811 static bfd_boolean
14812 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14813                                  struct bfd_link_info *info,
14814                                  struct elf_link_hash_entry *h,
14815                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14816 {
14817   struct ppc_link_hash_table *htab;
14818   struct plt_entry *ent;
14819   Elf_Internal_Rela rela;
14820   bfd_byte *loc;
14821
14822   htab = ppc_hash_table (info);
14823   if (htab == NULL)
14824     return FALSE;
14825
14826   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14827     if (ent->plt.offset != (bfd_vma) -1)
14828       {
14829         /* This symbol has an entry in the procedure linkage
14830            table.  Set it up.  */
14831         if (!htab->elf.dynamic_sections_created
14832             || h->dynindx == -1)
14833           {
14834             BFD_ASSERT (h->type == STT_GNU_IFUNC
14835                         && h->def_regular
14836                         && (h->root.type == bfd_link_hash_defined
14837                             || h->root.type == bfd_link_hash_defweak));
14838             rela.r_offset = (htab->elf.iplt->output_section->vma
14839                              + htab->elf.iplt->output_offset
14840                              + ent->plt.offset);
14841             if (htab->opd_abi)
14842               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14843             else
14844               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14845             rela.r_addend = (h->root.u.def.value
14846                              + h->root.u.def.section->output_offset
14847                              + h->root.u.def.section->output_section->vma
14848                              + ent->addend);
14849             loc = (htab->elf.irelplt->contents
14850                    + (htab->elf.irelplt->reloc_count++
14851                       * sizeof (Elf64_External_Rela)));
14852           }
14853         else
14854           {
14855             rela.r_offset = (htab->elf.splt->output_section->vma
14856                              + htab->elf.splt->output_offset
14857                              + ent->plt.offset);
14858             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14859             rela.r_addend = ent->addend;
14860             loc = (htab->elf.srelplt->contents
14861                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14862                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14863           }
14864         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14865
14866         if (!htab->opd_abi)
14867           {
14868             if (!h->def_regular)
14869               {
14870                 /* Mark the symbol as undefined, rather than as
14871                    defined in glink.  Leave the value if there were
14872                    any relocations where pointer equality matters
14873                    (this is a clue for the dynamic linker, to make
14874                    function pointer comparisons work between an
14875                    application and shared library), otherwise set it
14876                    to zero.  */
14877                 sym->st_shndx = SHN_UNDEF;
14878                 if (!h->pointer_equality_needed)
14879                   sym->st_value = 0;
14880                 else if (!h->ref_regular_nonweak)
14881                   {
14882                     /* This breaks function pointer comparisons, but
14883                        that is better than breaking tests for a NULL
14884                        function pointer.  */
14885                     sym->st_value = 0;
14886                   }
14887               }
14888           }
14889       }
14890
14891   if (h->needs_copy)
14892     {
14893       /* This symbol needs a copy reloc.  Set it up.  */
14894
14895       if (h->dynindx == -1
14896           || (h->root.type != bfd_link_hash_defined
14897               && h->root.type != bfd_link_hash_defweak)
14898           || htab->relbss == NULL)
14899         abort ();
14900
14901       rela.r_offset = (h->root.u.def.value
14902                        + h->root.u.def.section->output_section->vma
14903                        + h->root.u.def.section->output_offset);
14904       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14905       rela.r_addend = 0;
14906       loc = htab->relbss->contents;
14907       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14908       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14909     }
14910
14911   return TRUE;
14912 }
14913
14914 /* Used to decide how to sort relocs in an optimal manner for the
14915    dynamic linker, before writing them out.  */
14916
14917 static enum elf_reloc_type_class
14918 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14919                             const asection *rel_sec,
14920                             const Elf_Internal_Rela *rela)
14921 {
14922   enum elf_ppc64_reloc_type r_type;
14923   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14924
14925   if (rel_sec == htab->elf.irelplt)
14926     return reloc_class_ifunc;
14927
14928   r_type = ELF64_R_TYPE (rela->r_info);
14929   switch (r_type)
14930     {
14931     case R_PPC64_RELATIVE:
14932       return reloc_class_relative;
14933     case R_PPC64_JMP_SLOT:
14934       return reloc_class_plt;
14935     case R_PPC64_COPY:
14936       return reloc_class_copy;
14937     default:
14938       return reloc_class_normal;
14939     }
14940 }
14941
14942 /* Finish up the dynamic sections.  */
14943
14944 static bfd_boolean
14945 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14946                                    struct bfd_link_info *info)
14947 {
14948   struct ppc_link_hash_table *htab;
14949   bfd *dynobj;
14950   asection *sdyn;
14951
14952   htab = ppc_hash_table (info);
14953   if (htab == NULL)
14954     return FALSE;
14955
14956   dynobj = htab->elf.dynobj;
14957   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14958
14959   if (htab->elf.dynamic_sections_created)
14960     {
14961       Elf64_External_Dyn *dyncon, *dynconend;
14962
14963       if (sdyn == NULL || htab->elf.sgot == NULL)
14964         abort ();
14965
14966       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14967       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14968       for (; dyncon < dynconend; dyncon++)
14969         {
14970           Elf_Internal_Dyn dyn;
14971           asection *s;
14972
14973           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14974
14975           switch (dyn.d_tag)
14976             {
14977             default:
14978               continue;
14979
14980             case DT_PPC64_GLINK:
14981               s = htab->glink;
14982               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14983               /* We stupidly defined DT_PPC64_GLINK to be the start
14984                  of glink rather than the first entry point, which is
14985                  what ld.so needs, and now have a bigger stub to
14986                  support automatic multiple TOCs.  */
14987               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14988               break;
14989
14990             case DT_PPC64_OPD:
14991               s = bfd_get_section_by_name (output_bfd, ".opd");
14992               if (s == NULL)
14993                 continue;
14994               dyn.d_un.d_ptr = s->vma;
14995               break;
14996
14997             case DT_PPC64_OPT:
14998               if (htab->do_multi_toc && htab->multi_toc_needed)
14999                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15000               break;
15001
15002             case DT_PPC64_OPDSZ:
15003               s = bfd_get_section_by_name (output_bfd, ".opd");
15004               if (s == NULL)
15005                 continue;
15006               dyn.d_un.d_val = s->size;
15007               break;
15008
15009             case DT_PLTGOT:
15010               s = htab->elf.splt;
15011               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15012               break;
15013
15014             case DT_JMPREL:
15015               s = htab->elf.srelplt;
15016               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15017               break;
15018
15019             case DT_PLTRELSZ:
15020               dyn.d_un.d_val = htab->elf.srelplt->size;
15021               break;
15022
15023             case DT_RELASZ:
15024               /* Don't count procedure linkage table relocs in the
15025                  overall reloc count.  */
15026               s = htab->elf.srelplt;
15027               if (s == NULL)
15028                 continue;
15029               dyn.d_un.d_val -= s->size;
15030               break;
15031
15032             case DT_RELA:
15033               /* We may not be using the standard ELF linker script.
15034                  If .rela.plt is the first .rela section, we adjust
15035                  DT_RELA to not include it.  */
15036               s = htab->elf.srelplt;
15037               if (s == NULL)
15038                 continue;
15039               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15040                 continue;
15041               dyn.d_un.d_ptr += s->size;
15042               break;
15043             }
15044
15045           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15046         }
15047     }
15048
15049   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15050     {
15051       /* Fill in the first entry in the global offset table.
15052          We use it to hold the link-time TOCbase.  */
15053       bfd_put_64 (output_bfd,
15054                   elf_gp (output_bfd) + TOC_BASE_OFF,
15055                   htab->elf.sgot->contents);
15056
15057       /* Set .got entry size.  */
15058       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15059     }
15060
15061   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15062     {
15063       /* Set .plt entry size.  */
15064       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15065         = PLT_ENTRY_SIZE (htab);
15066     }
15067
15068   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15069      brlt ourselves if emitrelocations.  */
15070   if (htab->brlt != NULL
15071       && htab->brlt->reloc_count != 0
15072       && !_bfd_elf_link_output_relocs (output_bfd,
15073                                        htab->brlt,
15074                                        elf_section_data (htab->brlt)->rela.hdr,
15075                                        elf_section_data (htab->brlt)->relocs,
15076                                        NULL))
15077     return FALSE;
15078
15079   if (htab->glink != NULL
15080       && htab->glink->reloc_count != 0
15081       && !_bfd_elf_link_output_relocs (output_bfd,
15082                                        htab->glink,
15083                                        elf_section_data (htab->glink)->rela.hdr,
15084                                        elf_section_data (htab->glink)->relocs,
15085                                        NULL))
15086     return FALSE;
15087
15088
15089   if (htab->glink_eh_frame != NULL
15090       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15091       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15092                                            htab->glink_eh_frame,
15093                                            htab->glink_eh_frame->contents))
15094     return FALSE;
15095
15096   /* We need to handle writing out multiple GOT sections ourselves,
15097      since we didn't add them to DYNOBJ.  We know dynobj is the first
15098      bfd.  */
15099   while ((dynobj = dynobj->link.next) != NULL)
15100     {
15101       asection *s;
15102
15103       if (!is_ppc64_elf (dynobj))
15104         continue;
15105
15106       s = ppc64_elf_tdata (dynobj)->got;
15107       if (s != NULL
15108           && s->size != 0
15109           && s->output_section != bfd_abs_section_ptr
15110           && !bfd_set_section_contents (output_bfd, s->output_section,
15111                                         s->contents, s->output_offset,
15112                                         s->size))
15113         return FALSE;
15114       s = ppc64_elf_tdata (dynobj)->relgot;
15115       if (s != NULL
15116           && s->size != 0
15117           && s->output_section != bfd_abs_section_ptr
15118           && !bfd_set_section_contents (output_bfd, s->output_section,
15119                                         s->contents, s->output_offset,
15120                                         s->size))
15121         return FALSE;
15122     }
15123
15124   return TRUE;
15125 }
15126
15127 #include "elf64-target.h"
15128
15129 /* FreeBSD support */
15130
15131 #undef  TARGET_LITTLE_SYM
15132 #undef  TARGET_LITTLE_NAME
15133
15134 #undef  TARGET_BIG_SYM
15135 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15136 #undef  TARGET_BIG_NAME
15137 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15138
15139 #undef  ELF_OSABI
15140 #define ELF_OSABI       ELFOSABI_FREEBSD
15141
15142 #undef  elf64_bed
15143 #define elf64_bed       elf64_powerpc_fbsd_bed
15144
15145 #include "elf64-target.h"
15146