bfd/elf64-ppc.c

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