bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141
 142 /* Offset of tp and dtp pointers from start of TLS block.  */
 143 #define TP_OFFSET       0x7000
 144 #define DTP_OFFSET      0x8000
 145
 146 /* .plt call stub instructions.  The normal stub is like this, but
 147    sometimes the .plt entry crosses a 64k boundary and we need to
 148    insert an addi to adjust r11.  */
 149 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 150 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 151 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 152 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 153 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 154 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 155 #define BCTR            0x4e800420      /* bctr                      */
 156
 157 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 158 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 159 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 160
 161 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 162 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 163 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 164 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 165 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 166 #define BNECTR          0x4ca20420      /* bnectr+               */
 167 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 168
 169 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 170 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 171 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 172
 173 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 174
 175 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 176 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 177 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 178
 179 /* glink call stub instructions.  We enter with the index in R0.  */
 180 #define GLINK_CALL_STUB_SIZE (16*4)
 181                                         /* 0:                           */
 182                                         /*  .quad plt0-1f               */
 183                                         /* __glink:                     */
 184 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 185 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 186                                         /* 1:                           */
 187 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 188                                         /*  ld %2,(0b-1b)(%11)          */
 189 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 190 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 191                                         /*  ld %12,0(%11)               */
 192                                         /*  ld %2,8(%11)                */
 193                                         /*  mtctr %12                   */
 194                                         /*  ld %11,16(%11)              */
 195                                         /*  bctr                        */
 196 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 197 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 198 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 199 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 200 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 201
 202 /* Pad with this.  */
 203 #define NOP             0x60000000
 204
 205 /* Some other nops.  */
 206 #define CROR_151515     0x4def7b82
 207 #define CROR_313131     0x4ffffb82
 208
 209 /* .glink entries for the first 32k functions are two instructions.  */
 210 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 211 #define B_DOT           0x48000000      /* b     .              */
 212
 213 /* After that, we need two instructions to load the index, followed by
 214    a branch.  */
 215 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 216 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 217
 218 /* Instructions used by the save and restore reg functions.  */
 219 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 220 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 221 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 222 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 223 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 224 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 225 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 226 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 227 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 228 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 229 #define BLR             0x4e800020      /* blr                  */
 230
 231 /* Since .opd is an array of descriptors and each entry will end up
 232    with identical R_PPC64_RELATIVE relocs, there is really no need to
 233    propagate .opd relocs;  The dynamic linker should be taught to
 234    relocate .opd without reloc entries.  */
 235 #ifndef NO_OPD_RELOCS
 236 #define NO_OPD_RELOCS 0
 237 #endif
 238
 239 static inline int
 240 abiversion (bfd *abfd)
 241 {
 242   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 243 }
 244
 245 static inline void
 246 set_abiversion (bfd *abfd, int ver)
 247 {
 248   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 249   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 250 }
 251 \f
 252 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 253
 254 /* Relocation HOWTO's.  */
 255 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 256
 257 static reloc_howto_type ppc64_elf_howto_raw[] = {
 258   /* This reloc does nothing.  */
 259   HOWTO (R_PPC64_NONE,          /* type */
 260          0,                     /* rightshift */
 261          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 262          32,                    /* bitsize */
 263          FALSE,                 /* pc_relative */
 264          0,                     /* bitpos */
 265          complain_overflow_dont, /* complain_on_overflow */
 266          bfd_elf_generic_reloc, /* special_function */
 267          "R_PPC64_NONE",        /* name */
 268          FALSE,                 /* partial_inplace */
 269          0,                     /* src_mask */
 270          0,                     /* dst_mask */
 271          FALSE),                /* pcrel_offset */
 272
 273   /* A standard 32 bit relocation.  */
 274   HOWTO (R_PPC64_ADDR32,        /* type */
 275          0,                     /* rightshift */
 276          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          32,                    /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_bitfield, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_ADDR32",      /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0xffffffff,            /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* An absolute 26 bit branch; the lower two bits must be zero.
 289      FIXME: we don't check that, we just clear them.  */
 290   HOWTO (R_PPC64_ADDR24,        /* type */
 291          0,                     /* rightshift */
 292          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 293          26,                    /* bitsize */
 294          FALSE,                 /* pc_relative */
 295          0,                     /* bitpos */
 296          complain_overflow_bitfield, /* complain_on_overflow */
 297          bfd_elf_generic_reloc, /* special_function */
 298          "R_PPC64_ADDR24",      /* name */
 299          FALSE,                 /* partial_inplace */
 300          0,                     /* src_mask */
 301          0x03fffffc,            /* dst_mask */
 302          FALSE),                /* pcrel_offset */
 303
 304   /* A standard 16 bit relocation.  */
 305   HOWTO (R_PPC64_ADDR16,        /* type */
 306          0,                     /* rightshift */
 307          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          16,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR16",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0xffff,                /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A 16 bit relocation without overflow.  */
 320   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_dont,/* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16_LO",   /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* Bits 16-31 of an address.  */
 335   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 336          16,                    /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_signed, /* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_HI",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 350      bits, treated as a signed number, is negative.  */
 351   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 352          16,                    /* rightshift */
 353          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 354          16,                    /* bitsize */
 355          FALSE,                 /* pc_relative */
 356          0,                     /* bitpos */
 357          complain_overflow_signed, /* complain_on_overflow */
 358          ppc64_elf_ha_reloc,    /* special_function */
 359          "R_PPC64_ADDR16_HA",   /* name */
 360          FALSE,                 /* partial_inplace */
 361          0,                     /* src_mask */
 362          0xffff,                /* dst_mask */
 363          FALSE),                /* pcrel_offset */
 364
 365   /* An absolute 16 bit branch; the lower two bits must be zero.
 366      FIXME: we don't check that, we just clear them.  */
 367   HOWTO (R_PPC64_ADDR14,        /* type */
 368          0,                     /* rightshift */
 369          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 370          16,                    /* bitsize */
 371          FALSE,                 /* pc_relative */
 372          0,                     /* bitpos */
 373          complain_overflow_signed, /* complain_on_overflow */
 374          ppc64_elf_branch_reloc, /* special_function */
 375          "R_PPC64_ADDR14",      /* name */
 376          FALSE,                 /* partial_inplace */
 377          0,                     /* src_mask */
 378          0x0000fffc,            /* dst_mask */
 379          FALSE),                /* pcrel_offset */
 380
 381   /* An absolute 16 bit branch, for which bit 10 should be set to
 382      indicate that the branch is expected to be taken.  The lower two
 383      bits must be zero.  */
 384   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 385          0,                     /* rightshift */
 386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          16,                    /* bitsize */
 388          FALSE,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_signed, /* complain_on_overflow */
 391          ppc64_elf_brtaken_reloc, /* special_function */
 392          "R_PPC64_ADDR14_BRTAKEN",/* name */
 393          FALSE,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          0x0000fffc,            /* dst_mask */
 396          FALSE),                /* pcrel_offset */
 397
 398   /* An absolute 16 bit branch, for which bit 10 should be set to
 399      indicate that the branch is not expected to be taken.  The lower
 400      two bits must be zero.  */
 401   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 402          0,                     /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          16,                    /* bitsize */
 405          FALSE,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_signed, /* complain_on_overflow */
 408          ppc64_elf_brtaken_reloc, /* special_function */
 409          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 410          FALSE,                 /* partial_inplace */
 411          0,                     /* src_mask */
 412          0x0000fffc,            /* dst_mask */
 413          FALSE),                /* pcrel_offset */
 414
 415   /* A relative 26 bit branch; the lower two bits must be zero.  */
 416   HOWTO (R_PPC64_REL24,         /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          26,                    /* bitsize */
 420          TRUE,                  /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_branch_reloc, /* special_function */
 424          "R_PPC64_REL24",       /* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x03fffffc,            /* dst_mask */
 428          TRUE),                 /* pcrel_offset */
 429
 430   /* A relative 16 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL14,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          16,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL14",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x0000fffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 446      the branch is expected to be taken.  The lower two bits must be
 447      zero.  */
 448   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 449          0,                     /* rightshift */
 450          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 451          16,                    /* bitsize */
 452          TRUE,                  /* pc_relative */
 453          0,                     /* bitpos */
 454          complain_overflow_signed, /* complain_on_overflow */
 455          ppc64_elf_brtaken_reloc, /* special_function */
 456          "R_PPC64_REL14_BRTAKEN", /* name */
 457          FALSE,                 /* partial_inplace */
 458          0,                     /* src_mask */
 459          0x0000fffc,            /* dst_mask */
 460          TRUE),                 /* pcrel_offset */
 461
 462   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 463      the branch is not expected to be taken.  The lower two bits must
 464      be zero.  */
 465   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 466          0,                     /* rightshift */
 467          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 468          16,                    /* bitsize */
 469          TRUE,                  /* pc_relative */
 470          0,                     /* bitpos */
 471          complain_overflow_signed, /* complain_on_overflow */
 472          ppc64_elf_brtaken_reloc, /* special_function */
 473          "R_PPC64_REL14_BRNTAKEN",/* name */
 474          FALSE,                 /* partial_inplace */
 475          0,                     /* src_mask */
 476          0x0000fffc,            /* dst_mask */
 477          TRUE),                 /* pcrel_offset */
 478
 479   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 480      symbol.  */
 481   HOWTO (R_PPC64_GOT16,         /* type */
 482          0,                     /* rightshift */
 483          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 484          16,                    /* bitsize */
 485          FALSE,                 /* pc_relative */
 486          0,                     /* bitpos */
 487          complain_overflow_signed, /* complain_on_overflow */
 488          ppc64_elf_unhandled_reloc, /* special_function */
 489          "R_PPC64_GOT16",       /* name */
 490          FALSE,                 /* partial_inplace */
 491          0,                     /* src_mask */
 492          0xffff,                /* dst_mask */
 493          FALSE),                /* pcrel_offset */
 494
 495   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 496      the symbol.  */
 497   HOWTO (R_PPC64_GOT16_LO,      /* type */
 498          0,                     /* rightshift */
 499          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 500          16,                    /* bitsize */
 501          FALSE,                 /* pc_relative */
 502          0,                     /* bitpos */
 503          complain_overflow_dont, /* complain_on_overflow */
 504          ppc64_elf_unhandled_reloc, /* special_function */
 505          "R_PPC64_GOT16_LO",    /* name */
 506          FALSE,                 /* partial_inplace */
 507          0,                     /* src_mask */
 508          0xffff,                /* dst_mask */
 509          FALSE),                /* pcrel_offset */
 510
 511   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 512      the symbol.  */
 513   HOWTO (R_PPC64_GOT16_HI,      /* type */
 514          16,                    /* rightshift */
 515          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 516          16,                    /* bitsize */
 517          FALSE,                 /* pc_relative */
 518          0,                     /* bitpos */
 519          complain_overflow_signed,/* complain_on_overflow */
 520          ppc64_elf_unhandled_reloc, /* special_function */
 521          "R_PPC64_GOT16_HI",    /* name */
 522          FALSE,                 /* partial_inplace */
 523          0,                     /* src_mask */
 524          0xffff,                /* dst_mask */
 525          FALSE),                /* pcrel_offset */
 526
 527   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 528      the symbol.  */
 529   HOWTO (R_PPC64_GOT16_HA,      /* type */
 530          16,                    /* rightshift */
 531          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 532          16,                    /* bitsize */
 533          FALSE,                 /* pc_relative */
 534          0,                     /* bitpos */
 535          complain_overflow_signed,/* complain_on_overflow */
 536          ppc64_elf_unhandled_reloc, /* special_function */
 537          "R_PPC64_GOT16_HA",    /* name */
 538          FALSE,                 /* partial_inplace */
 539          0,                     /* src_mask */
 540          0xffff,                /* dst_mask */
 541          FALSE),                /* pcrel_offset */
 542
 543   /* This is used only by the dynamic linker.  The symbol should exist
 544      both in the object being run and in some shared library.  The
 545      dynamic linker copies the data addressed by the symbol from the
 546      shared library into the object, because the object being
 547      run has to have the data at some particular address.  */
 548   HOWTO (R_PPC64_COPY,          /* type */
 549          0,                     /* rightshift */
 550          0,                     /* this one is variable size */
 551          0,                     /* bitsize */
 552          FALSE,                 /* pc_relative */
 553          0,                     /* bitpos */
 554          complain_overflow_dont, /* complain_on_overflow */
 555          ppc64_elf_unhandled_reloc, /* special_function */
 556          "R_PPC64_COPY",        /* name */
 557          FALSE,                 /* partial_inplace */
 558          0,                     /* src_mask */
 559          0,                     /* dst_mask */
 560          FALSE),                /* pcrel_offset */
 561
 562   /* Like R_PPC64_ADDR64, but used when setting global offset table
 563      entries.  */
 564   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 565          0,                     /* rightshift */
 566          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 567          64,                    /* bitsize */
 568          FALSE,                 /* pc_relative */
 569          0,                     /* bitpos */
 570          complain_overflow_dont, /* complain_on_overflow */
 571          ppc64_elf_unhandled_reloc,  /* special_function */
 572          "R_PPC64_GLOB_DAT",    /* name */
 573          FALSE,                 /* partial_inplace */
 574          0,                     /* src_mask */
 575          ONES (64),             /* dst_mask */
 576          FALSE),                /* pcrel_offset */
 577
 578   /* Created by the link editor.  Marks a procedure linkage table
 579      entry for a symbol.  */
 580   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 581          0,                     /* rightshift */
 582          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 583          0,                     /* bitsize */
 584          FALSE,                 /* pc_relative */
 585          0,                     /* bitpos */
 586          complain_overflow_dont, /* complain_on_overflow */
 587          ppc64_elf_unhandled_reloc, /* special_function */
 588          "R_PPC64_JMP_SLOT",    /* name */
 589          FALSE,                 /* partial_inplace */
 590          0,                     /* src_mask */
 591          0,                     /* dst_mask */
 592          FALSE),                /* pcrel_offset */
 593
 594   /* Used only by the dynamic linker.  When the object is run, this
 595      doubleword64 is set to the load address of the object, plus the
 596      addend.  */
 597   HOWTO (R_PPC64_RELATIVE,      /* type */
 598          0,                     /* rightshift */
 599          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 600          64,                    /* bitsize */
 601          FALSE,                 /* pc_relative */
 602          0,                     /* bitpos */
 603          complain_overflow_dont, /* complain_on_overflow */
 604          bfd_elf_generic_reloc, /* special_function */
 605          "R_PPC64_RELATIVE",    /* name */
 606          FALSE,                 /* partial_inplace */
 607          0,                     /* src_mask */
 608          ONES (64),             /* dst_mask */
 609          FALSE),                /* pcrel_offset */
 610
 611   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 612   HOWTO (R_PPC64_UADDR32,       /* type */
 613          0,                     /* rightshift */
 614          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 615          32,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_bitfield, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_UADDR32",     /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          0xffffffff,            /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR16,       /* type */
 628          0,                     /* rightshift */
 629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          16,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR16",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffff,                /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* 32-bit PC relative.  */
 642   HOWTO (R_PPC64_REL32,         /* type */
 643          0,                     /* rightshift */
 644          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          32,                    /* bitsize */
 646          TRUE,                  /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_signed, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_REL32",       /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffffffff,            /* dst_mask */
 654          TRUE),                 /* pcrel_offset */
 655
 656   /* 32-bit relocation to the symbol's procedure linkage table.  */
 657   HOWTO (R_PPC64_PLT32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          FALSE,                 /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_bitfield, /* complain_on_overflow */
 664          ppc64_elf_unhandled_reloc, /* special_function */
 665          "R_PPC64_PLT32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          FALSE),                /* pcrel_offset */
 670
 671   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 672      FIXME: R_PPC64_PLTREL32 not supported.  */
 673   HOWTO (R_PPC64_PLTREL32,      /* type */
 674          0,                     /* rightshift */
 675          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 676          32,                    /* bitsize */
 677          TRUE,                  /* pc_relative */
 678          0,                     /* bitpos */
 679          complain_overflow_signed, /* complain_on_overflow */
 680          bfd_elf_generic_reloc, /* special_function */
 681          "R_PPC64_PLTREL32",    /* name */
 682          FALSE,                 /* partial_inplace */
 683          0,                     /* src_mask */
 684          0xffffffff,            /* dst_mask */
 685          TRUE),                 /* pcrel_offset */
 686
 687   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 688      the symbol.  */
 689   HOWTO (R_PPC64_PLT16_LO,      /* type */
 690          0,                     /* rightshift */
 691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 692          16,                    /* bitsize */
 693          FALSE,                 /* pc_relative */
 694          0,                     /* bitpos */
 695          complain_overflow_dont, /* complain_on_overflow */
 696          ppc64_elf_unhandled_reloc, /* special_function */
 697          "R_PPC64_PLT16_LO",    /* name */
 698          FALSE,                 /* partial_inplace */
 699          0,                     /* src_mask */
 700          0xffff,                /* dst_mask */
 701          FALSE),                /* pcrel_offset */
 702
 703   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 704      the symbol.  */
 705   HOWTO (R_PPC64_PLT16_HI,      /* type */
 706          16,                    /* rightshift */
 707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 708          16,                    /* bitsize */
 709          FALSE,                 /* pc_relative */
 710          0,                     /* bitpos */
 711          complain_overflow_signed, /* complain_on_overflow */
 712          ppc64_elf_unhandled_reloc, /* special_function */
 713          "R_PPC64_PLT16_HI",    /* name */
 714          FALSE,                 /* partial_inplace */
 715          0,                     /* src_mask */
 716          0xffff,                /* dst_mask */
 717          FALSE),                /* pcrel_offset */
 718
 719   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 720      the symbol.  */
 721   HOWTO (R_PPC64_PLT16_HA,      /* type */
 722          16,                    /* rightshift */
 723          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 724          16,                    /* bitsize */
 725          FALSE,                 /* pc_relative */
 726          0,                     /* bitpos */
 727          complain_overflow_signed, /* complain_on_overflow */
 728          ppc64_elf_unhandled_reloc, /* special_function */
 729          "R_PPC64_PLT16_HA",    /* name */
 730          FALSE,                 /* partial_inplace */
 731          0,                     /* src_mask */
 732          0xffff,                /* dst_mask */
 733          FALSE),                /* pcrel_offset */
 734
 735   /* 16-bit section relative relocation.  */
 736   HOWTO (R_PPC64_SECTOFF,       /* type */
 737          0,                     /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_sectoff_reloc, /* special_function */
 744          "R_PPC64_SECTOFF",     /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 751   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_dont, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF_LO",  /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* 16-bit upper half section relative relocation.  */
 766   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 767          16,                    /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_signed, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_HI",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half adjusted section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_ha_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HA",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 796   HOWTO (R_PPC64_REL30,         /* type */
 797          2,                     /* rightshift */
 798          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          30,                    /* bitsize */
 800          TRUE,                  /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_dont, /* complain_on_overflow */
 803          bfd_elf_generic_reloc, /* special_function */
 804          "R_PPC64_REL30",       /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xfffffffc,            /* dst_mask */
 808          TRUE),                 /* pcrel_offset */
 809
 810   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 811
 812   /* A standard 64-bit relocation.  */
 813   HOWTO (R_PPC64_ADDR64,        /* type */
 814          0,                     /* rightshift */
 815          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 816          64,                    /* bitsize */
 817          FALSE,                 /* pc_relative */
 818          0,                     /* bitpos */
 819          complain_overflow_dont, /* complain_on_overflow */
 820          bfd_elf_generic_reloc, /* special_function */
 821          "R_PPC64_ADDR64",      /* name */
 822          FALSE,                 /* partial_inplace */
 823          0,                     /* src_mask */
 824          ONES (64),             /* dst_mask */
 825          FALSE),                /* pcrel_offset */
 826
 827   /* The bits 32-47 of an address.  */
 828   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 829          32,                    /* rightshift */
 830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 831          16,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR16_HIGHER", /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          0xffff,                /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address, plus 1 if the contents of the low
 843      16 bits, treated as a signed number, is negative.  */
 844   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 845          32,                    /* rightshift */
 846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 847          16,                    /* bitsize */
 848          FALSE,                 /* pc_relative */
 849          0,                     /* bitpos */
 850          complain_overflow_dont, /* complain_on_overflow */
 851          ppc64_elf_ha_reloc,    /* special_function */
 852          "R_PPC64_ADDR16_HIGHERA", /* name */
 853          FALSE,                 /* partial_inplace */
 854          0,                     /* src_mask */
 855          0xffff,                /* dst_mask */
 856          FALSE),                /* pcrel_offset */
 857
 858   /* The bits 48-63 of an address.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 860          48,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          bfd_elf_generic_reloc, /* special_function */
 867          "R_PPC64_ADDR16_HIGHEST", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address, plus 1 if the contents of the low
 874      16 bits, treated as a signed number, is negative.  */
 875   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 876          48,                    /* rightshift */
 877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 878          16,                    /* bitsize */
 879          FALSE,                 /* pc_relative */
 880          0,                     /* bitpos */
 881          complain_overflow_dont, /* complain_on_overflow */
 882          ppc64_elf_ha_reloc,    /* special_function */
 883          "R_PPC64_ADDR16_HIGHESTA", /* name */
 884          FALSE,                 /* partial_inplace */
 885          0,                     /* src_mask */
 886          0xffff,                /* dst_mask */
 887          FALSE),                /* pcrel_offset */
 888
 889   /* Like ADDR64, but may be unaligned.  */
 890   HOWTO (R_PPC64_UADDR64,       /* type */
 891          0,                     /* rightshift */
 892          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 893          64,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          bfd_elf_generic_reloc, /* special_function */
 898          "R_PPC64_UADDR64",     /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          ONES (64),             /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* 64-bit relative relocation.  */
 905   HOWTO (R_PPC64_REL64,         /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          TRUE,                  /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_REL64",       /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          TRUE),                 /* pcrel_offset */
 918
 919   /* 64-bit relocation to the symbol's procedure linkage table.  */
 920   HOWTO (R_PPC64_PLT64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          FALSE,                 /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          ppc64_elf_unhandled_reloc, /* special_function */
 928          "R_PPC64_PLT64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          FALSE),                /* pcrel_offset */
 933
 934   /* 64-bit PC relative relocation to the symbol's procedure linkage
 935      table.  */
 936   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 937   HOWTO (R_PPC64_PLTREL64,      /* type */
 938          0,                     /* rightshift */
 939          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 940          64,                    /* bitsize */
 941          TRUE,                  /* pc_relative */
 942          0,                     /* bitpos */
 943          complain_overflow_dont, /* complain_on_overflow */
 944          ppc64_elf_unhandled_reloc, /* special_function */
 945          "R_PPC64_PLTREL64",    /* name */
 946          FALSE,                 /* partial_inplace */
 947          0,                     /* src_mask */
 948          ONES (64),             /* dst_mask */
 949          TRUE),                 /* pcrel_offset */
 950
 951   /* 16 bit TOC-relative relocation.  */
 952
 953   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 954   HOWTO (R_PPC64_TOC16,         /* type */
 955          0,                     /* rightshift */
 956          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 957          16,                    /* bitsize */
 958          FALSE,                 /* pc_relative */
 959          0,                     /* bitpos */
 960          complain_overflow_signed, /* complain_on_overflow */
 961          ppc64_elf_toc_reloc,   /* special_function */
 962          "R_PPC64_TOC16",       /* name */
 963          FALSE,                 /* partial_inplace */
 964          0,                     /* src_mask */
 965          0xffff,                /* dst_mask */
 966          FALSE),                /* pcrel_offset */
 967
 968   /* 16 bit TOC-relative relocation without overflow.  */
 969
 970   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 971   HOWTO (R_PPC64_TOC16_LO,      /* type */
 972          0,                     /* rightshift */
 973          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 974          16,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_dont, /* complain_on_overflow */
 978          ppc64_elf_toc_reloc,   /* special_function */
 979          "R_PPC64_TOC16_LO",    /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          0xffff,                /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* 16 bit TOC-relative relocation, high 16 bits.  */
 986
 987   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 988   HOWTO (R_PPC64_TOC16_HI,      /* type */
 989          16,                    /* rightshift */
 990          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 991          16,                    /* bitsize */
 992          FALSE,                 /* pc_relative */
 993          0,                     /* bitpos */
 994          complain_overflow_signed, /* complain_on_overflow */
 995          ppc64_elf_toc_reloc,   /* special_function */
 996          "R_PPC64_TOC16_HI",    /* name */
 997          FALSE,                 /* partial_inplace */
 998          0,                     /* src_mask */
 999          0xffff,                /* dst_mask */
1000          FALSE),                /* pcrel_offset */
1001
1002   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1003      contents of the low 16 bits, treated as a signed number, is
1004      negative.  */
1005
1006   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1007   HOWTO (R_PPC64_TOC16_HA,      /* type */
1008          16,                    /* rightshift */
1009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1010          16,                    /* bitsize */
1011          FALSE,                 /* pc_relative */
1012          0,                     /* bitpos */
1013          complain_overflow_signed, /* complain_on_overflow */
1014          ppc64_elf_toc_ha_reloc, /* special_function */
1015          "R_PPC64_TOC16_HA",    /* name */
1016          FALSE,                 /* partial_inplace */
1017          0,                     /* src_mask */
1018          0xffff,                /* dst_mask */
1019          FALSE),                /* pcrel_offset */
1020
1021   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1022
1023   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1024   HOWTO (R_PPC64_TOC,           /* type */
1025          0,                     /* rightshift */
1026          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1027          64,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_dont, /* complain_on_overflow */
1031          ppc64_elf_toc64_reloc, /* special_function */
1032          "R_PPC64_TOC",         /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          ONES (64),             /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* Like R_PPC64_GOT16, but also informs the link editor that the
1039      value to relocate may (!) refer to a PLT entry which the link
1040      editor (a) may replace with the symbol value.  If the link editor
1041      is unable to fully resolve the symbol, it may (b) create a PLT
1042      entry and store the address to the new PLT entry in the GOT.
1043      This permits lazy resolution of function symbols at run time.
1044      The link editor may also skip all of this and just (c) emit a
1045      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1046   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1047     HOWTO (R_PPC64_PLTGOT16,    /* type */
1048          0,                     /* rightshift */
1049          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1050          16,                    /* bitsize */
1051          FALSE,                 /* pc_relative */
1052          0,                     /* bitpos */
1053          complain_overflow_signed, /* complain_on_overflow */
1054          ppc64_elf_unhandled_reloc, /* special_function */
1055          "R_PPC64_PLTGOT16",    /* name */
1056          FALSE,                 /* partial_inplace */
1057          0,                     /* src_mask */
1058          0xffff,                /* dst_mask */
1059          FALSE),                /* pcrel_offset */
1060
1061   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1062   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1063   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1064          0,                     /* rightshift */
1065          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1066          16,                    /* bitsize */
1067          FALSE,                 /* pc_relative */
1068          0,                     /* bitpos */
1069          complain_overflow_dont, /* complain_on_overflow */
1070          ppc64_elf_unhandled_reloc, /* special_function */
1071          "R_PPC64_PLTGOT16_LO", /* name */
1072          FALSE,                 /* partial_inplace */
1073          0,                     /* src_mask */
1074          0xffff,                /* dst_mask */
1075          FALSE),                /* pcrel_offset */
1076
1077   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1078   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1079   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1080          16,                    /* rightshift */
1081          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1082          16,                    /* bitsize */
1083          FALSE,                 /* pc_relative */
1084          0,                     /* bitpos */
1085          complain_overflow_signed, /* complain_on_overflow */
1086          ppc64_elf_unhandled_reloc, /* special_function */
1087          "R_PPC64_PLTGOT16_HI", /* name */
1088          FALSE,                 /* partial_inplace */
1089          0,                     /* src_mask */
1090          0xffff,                /* dst_mask */
1091          FALSE),                /* pcrel_offset */
1092
1093   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1094      1 if the contents of the low 16 bits, treated as a signed number,
1095      is negative.  */
1096   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1097   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1098          16,                    /* rightshift */
1099          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1100          16,                    /* bitsize */
1101          FALSE,                 /* pc_relative */
1102          0,                     /* bitpos */
1103          complain_overflow_signed, /* complain_on_overflow */
1104          ppc64_elf_unhandled_reloc, /* special_function */
1105          "R_PPC64_PLTGOT16_HA", /* name */
1106          FALSE,                 /* partial_inplace */
1107          0,                     /* src_mask */
1108          0xffff,                /* dst_mask */
1109          FALSE),                /* pcrel_offset */
1110
1111   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1112   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1113          0,                     /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          bfd_elf_generic_reloc, /* special_function */
1120          "R_PPC64_ADDR16_DS",   /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xfffc,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_dont,/* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_LO_DS",/* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_GOT16_DS,      /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_signed, /* complain_on_overflow */
1149          ppc64_elf_unhandled_reloc, /* special_function */
1150          "R_PPC64_GOT16_DS",    /* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_dont, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_LO_DS", /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_PLT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_signed, /* complain_on_overflow */
1194          ppc64_elf_sectoff_reloc, /* special_function */
1195          "R_PPC64_SECTOFF_DS",  /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_dont, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_LO_DS",/* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_TOC16_DS,      /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_signed, /* complain_on_overflow */
1224          ppc64_elf_toc_reloc,   /* special_function */
1225          "R_PPC64_TOC16_DS",    /* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_dont, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_LO_DS", /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1247   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1248   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1249          0,                     /* rightshift */
1250          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1251          16,                    /* bitsize */
1252          FALSE,                 /* pc_relative */
1253          0,                     /* bitpos */
1254          complain_overflow_signed, /* complain_on_overflow */
1255          ppc64_elf_unhandled_reloc, /* special_function */
1256          "R_PPC64_PLTGOT16_DS", /* name */
1257          FALSE,                 /* partial_inplace */
1258          0,                     /* src_mask */
1259          0xfffc,                /* dst_mask */
1260          FALSE),                /* pcrel_offset */
1261
1262   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1263   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1264   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1265          0,                     /* rightshift */
1266          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1267          16,                    /* bitsize */
1268          FALSE,                 /* pc_relative */
1269          0,                     /* bitpos */
1270          complain_overflow_dont, /* complain_on_overflow */
1271          ppc64_elf_unhandled_reloc, /* special_function */
1272          "R_PPC64_PLTGOT16_LO_DS",/* name */
1273          FALSE,                 /* partial_inplace */
1274          0,                     /* src_mask */
1275          0xfffc,                /* dst_mask */
1276          FALSE),                /* pcrel_offset */
1277
1278   /* Marker relocs for TLS.  */
1279   HOWTO (R_PPC64_TLS,
1280          0,                     /* rightshift */
1281          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          32,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          bfd_elf_generic_reloc, /* special_function */
1287          "R_PPC64_TLS",         /* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0,                     /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   HOWTO (R_PPC64_TLSGD,
1294          0,                     /* rightshift */
1295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1296          32,                    /* bitsize */
1297          FALSE,                 /* pc_relative */
1298          0,                     /* bitpos */
1299          complain_overflow_dont, /* complain_on_overflow */
1300          bfd_elf_generic_reloc, /* special_function */
1301          "R_PPC64_TLSGD",       /* name */
1302          FALSE,                 /* partial_inplace */
1303          0,                     /* src_mask */
1304          0,                     /* dst_mask */
1305          FALSE),                /* pcrel_offset */
1306
1307   HOWTO (R_PPC64_TLSLD,
1308          0,                     /* rightshift */
1309          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1310          32,                    /* bitsize */
1311          FALSE,                 /* pc_relative */
1312          0,                     /* bitpos */
1313          complain_overflow_dont, /* complain_on_overflow */
1314          bfd_elf_generic_reloc, /* special_function */
1315          "R_PPC64_TLSLD",       /* name */
1316          FALSE,                 /* partial_inplace */
1317          0,                     /* src_mask */
1318          0,                     /* dst_mask */
1319          FALSE),                /* pcrel_offset */
1320
1321   HOWTO (R_PPC64_TOCSAVE,
1322          0,                     /* rightshift */
1323          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1324          32,                    /* bitsize */
1325          FALSE,                 /* pc_relative */
1326          0,                     /* bitpos */
1327          complain_overflow_dont, /* complain_on_overflow */
1328          bfd_elf_generic_reloc, /* special_function */
1329          "R_PPC64_TOCSAVE",     /* name */
1330          FALSE,                 /* partial_inplace */
1331          0,                     /* src_mask */
1332          0,                     /* dst_mask */
1333          FALSE),                /* pcrel_offset */
1334
1335   /* Computes the load module index of the load module that contains the
1336      definition of its TLS sym.  */
1337   HOWTO (R_PPC64_DTPMOD64,
1338          0,                     /* rightshift */
1339          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1340          64,                    /* bitsize */
1341          FALSE,                 /* pc_relative */
1342          0,                     /* bitpos */
1343          complain_overflow_dont, /* complain_on_overflow */
1344          ppc64_elf_unhandled_reloc, /* special_function */
1345          "R_PPC64_DTPMOD64",    /* name */
1346          FALSE,                 /* partial_inplace */
1347          0,                     /* src_mask */
1348          ONES (64),             /* dst_mask */
1349          FALSE),                /* pcrel_offset */
1350
1351   /* Computes a dtv-relative displacement, the difference between the value
1352      of sym+add and the base address of the thread-local storage block that
1353      contains the definition of sym, minus 0x8000.  */
1354   HOWTO (R_PPC64_DTPREL64,
1355          0,                     /* rightshift */
1356          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1357          64,                    /* bitsize */
1358          FALSE,                 /* pc_relative */
1359          0,                     /* bitpos */
1360          complain_overflow_dont, /* complain_on_overflow */
1361          ppc64_elf_unhandled_reloc, /* special_function */
1362          "R_PPC64_DTPREL64",    /* name */
1363          FALSE,                 /* partial_inplace */
1364          0,                     /* src_mask */
1365          ONES (64),             /* dst_mask */
1366          FALSE),                /* pcrel_offset */
1367
1368   /* A 16 bit dtprel reloc.  */
1369   HOWTO (R_PPC64_DTPREL16,
1370          0,                     /* rightshift */
1371          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          16,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_signed, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL16",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          0xffff,                /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* Like DTPREL16, but no overflow.  */
1384   HOWTO (R_PPC64_DTPREL16_LO,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_dont, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16_LO", /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1399   HOWTO (R_PPC64_DTPREL16_HI,
1400          16,                    /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_signed, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_HI", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HA,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HA", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HIGHER,
1430          32,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_dont, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HIGHER", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHERA", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1460          48,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHEST", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16, but for insns with a DS field.  */
1489   HOWTO (R_PPC64_DTPREL16_DS,
1490          0,                     /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_signed, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_DS", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xfffc,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16_DS, but no overflow.  */
1504   HOWTO (R_PPC64_DTPREL16_LO_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_dont, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_LO_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Computes a tp-relative displacement, the difference between the value of
1519      sym+add and the value of the thread pointer (r13).  */
1520   HOWTO (R_PPC64_TPREL64,
1521          0,                     /* rightshift */
1522          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1523          64,                    /* bitsize */
1524          FALSE,                 /* pc_relative */
1525          0,                     /* bitpos */
1526          complain_overflow_dont, /* complain_on_overflow */
1527          ppc64_elf_unhandled_reloc, /* special_function */
1528          "R_PPC64_TPREL64",     /* name */
1529          FALSE,                 /* partial_inplace */
1530          0,                     /* src_mask */
1531          ONES (64),             /* dst_mask */
1532          FALSE),                /* pcrel_offset */
1533
1534   /* A 16 bit tprel reloc.  */
1535   HOWTO (R_PPC64_TPREL16,
1536          0,                     /* rightshift */
1537          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          16,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_signed, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL16",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          0xffff,                /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* Like TPREL16, but no overflow.  */
1550   HOWTO (R_PPC64_TPREL16_LO,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_dont, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16_LO",  /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1565   HOWTO (R_PPC64_TPREL16_HI,
1566          16,                    /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_signed, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_HI",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HA,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HA",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HIGHER,
1596          32,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_dont, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HIGHER",      /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHERA,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHERA", /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHEST,
1626          48,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHEST", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHESTA", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16, but for insns with a DS field.  */
1655   HOWTO (R_PPC64_TPREL16_DS,
1656          0,                     /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_signed, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_DS",  /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xfffc,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16_DS, but no overflow.  */
1670   HOWTO (R_PPC64_TPREL16_LO_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_dont, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_LO_DS", /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1685      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1686      to the first entry relative to the TOC base (r2).  */
1687   HOWTO (R_PPC64_GOT_TLSGD16,
1688          0,                     /* rightshift */
1689          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1690          16,                    /* bitsize */
1691          FALSE,                 /* pc_relative */
1692          0,                     /* bitpos */
1693          complain_overflow_signed, /* complain_on_overflow */
1694          ppc64_elf_unhandled_reloc, /* special_function */
1695          "R_PPC64_GOT_TLSGD16", /* name */
1696          FALSE,                 /* partial_inplace */
1697          0,                     /* src_mask */
1698          0xffff,                /* dst_mask */
1699          FALSE),                /* pcrel_offset */
1700
1701   /* Like GOT_TLSGD16, but no overflow.  */
1702   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_dont, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16_LO", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1718          16,                    /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_signed, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_HI", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HA", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1747      with values (sym+add)@dtpmod and zero, and computes the offset to the
1748      first entry relative to the TOC base (r2).  */
1749   HOWTO (R_PPC64_GOT_TLSLD16,
1750          0,                     /* rightshift */
1751          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1752          16,                    /* bitsize */
1753          FALSE,                 /* pc_relative */
1754          0,                     /* bitpos */
1755          complain_overflow_signed, /* complain_on_overflow */
1756          ppc64_elf_unhandled_reloc, /* special_function */
1757          "R_PPC64_GOT_TLSLD16", /* name */
1758          FALSE,                 /* partial_inplace */
1759          0,                     /* src_mask */
1760          0xffff,                /* dst_mask */
1761          FALSE),                /* pcrel_offset */
1762
1763   /* Like GOT_TLSLD16, but no overflow.  */
1764   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_dont, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16_LO", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1780          16,                    /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_signed, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_HI", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HA", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1809      the offset to the entry relative to the TOC base (r2).  */
1810   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1811          0,                     /* rightshift */
1812          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1813          16,                    /* bitsize */
1814          FALSE,                 /* pc_relative */
1815          0,                     /* bitpos */
1816          complain_overflow_signed, /* complain_on_overflow */
1817          ppc64_elf_unhandled_reloc, /* special_function */
1818          "R_PPC64_GOT_DTPREL16_DS", /* name */
1819          FALSE,                 /* partial_inplace */
1820          0,                     /* src_mask */
1821          0xfffc,                /* dst_mask */
1822          FALSE),                /* pcrel_offset */
1823
1824   /* Like GOT_DTPREL16_DS, but no overflow.  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_dont, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1841          16,                    /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_signed, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_HI", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xffff,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HA", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1870      offset to the entry relative to the TOC base (r2).  */
1871   HOWTO (R_PPC64_GOT_TPREL16_DS,
1872          0,                     /* rightshift */
1873          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1874          16,                    /* bitsize */
1875          FALSE,                 /* pc_relative */
1876          0,                     /* bitpos */
1877          complain_overflow_signed, /* complain_on_overflow */
1878          ppc64_elf_unhandled_reloc, /* special_function */
1879          "R_PPC64_GOT_TPREL16_DS", /* name */
1880          FALSE,                 /* partial_inplace */
1881          0,                     /* src_mask */
1882          0xfffc,                /* dst_mask */
1883          FALSE),                /* pcrel_offset */
1884
1885   /* Like GOT_TPREL16_DS, but no overflow.  */
1886   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_dont, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_HI,
1902          16,                    /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_signed, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_HI", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xffff,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HA,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HA", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   HOWTO (R_PPC64_JMP_IREL,      /* type */
1931          0,                     /* rightshift */
1932          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1933          0,                     /* bitsize */
1934          FALSE,                 /* pc_relative */
1935          0,                     /* bitpos */
1936          complain_overflow_dont, /* complain_on_overflow */
1937          ppc64_elf_unhandled_reloc, /* special_function */
1938          "R_PPC64_JMP_IREL",    /* name */
1939          FALSE,                 /* partial_inplace */
1940          0,                     /* src_mask */
1941          0,                     /* dst_mask */
1942          FALSE),                /* pcrel_offset */
1943
1944   HOWTO (R_PPC64_IRELATIVE,     /* type */
1945          0,                     /* rightshift */
1946          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1947          64,                    /* bitsize */
1948          FALSE,                 /* pc_relative */
1949          0,                     /* bitpos */
1950          complain_overflow_dont, /* complain_on_overflow */
1951          bfd_elf_generic_reloc, /* special_function */
1952          "R_PPC64_IRELATIVE",   /* name */
1953          FALSE,                 /* partial_inplace */
1954          0,                     /* src_mask */
1955          ONES (64),             /* dst_mask */
1956          FALSE),                /* pcrel_offset */
1957
1958   /* A 16 bit relative relocation.  */
1959   HOWTO (R_PPC64_REL16,         /* type */
1960          0,                     /* rightshift */
1961          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1962          16,                    /* bitsize */
1963          TRUE,                  /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_signed, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_REL16",       /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          0xffff,                /* dst_mask */
1971          TRUE),                 /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation without overflow.  */
1974   HOWTO (R_PPC64_REL16_LO,      /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_dont,/* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16_LO",    /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* The high order 16 bits of a relative address.  */
1989   HOWTO (R_PPC64_REL16_HI,      /* type */
1990          16,                    /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_signed, /* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_HI",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address, plus 1 if the contents of
2004      the low 16 bits, treated as a signed number, is negative.  */
2005   HOWTO (R_PPC64_REL16_HA,      /* type */
2006          16,                    /* rightshift */
2007          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2008          16,                    /* bitsize */
2009          TRUE,                  /* pc_relative */
2010          0,                     /* bitpos */
2011          complain_overflow_signed, /* complain_on_overflow */
2012          ppc64_elf_ha_reloc,    /* special_function */
2013          "R_PPC64_REL16_HA",    /* name */
2014          FALSE,                 /* partial_inplace */
2015          0,                     /* src_mask */
2016          0xffff,                /* dst_mask */
2017          TRUE),                 /* pcrel_offset */
2018
2019   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2020   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          FALSE,                 /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_dont, /* complain_on_overflow */
2027          bfd_elf_generic_reloc, /* special_function */
2028          "R_PPC64_ADDR16_HIGH", /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          FALSE),                /* pcrel_offset */
2033
2034   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2035   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2036          16,                    /* rightshift */
2037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          FALSE,                 /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_dont, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_ADDR16_HIGHA",        /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0xffff,                /* dst_mask */
2047          FALSE),                /* pcrel_offset */
2048
2049   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2050   HOWTO (R_PPC64_DTPREL16_HIGH,
2051          16,                    /* rightshift */
2052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_dont, /* complain_on_overflow */
2057          ppc64_elf_unhandled_reloc, /* special_function */
2058          "R_PPC64_DTPREL16_HIGH", /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0xffff,                /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2065   HOWTO (R_PPC64_DTPREL16_HIGHA,
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          ppc64_elf_unhandled_reloc, /* special_function */
2073          "R_PPC64_DTPREL16_HIGHA", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2080   HOWTO (R_PPC64_TPREL16_HIGH,
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_unhandled_reloc, /* special_function */
2088          "R_PPC64_TPREL16_HIGH",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2095   HOWTO (R_PPC64_TPREL16_HIGHA,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_TPREL16_HIGHA",       /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like ADDR64, but use local entry point of function.  */
2110   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2111          0,                     /* rightshift */
2112          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2113          64,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          bfd_elf_generic_reloc, /* special_function */
2118          "R_PPC64_ADDR64_LOCAL", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          ONES (64),             /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* GNU extension to record C++ vtable hierarchy.  */
2125   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2126          0,                     /* rightshift */
2127          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          0,                     /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          NULL,                  /* special_function */
2133          "R_PPC64_GNU_VTINHERIT", /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0,                     /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* GNU extension to record C++ vtable member usage.  */
2140   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2141          0,                     /* rightshift */
2142          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          0,                     /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          NULL,                  /* special_function */
2148          "R_PPC64_GNU_VTENTRY", /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0,                     /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153 };
2154
2155 \f
2156 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2157    be done.  */
2158
2159 static void
2160 ppc_howto_init (void)
2161 {
2162   unsigned int i, type;
2163
2164   for (i = 0;
2165        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2166        i++)
2167     {
2168       type = ppc64_elf_howto_raw[i].type;
2169       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2170                           / sizeof (ppc64_elf_howto_table[0])));
2171       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2172     }
2173 }
2174
2175 static reloc_howto_type *
2176 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2177                              bfd_reloc_code_real_type code)
2178 {
2179   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2180
2181   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2182     /* Initialize howto table if needed.  */
2183     ppc_howto_init ();
2184
2185   switch (code)
2186     {
2187     default:
2188       return NULL;
2189
2190     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2191       break;
2192     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2193       break;
2194     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2195       break;
2196     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2197       break;
2198     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2199       break;
2200     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2201       break;
2202     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2203       break;
2204     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2205       break;
2206     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2207       break;
2208     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2209       break;
2210     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2211       break;
2212     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2213       break;
2214     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2215       break;
2216     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2217       break;
2218     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2219       break;
2220     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2221       break;
2222     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2223       break;
2224     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2225       break;
2226     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2227       break;
2228     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2229       break;
2230     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2231       break;
2232     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2233       break;
2234     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2235       break;
2236     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2237       break;
2238     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2239       break;
2240     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2241       break;
2242     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2243       break;
2244     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2245       break;
2246     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2247       break;
2248     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2249       break;
2250     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2251       break;
2252     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2253       break;
2254     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2255       break;
2256     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2257       break;
2258     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2259       break;
2260     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2261       break;
2262     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2263       break;
2264     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2265       break;
2266     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2267       break;
2268     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2269       break;
2270     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2271       break;
2272     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2273       break;
2274     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2275       break;
2276     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2279       break;
2280     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2281       break;
2282     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2285       break;
2286     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2287       break;
2288     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2289       break;
2290     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2291       break;
2292     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2293       break;
2294     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2295       break;
2296     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2297       break;
2298     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2299       break;
2300     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2301       break;
2302     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2303       break;
2304     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2305       break;
2306     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2307       break;
2308     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2309       break;
2310     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2311       break;
2312     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2313       break;
2314     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2315       break;
2316     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2317       break;
2318     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2319       break;
2320     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2321       break;
2322     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2323       break;
2324     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2325       break;
2326     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2327       break;
2328     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2329       break;
2330     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2331       break;
2332     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2333       break;
2334     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2335       break;
2336     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2337       break;
2338     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2339       break;
2340     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2341       break;
2342     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2343       break;
2344     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2345       break;
2346     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2347       break;
2348     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2349       break;
2350     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2351       break;
2352     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2353       break;
2354     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2355       break;
2356     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2357       break;
2358     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2359       break;
2360     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2361       break;
2362     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2363       break;
2364     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2365       break;
2366     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2367       break;
2368     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2369       break;
2370     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2371       break;
2372     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2373       break;
2374     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2375       break;
2376     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2377       break;
2378     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2379       break;
2380     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2381       break;
2382     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2383       break;
2384     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2385       break;
2386     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2387       break;
2388     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2389       break;
2390     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2391       break;
2392     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2393       break;
2394     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2395       break;
2396     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2397       break;
2398     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2399       break;
2400     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2401       break;
2402     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2403       break;
2404     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2405       break;
2406     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2407       break;
2408     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2409       break;
2410     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2411       break;
2412     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2413       break;
2414     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2415       break;
2416     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2417       break;
2418     }
2419
2420   return ppc64_elf_howto_table[r];
2421 };
2422
2423 static reloc_howto_type *
2424 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2425                              const char *r_name)
2426 {
2427   unsigned int i;
2428
2429   for (i = 0;
2430        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2431        i++)
2432     if (ppc64_elf_howto_raw[i].name != NULL
2433         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2434       return &ppc64_elf_howto_raw[i];
2435
2436   return NULL;
2437 }
2438
2439 /* Set the howto pointer for a PowerPC ELF reloc.  */
2440
2441 static void
2442 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2443                          Elf_Internal_Rela *dst)
2444 {
2445   unsigned int type;
2446
2447   /* Initialize howto table if needed.  */
2448   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2449     ppc_howto_init ();
2450
2451   type = ELF64_R_TYPE (dst->r_info);
2452   if (type >= (sizeof (ppc64_elf_howto_table)
2453                / sizeof (ppc64_elf_howto_table[0])))
2454     {
2455       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2456                              abfd, (int) type);
2457       type = R_PPC64_NONE;
2458     }
2459   cache_ptr->howto = ppc64_elf_howto_table[type];
2460 }
2461
2462 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2463
2464 static bfd_reloc_status_type
2465 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2466                     void *data, asection *input_section,
2467                     bfd *output_bfd, char **error_message)
2468 {
2469   /* If this is a relocatable link (output_bfd test tells us), just
2470      call the generic function.  Any adjustment will be done at final
2471      link time.  */
2472   if (output_bfd != NULL)
2473     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2474                                   input_section, output_bfd, error_message);
2475
2476   /* Adjust the addend for sign extension of the low 16 bits.
2477      We won't actually be using the low 16 bits, so trashing them
2478      doesn't matter.  */
2479   reloc_entry->addend += 0x8000;
2480   return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485                         void *data, asection *input_section,
2486                         bfd *output_bfd, char **error_message)
2487 {
2488   if (output_bfd != NULL)
2489     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2490                                   input_section, output_bfd, error_message);
2491
2492   if (strcmp (symbol->section->name, ".opd") == 0
2493       && (symbol->section->owner->flags & DYNAMIC) == 0)
2494     {
2495       bfd_vma dest = opd_entry_value (symbol->section,
2496                                       symbol->value + reloc_entry->addend,
2497                                       NULL, NULL, FALSE);
2498       if (dest != (bfd_vma) -1)
2499         reloc_entry->addend = dest - (symbol->value
2500                                       + symbol->section->output_section->vma
2501                                       + symbol->section->output_offset);
2502     }
2503   else
2504     {
2505       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2506
2507       if (symbol->section->owner != abfd
2508           && abiversion (symbol->section->owner) >= 2)
2509         {
2510           unsigned int i;
2511
2512           for (i = 0; i < symbol->section->owner->symcount; ++i)
2513             {
2514               asymbol *symdef = symbol->section->owner->outsymbols[i];
2515
2516               if (strcmp (symdef->name, symbol->name) == 0)
2517                 {
2518                   elfsym = (elf_symbol_type *) symdef;
2519                   break;
2520                 }
2521             }
2522         }
2523       reloc_entry->addend
2524         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2525     }
2526   return bfd_reloc_continue;
2527 }
2528
2529 static bfd_reloc_status_type
2530 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2531                          void *data, asection *input_section,
2532                          bfd *output_bfd, char **error_message)
2533 {
2534   long insn;
2535   enum elf_ppc64_reloc_type r_type;
2536   bfd_size_type octets;
2537   /* Assume 'at' branch hints.  */
2538   bfd_boolean is_isa_v2 = TRUE;
2539
2540   /* If this is a relocatable link (output_bfd test tells us), just
2541      call the generic function.  Any adjustment will be done at final
2542      link time.  */
2543   if (output_bfd != NULL)
2544     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2545                                   input_section, output_bfd, error_message);
2546
2547   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2548   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2549   insn &= ~(0x01 << 21);
2550   r_type = reloc_entry->howto->type;
2551   if (r_type == R_PPC64_ADDR14_BRTAKEN
2552       || r_type == R_PPC64_REL14_BRTAKEN)
2553     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2554
2555   if (is_isa_v2)
2556     {
2557       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2558          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2559          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2560       if ((insn & (0x14 << 21)) == (0x04 << 21))
2561         insn |= 0x02 << 21;
2562       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2563         insn |= 0x08 << 21;
2564       else
2565         goto out;
2566     }
2567   else
2568     {
2569       bfd_vma target = 0;
2570       bfd_vma from;
2571
2572       if (!bfd_is_com_section (symbol->section))
2573         target = symbol->value;
2574       target += symbol->section->output_section->vma;
2575       target += symbol->section->output_offset;
2576       target += reloc_entry->addend;
2577
2578       from = (reloc_entry->address
2579               + input_section->output_offset
2580               + input_section->output_section->vma);
2581
2582       /* Invert 'y' bit if not the default.  */
2583       if ((bfd_signed_vma) (target - from) < 0)
2584         insn ^= 0x01 << 21;
2585     }
2586   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2587  out:
2588   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2589                                  input_section, output_bfd, error_message);
2590 }
2591
2592 static bfd_reloc_status_type
2593 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2594                          void *data, asection *input_section,
2595                          bfd *output_bfd, char **error_message)
2596 {
2597   /* If this is a relocatable link (output_bfd test tells us), just
2598      call the generic function.  Any adjustment will be done at final
2599      link time.  */
2600   if (output_bfd != NULL)
2601     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2602                                   input_section, output_bfd, error_message);
2603
2604   /* Subtract the symbol section base address.  */
2605   reloc_entry->addend -= symbol->section->output_section->vma;
2606   return bfd_reloc_continue;
2607 }
2608
2609 static bfd_reloc_status_type
2610 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2611                             void *data, asection *input_section,
2612                             bfd *output_bfd, char **error_message)
2613 {
2614   /* If this is a relocatable link (output_bfd test tells us), just
2615      call the generic function.  Any adjustment will be done at final
2616      link time.  */
2617   if (output_bfd != NULL)
2618     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2619                                   input_section, output_bfd, error_message);
2620
2621   /* Subtract the symbol section base address.  */
2622   reloc_entry->addend -= symbol->section->output_section->vma;
2623
2624   /* Adjust the addend for sign extension of the low 16 bits.  */
2625   reloc_entry->addend += 0x8000;
2626   return bfd_reloc_continue;
2627 }
2628
2629 static bfd_reloc_status_type
2630 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2631                      void *data, asection *input_section,
2632                      bfd *output_bfd, char **error_message)
2633 {
2634   bfd_vma TOCstart;
2635
2636   /* If this is a relocatable link (output_bfd test tells us), just
2637      call the generic function.  Any adjustment will be done at final
2638      link time.  */
2639   if (output_bfd != NULL)
2640     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2641                                   input_section, output_bfd, error_message);
2642
2643   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2644   if (TOCstart == 0)
2645     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2646
2647   /* Subtract the TOC base address.  */
2648   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2649   return bfd_reloc_continue;
2650 }
2651
2652 static bfd_reloc_status_type
2653 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2654                         void *data, asection *input_section,
2655                         bfd *output_bfd, char **error_message)
2656 {
2657   bfd_vma TOCstart;
2658
2659   /* If this is a relocatable link (output_bfd test tells us), just
2660      call the generic function.  Any adjustment will be done at final
2661      link time.  */
2662   if (output_bfd != NULL)
2663     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2664                                   input_section, output_bfd, error_message);
2665
2666   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2667   if (TOCstart == 0)
2668     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2669
2670   /* Subtract the TOC base address.  */
2671   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2672
2673   /* Adjust the addend for sign extension of the low 16 bits.  */
2674   reloc_entry->addend += 0x8000;
2675   return bfd_reloc_continue;
2676 }
2677
2678 static bfd_reloc_status_type
2679 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2680                        void *data, asection *input_section,
2681                        bfd *output_bfd, char **error_message)
2682 {
2683   bfd_vma TOCstart;
2684   bfd_size_type octets;
2685
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2694   if (TOCstart == 0)
2695     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2696
2697   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2698   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2699   return bfd_reloc_ok;
2700 }
2701
2702 static bfd_reloc_status_type
2703 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2704                            void *data, asection *input_section,
2705                            bfd *output_bfd, char **error_message)
2706 {
2707   /* If this is a relocatable link (output_bfd test tells us), just
2708      call the generic function.  Any adjustment will be done at final
2709      link time.  */
2710   if (output_bfd != NULL)
2711     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2712                                   input_section, output_bfd, error_message);
2713
2714   if (error_message != NULL)
2715     {
2716       static char buf[60];
2717       sprintf (buf, "generic linker can't handle %s",
2718                reloc_entry->howto->name);
2719       *error_message = buf;
2720     }
2721   return bfd_reloc_dangerous;
2722 }
2723
2724 /* Track GOT entries needed for a given symbol.  We might need more
2725    than one got entry per symbol.  */
2726 struct got_entry
2727 {
2728   struct got_entry *next;
2729
2730   /* The symbol addend that we'll be placing in the GOT.  */
2731   bfd_vma addend;
2732
2733   /* Unlike other ELF targets, we use separate GOT entries for the same
2734      symbol referenced from different input files.  This is to support
2735      automatic multiple TOC/GOT sections, where the TOC base can vary
2736      from one input file to another.  After partitioning into TOC groups
2737      we merge entries within the group.
2738
2739      Point to the BFD owning this GOT entry.  */
2740   bfd *owner;
2741
2742   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2743      TLS_TPREL or TLS_DTPREL for tls entries.  */
2744   unsigned char tls_type;
2745
2746   /* Non-zero if got.ent points to real entry.  */
2747   unsigned char is_indirect;
2748
2749   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2750   union
2751     {
2752       bfd_signed_vma refcount;
2753       bfd_vma offset;
2754       struct got_entry *ent;
2755     } got;
2756 };
2757
2758 /* The same for PLT.  */
2759 struct plt_entry
2760 {
2761   struct plt_entry *next;
2762
2763   bfd_vma addend;
2764
2765   union
2766     {
2767       bfd_signed_vma refcount;
2768       bfd_vma offset;
2769     } plt;
2770 };
2771
2772 struct ppc64_elf_obj_tdata
2773 {
2774   struct elf_obj_tdata elf;
2775
2776   /* Shortcuts to dynamic linker sections.  */
2777   asection *got;
2778   asection *relgot;
2779
2780   /* Used during garbage collection.  We attach global symbols defined
2781      on removed .opd entries to this section so that the sym is removed.  */
2782   asection *deleted_section;
2783
2784   /* TLS local dynamic got entry handling.  Support for multiple GOT
2785      sections means we potentially need one of these for each input bfd.  */
2786   struct got_entry tlsld_got;
2787
2788   union {
2789     /* A copy of relocs before they are modified for --emit-relocs.  */
2790     Elf_Internal_Rela *relocs;
2791
2792     /* Section contents.  */
2793     bfd_byte *contents;
2794   } opd;
2795
2796   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2797      the reloc to be in the range -32768 to 32767.  */
2798   unsigned int has_small_toc_reloc : 1;
2799
2800   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2801      instruction not one we handle.  */
2802   unsigned int unexpected_toc_insn : 1;
2803 };
2804
2805 #define ppc64_elf_tdata(bfd) \
2806   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2807
2808 #define ppc64_tlsld_got(bfd) \
2809   (&ppc64_elf_tdata (bfd)->tlsld_got)
2810
2811 #define is_ppc64_elf(bfd) \
2812   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2813    && elf_object_id (bfd) == PPC64_ELF_DATA)
2814
2815 /* Override the generic function because we store some extras.  */
2816
2817 static bfd_boolean
2818 ppc64_elf_mkobject (bfd *abfd)
2819 {
2820   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2821                                   PPC64_ELF_DATA);
2822 }
2823
2824 /* Fix bad default arch selected for a 64 bit input bfd when the
2825    default is 32 bit.  */
2826
2827 static bfd_boolean
2828 ppc64_elf_object_p (bfd *abfd)
2829 {
2830   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2831     {
2832       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2833
2834       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2835         {
2836           /* Relies on arch after 32 bit default being 64 bit default.  */
2837           abfd->arch_info = abfd->arch_info->next;
2838           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2839         }
2840     }
2841   return TRUE;
2842 }
2843
2844 /* Support for core dump NOTE sections.  */
2845
2846 static bfd_boolean
2847 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2848 {
2849   size_t offset, size;
2850
2851   if (note->descsz != 504)
2852     return FALSE;
2853
2854   /* pr_cursig */
2855   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2856
2857   /* pr_pid */
2858   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2859
2860   /* pr_reg */
2861   offset = 112;
2862   size = 384;
2863
2864   /* Make a ".reg/999" section.  */
2865   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2866                                           size, note->descpos + offset);
2867 }
2868
2869 static bfd_boolean
2870 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2871 {
2872   if (note->descsz != 136)
2873     return FALSE;
2874
2875   elf_tdata (abfd)->core->pid
2876     = bfd_get_32 (abfd, note->descdata + 24);
2877   elf_tdata (abfd)->core->program
2878     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2879   elf_tdata (abfd)->core->command
2880     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2881
2882   return TRUE;
2883 }
2884
2885 static char *
2886 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2887                            ...)
2888 {
2889   switch (note_type)
2890     {
2891     default:
2892       return NULL;
2893
2894     case NT_PRPSINFO:
2895       {
2896         char data[136];
2897         va_list ap;
2898
2899         va_start (ap, note_type);
2900         memset (data, 0, sizeof (data));
2901         strncpy (data + 40, va_arg (ap, const char *), 16);
2902         strncpy (data + 56, va_arg (ap, const char *), 80);
2903         va_end (ap);
2904         return elfcore_write_note (abfd, buf, bufsiz,
2905                                    "CORE", note_type, data, sizeof (data));
2906       }
2907
2908     case NT_PRSTATUS:
2909       {
2910         char data[504];
2911         va_list ap;
2912         long pid;
2913         int cursig;
2914         const void *greg;
2915
2916         va_start (ap, note_type);
2917         memset (data, 0, 112);
2918         pid = va_arg (ap, long);
2919         bfd_put_32 (abfd, pid, data + 32);
2920         cursig = va_arg (ap, int);
2921         bfd_put_16 (abfd, cursig, data + 12);
2922         greg = va_arg (ap, const void *);
2923         memcpy (data + 112, greg, 384);
2924         memset (data + 496, 0, 8);
2925         va_end (ap);
2926         return elfcore_write_note (abfd, buf, bufsiz,
2927                                    "CORE", note_type, data, sizeof (data));
2928       }
2929     }
2930 }
2931
2932 /* Add extra PPC sections.  */
2933
2934 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2935 {
2936   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2937   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2938   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2939   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2940   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2941   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2942   { NULL,                     0,  0, 0,            0 }
2943 };
2944
2945 enum _ppc64_sec_type {
2946   sec_normal = 0,
2947   sec_opd = 1,
2948   sec_toc = 2
2949 };
2950
2951 struct _ppc64_elf_section_data
2952 {
2953   struct bfd_elf_section_data elf;
2954
2955   union
2956   {
2957     /* An array with one entry for each opd function descriptor.  */
2958     struct _opd_sec_data
2959     {
2960       /* Points to the function code section for local opd entries.  */
2961       asection **func_sec;
2962
2963       /* After editing .opd, adjust references to opd local syms.  */
2964       long *adjust;
2965     } opd;
2966
2967     /* An array for toc sections, indexed by offset/8.  */
2968     struct _toc_sec_data
2969     {
2970       /* Specifies the relocation symbol index used at a given toc offset.  */
2971       unsigned *symndx;
2972
2973       /* And the relocation addend.  */
2974       bfd_vma *add;
2975     } toc;
2976   } u;
2977
2978   enum _ppc64_sec_type sec_type:2;
2979
2980   /* Flag set when small branches are detected.  Used to
2981      select suitable defaults for the stub group size.  */
2982   unsigned int has_14bit_branch:1;
2983 };
2984
2985 #define ppc64_elf_section_data(sec) \
2986   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2987
2988 static bfd_boolean
2989 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2990 {
2991   if (!sec->used_by_bfd)
2992     {
2993       struct _ppc64_elf_section_data *sdata;
2994       bfd_size_type amt = sizeof (*sdata);
2995
2996       sdata = bfd_zalloc (abfd, amt);
2997       if (sdata == NULL)
2998         return FALSE;
2999       sec->used_by_bfd = sdata;
3000     }
3001
3002   return _bfd_elf_new_section_hook (abfd, sec);
3003 }
3004
3005 static struct _opd_sec_data *
3006 get_opd_info (asection * sec)
3007 {
3008   if (sec != NULL
3009       && ppc64_elf_section_data (sec) != NULL
3010       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3011     return &ppc64_elf_section_data (sec)->u.opd;
3012   return NULL;
3013 }
3014 \f
3015 /* Parameters for the qsort hook.  */
3016 static bfd_boolean synthetic_relocatable;
3017
3018 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3019
3020 static int
3021 compare_symbols (const void *ap, const void *bp)
3022 {
3023   const asymbol *a = * (const asymbol **) ap;
3024   const asymbol *b = * (const asymbol **) bp;
3025
3026   /* Section symbols first.  */
3027   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3028     return -1;
3029   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3030     return 1;
3031
3032   /* then .opd symbols.  */
3033   if (strcmp (a->section->name, ".opd") == 0
3034       && strcmp (b->section->name, ".opd") != 0)
3035     return -1;
3036   if (strcmp (a->section->name, ".opd") != 0
3037       && strcmp (b->section->name, ".opd") == 0)
3038     return 1;
3039
3040   /* then other code symbols.  */
3041   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3042       == (SEC_CODE | SEC_ALLOC)
3043       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3044          != (SEC_CODE | SEC_ALLOC))
3045     return -1;
3046
3047   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3048       != (SEC_CODE | SEC_ALLOC)
3049       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3050          == (SEC_CODE | SEC_ALLOC))
3051     return 1;
3052
3053   if (synthetic_relocatable)
3054     {
3055       if (a->section->id < b->section->id)
3056         return -1;
3057
3058       if (a->section->id > b->section->id)
3059         return 1;
3060     }
3061
3062   if (a->value + a->section->vma < b->value + b->section->vma)
3063     return -1;
3064
3065   if (a->value + a->section->vma > b->value + b->section->vma)
3066     return 1;
3067
3068   /* For syms with the same value, prefer strong dynamic global function
3069      syms over other syms.  */
3070   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3071     return -1;
3072
3073   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3074     return 1;
3075
3076   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3077     return -1;
3078
3079   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3080     return 1;
3081
3082   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3083     return -1;
3084
3085   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3086     return 1;
3087
3088   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3089     return -1;
3090
3091   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3092     return 1;
3093
3094   return 0;
3095 }
3096
3097 /* Search SYMS for a symbol of the given VALUE.  */
3098
3099 static asymbol *
3100 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3101 {
3102   long mid;
3103
3104   if (id == -1)
3105     {
3106       while (lo < hi)
3107         {
3108           mid = (lo + hi) >> 1;
3109           if (syms[mid]->value + syms[mid]->section->vma < value)
3110             lo = mid + 1;
3111           else if (syms[mid]->value + syms[mid]->section->vma > value)
3112             hi = mid;
3113           else
3114             return syms[mid];
3115         }
3116     }
3117   else
3118     {
3119       while (lo < hi)
3120         {
3121           mid = (lo + hi) >> 1;
3122           if (syms[mid]->section->id < id)
3123             lo = mid + 1;
3124           else if (syms[mid]->section->id > id)
3125             hi = mid;
3126           else if (syms[mid]->value < value)
3127             lo = mid + 1;
3128           else if (syms[mid]->value > value)
3129             hi = mid;
3130           else
3131             return syms[mid];
3132         }
3133     }
3134   return NULL;
3135 }
3136
3137 static bfd_boolean
3138 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3139 {
3140   bfd_vma vma = *(bfd_vma *) ptr;
3141   return ((section->flags & SEC_ALLOC) != 0
3142           && section->vma <= vma
3143           && vma < section->vma + section->size);
3144 }
3145
3146 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3147    entry syms.  Also generate @plt symbols for the glink branch table.  */
3148
3149 static long
3150 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3151                                 long static_count, asymbol **static_syms,
3152                                 long dyn_count, asymbol **dyn_syms,
3153                                 asymbol **ret)
3154 {
3155   asymbol *s;
3156   long i;
3157   long count;
3158   char *names;
3159   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3160   asection *opd = NULL;
3161   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3162   asymbol **syms;
3163   int abi = abiversion (abfd);
3164
3165   *ret = NULL;
3166
3167   if (abi < 2)
3168     {
3169       opd = bfd_get_section_by_name (abfd, ".opd");
3170       if (opd == NULL && abi == 1)
3171         return 0;
3172     }
3173
3174   symcount = static_count;
3175   if (!relocatable)
3176     symcount += dyn_count;
3177   if (symcount == 0)
3178     return 0;
3179
3180   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3181   if (syms == NULL)
3182     return -1;
3183
3184   if (!relocatable && static_count != 0 && dyn_count != 0)
3185     {
3186       /* Use both symbol tables.  */
3187       memcpy (syms, static_syms, static_count * sizeof (*syms));
3188       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3189     }
3190   else if (!relocatable && static_count == 0)
3191     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3192   else
3193     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3194
3195   synthetic_relocatable = relocatable;
3196   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3197
3198   if (!relocatable && symcount > 1)
3199     {
3200       long j;
3201       /* Trim duplicate syms, since we may have merged the normal and
3202          dynamic symbols.  Actually, we only care about syms that have
3203          different values, so trim any with the same value.  */
3204       for (i = 1, j = 1; i < symcount; ++i)
3205         if (syms[i - 1]->value + syms[i - 1]->section->vma
3206             != syms[i]->value + syms[i]->section->vma)
3207           syms[j++] = syms[i];
3208       symcount = j;
3209     }
3210
3211   i = 0;
3212   if (strcmp (syms[i]->section->name, ".opd") == 0)
3213     ++i;
3214   codesecsym = i;
3215
3216   for (; i < symcount; ++i)
3217     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3218          != (SEC_CODE | SEC_ALLOC))
3219         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3220       break;
3221   codesecsymend = i;
3222
3223   for (; i < symcount; ++i)
3224     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3225       break;
3226   secsymend = i;
3227
3228   for (; i < symcount; ++i)
3229     if (strcmp (syms[i]->section->name, ".opd") != 0)
3230       break;
3231   opdsymend = i;
3232
3233   for (; i < symcount; ++i)
3234     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3235         != (SEC_CODE | SEC_ALLOC))
3236       break;
3237   symcount = i;
3238
3239   count = 0;
3240
3241   if (relocatable)
3242     {
3243       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3244       arelent *r;
3245       size_t size;
3246       long relcount;
3247
3248       if (opdsymend == secsymend)
3249         goto done;
3250
3251       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3252       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3253       if (relcount == 0)
3254         goto done;
3255
3256       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3257         {
3258           count = -1;
3259           goto done;
3260         }
3261
3262       size = 0;
3263       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3264         {
3265           asymbol *sym;
3266
3267           while (r < opd->relocation + relcount
3268                  && r->address < syms[i]->value + opd->vma)
3269             ++r;
3270
3271           if (r == opd->relocation + relcount)
3272             break;
3273
3274           if (r->address != syms[i]->value + opd->vma)
3275             continue;
3276
3277           if (r->howto->type != R_PPC64_ADDR64)
3278             continue;
3279
3280           sym = *r->sym_ptr_ptr;
3281           if (!sym_exists_at (syms, opdsymend, symcount,
3282                               sym->section->id, sym->value + r->addend))
3283             {
3284               ++count;
3285               size += sizeof (asymbol);
3286               size += strlen (syms[i]->name) + 2;
3287             }
3288         }
3289
3290       s = *ret = bfd_malloc (size);
3291       if (s == NULL)
3292         {
3293           count = -1;
3294           goto done;
3295         }
3296
3297       names = (char *) (s + count);
3298
3299       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3300         {
3301           asymbol *sym;
3302
3303           while (r < opd->relocation + relcount
3304                  && r->address < syms[i]->value + opd->vma)
3305             ++r;
3306
3307           if (r == opd->relocation + relcount)
3308             break;
3309
3310           if (r->address != syms[i]->value + opd->vma)
3311             continue;
3312
3313           if (r->howto->type != R_PPC64_ADDR64)
3314             continue;
3315
3316           sym = *r->sym_ptr_ptr;
3317           if (!sym_exists_at (syms, opdsymend, symcount,
3318                               sym->section->id, sym->value + r->addend))
3319             {
3320               size_t len;
3321
3322               *s = *syms[i];
3323               s->flags |= BSF_SYNTHETIC;
3324               s->section = sym->section;
3325               s->value = sym->value + r->addend;
3326               s->name = names;
3327               *names++ = '.';
3328               len = strlen (syms[i]->name);
3329               memcpy (names, syms[i]->name, len + 1);
3330               names += len + 1;
3331               /* Have udata.p point back to the original symbol this
3332                  synthetic symbol was derived from.  */
3333               s->udata.p = syms[i];
3334               s++;
3335             }
3336         }
3337     }
3338   else
3339     {
3340       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3341       bfd_byte *contents = NULL;
3342       size_t size;
3343       long plt_count = 0;
3344       bfd_vma glink_vma = 0, resolv_vma = 0;
3345       asection *dynamic, *glink = NULL, *relplt = NULL;
3346       arelent *p;
3347
3348       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3349         {
3350         free_contents_and_exit:
3351           if (contents)
3352             free (contents);
3353           count = -1;
3354           goto done;
3355         }
3356
3357       size = 0;
3358       for (i = secsymend; i < opdsymend; ++i)
3359         {
3360           bfd_vma ent;
3361
3362           /* Ignore bogus symbols.  */
3363           if (syms[i]->value > opd->size - 8)
3364             continue;
3365
3366           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3367           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3368             {
3369               ++count;
3370               size += sizeof (asymbol);
3371               size += strlen (syms[i]->name) + 2;
3372             }
3373         }
3374
3375       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3376       if (dyn_count != 0
3377           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3378         {
3379           bfd_byte *dynbuf, *extdyn, *extdynend;
3380           size_t extdynsize;
3381           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3382
3383           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3384             goto free_contents_and_exit;
3385
3386           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3387           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3388
3389           extdyn = dynbuf;
3390           extdynend = extdyn + dynamic->size;
3391           for (; extdyn < extdynend; extdyn += extdynsize)
3392             {
3393               Elf_Internal_Dyn dyn;
3394               (*swap_dyn_in) (abfd, extdyn, &dyn);
3395
3396               if (dyn.d_tag == DT_NULL)
3397                 break;
3398
3399               if (dyn.d_tag == DT_PPC64_GLINK)
3400                 {
3401                   /* The first glink stub starts at offset 32; see
3402                      comment in ppc64_elf_finish_dynamic_sections. */
3403                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3404                   /* The .glink section usually does not survive the final
3405                      link; search for the section (usually .text) where the
3406                      glink stubs now reside.  */
3407                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3408                                                 &glink_vma);
3409                   break;
3410                 }
3411             }
3412
3413           free (dynbuf);
3414         }
3415
3416       if (glink != NULL)
3417         {
3418           /* Determine __glink trampoline by reading the relative branch
3419              from the first glink stub.  */
3420           bfd_byte buf[4];
3421           unsigned int off = 0;
3422
3423           while (bfd_get_section_contents (abfd, glink, buf,
3424                                            glink_vma + off - glink->vma, 4))
3425             {
3426               unsigned int insn = bfd_get_32 (abfd, buf);
3427               insn ^= B_DOT;
3428               if ((insn & ~0x3fffffc) == 0)
3429                 {
3430                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3431                   break;
3432                 }
3433               off += 4;
3434               if (off > 4)
3435                 break;
3436             }
3437
3438           if (resolv_vma)
3439             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3440
3441           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3442           if (relplt != NULL)
3443             {
3444               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3445               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3446                 goto free_contents_and_exit;
3447
3448               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3449               size += plt_count * sizeof (asymbol);
3450
3451               p = relplt->relocation;
3452               for (i = 0; i < plt_count; i++, p++)
3453                 {
3454                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3455                   if (p->addend != 0)
3456                     size += sizeof ("+0x") - 1 + 16;
3457                 }
3458             }
3459         }
3460
3461       s = *ret = bfd_malloc (size);
3462       if (s == NULL)
3463         goto free_contents_and_exit;
3464
3465       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3466
3467       for (i = secsymend; i < opdsymend; ++i)
3468         {
3469           bfd_vma ent;
3470
3471           if (syms[i]->value > opd->size - 8)
3472             continue;
3473
3474           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476             {
3477               long lo, hi;
3478               size_t len;
3479               asection *sec = abfd->sections;
3480
3481               *s = *syms[i];
3482               lo = codesecsym;
3483               hi = codesecsymend;
3484               while (lo < hi)
3485                 {
3486                   long mid = (lo + hi) >> 1;
3487                   if (syms[mid]->section->vma < ent)
3488                     lo = mid + 1;
3489                   else if (syms[mid]->section->vma > ent)
3490                     hi = mid;
3491                   else
3492                     {
3493                       sec = syms[mid]->section;
3494                       break;
3495                     }
3496                 }
3497
3498               if (lo >= hi && lo > codesecsym)
3499                 sec = syms[lo - 1]->section;
3500
3501               for (; sec != NULL; sec = sec->next)
3502                 {
3503                   if (sec->vma > ent)
3504                     break;
3505                   /* SEC_LOAD may not be set if SEC is from a separate debug
3506                      info file.  */
3507                   if ((sec->flags & SEC_ALLOC) == 0)
3508                     break;
3509                   if ((sec->flags & SEC_CODE) != 0)
3510                     s->section = sec;
3511                 }
3512               s->flags |= BSF_SYNTHETIC;
3513               s->value = ent - s->section->vma;
3514               s->name = names;
3515               *names++ = '.';
3516               len = strlen (syms[i]->name);
3517               memcpy (names, syms[i]->name, len + 1);
3518               names += len + 1;
3519               /* Have udata.p point back to the original symbol this
3520                  synthetic symbol was derived from.  */
3521               s->udata.p = syms[i];
3522               s++;
3523             }
3524         }
3525       free (contents);
3526
3527       if (glink != NULL && relplt != NULL)
3528         {
3529           if (resolv_vma)
3530             {
3531               /* Add a symbol for the main glink trampoline.  */
3532               memset (s, 0, sizeof *s);
3533               s->the_bfd = abfd;
3534               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3535               s->section = glink;
3536               s->value = resolv_vma - glink->vma;
3537               s->name = names;
3538               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3539               names += sizeof ("__glink_PLTresolve");
3540               s++;
3541               count++;
3542             }
3543
3544           /* FIXME: It would be very much nicer to put sym@plt on the
3545              stub rather than on the glink branch table entry.  The
3546              objdump disassembler would then use a sensible symbol
3547              name on plt calls.  The difficulty in doing so is
3548              a) finding the stubs, and,
3549              b) matching stubs against plt entries, and,
3550              c) there can be multiple stubs for a given plt entry.
3551
3552              Solving (a) could be done by code scanning, but older
3553              ppc64 binaries used different stubs to current code.
3554              (b) is the tricky one since you need to known the toc
3555              pointer for at least one function that uses a pic stub to
3556              be able to calculate the plt address referenced.
3557              (c) means gdb would need to set multiple breakpoints (or
3558              find the glink branch itself) when setting breakpoints
3559              for pending shared library loads.  */
3560           p = relplt->relocation;
3561           for (i = 0; i < plt_count; i++, p++)
3562             {
3563               size_t len;
3564
3565               *s = **p->sym_ptr_ptr;
3566               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3567                  we are defining a symbol, ensure one of them is set.  */
3568               if ((s->flags & BSF_LOCAL) == 0)
3569                 s->flags |= BSF_GLOBAL;
3570               s->flags |= BSF_SYNTHETIC;
3571               s->section = glink;
3572               s->value = glink_vma - glink->vma;
3573               s->name = names;
3574               s->udata.p = NULL;
3575               len = strlen ((*p->sym_ptr_ptr)->name);
3576               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3577               names += len;
3578               if (p->addend != 0)
3579                 {
3580                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3581                   names += sizeof ("+0x") - 1;
3582                   bfd_sprintf_vma (abfd, names, p->addend);
3583                   names += strlen (names);
3584                 }
3585               memcpy (names, "@plt", sizeof ("@plt"));
3586               names += sizeof ("@plt");
3587               s++;
3588               if (abi < 2)
3589                 {
3590                   glink_vma += 8;
3591                   if (i >= 0x8000)
3592                     glink_vma += 4;
3593                 }
3594               else
3595                 glink_vma += 4;
3596             }
3597           count += plt_count;
3598         }
3599     }
3600
3601  done:
3602   free (syms);
3603   return count;
3604 }
3605 \f
3606 /* The following functions are specific to the ELF linker, while
3607    functions above are used generally.  Those named ppc64_elf_* are
3608    called by the main ELF linker code.  They appear in this file more
3609    or less in the order in which they are called.  eg.
3610    ppc64_elf_check_relocs is called early in the link process,
3611    ppc64_elf_finish_dynamic_sections is one of the last functions
3612    called.
3613
3614    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3615    functions have both a function code symbol and a function descriptor
3616    symbol.  A call to foo in a relocatable object file looks like:
3617
3618    .            .text
3619    .    x:
3620    .            bl      .foo
3621    .            nop
3622
3623    The function definition in another object file might be:
3624
3625    .            .section .opd
3626    .    foo:    .quad   .foo
3627    .            .quad   .TOC.@tocbase
3628    .            .quad   0
3629    .
3630    .            .text
3631    .    .foo:   blr
3632
3633    When the linker resolves the call during a static link, the branch
3634    unsurprisingly just goes to .foo and the .opd information is unused.
3635    If the function definition is in a shared library, things are a little
3636    different:  The call goes via a plt call stub, the opd information gets
3637    copied to the plt, and the linker patches the nop.
3638
3639    .    x:
3640    .            bl      .foo_stub
3641    .            ld      2,40(1)
3642    .
3643    .
3644    .    .foo_stub:
3645    .            std     2,40(1)                 # in practice, the call stub
3646    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3647    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3648    .            ld      12,0(11)
3649    .            ld      2,8(11)
3650    .            mtctr   12
3651    .            ld      11,16(11)
3652    .            bctr
3653    .
3654    .            .section .plt
3655    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3656
3657    The "reloc ()" notation is supposed to indicate that the linker emits
3658    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3659    copying.
3660
3661    What are the difficulties here?  Well, firstly, the relocations
3662    examined by the linker in check_relocs are against the function code
3663    sym .foo, while the dynamic relocation in the plt is emitted against
3664    the function descriptor symbol, foo.  Somewhere along the line, we need
3665    to carefully copy dynamic link information from one symbol to the other.
3666    Secondly, the generic part of the elf linker will make .foo a dynamic
3667    symbol as is normal for most other backends.  We need foo dynamic
3668    instead, at least for an application final link.  However, when
3669    creating a shared library containing foo, we need to have both symbols
3670    dynamic so that references to .foo are satisfied during the early
3671    stages of linking.  Otherwise the linker might decide to pull in a
3672    definition from some other object, eg. a static library.
3673
3674    Update: As of August 2004, we support a new convention.  Function
3675    calls may use the function descriptor symbol, ie. "bl foo".  This
3676    behaves exactly as "bl .foo".  */
3677
3678 /* Of those relocs that might be copied as dynamic relocs, this function
3679    selects those that must be copied when linking a shared library,
3680    even when the symbol is local.  */
3681
3682 static int
3683 must_be_dyn_reloc (struct bfd_link_info *info,
3684                    enum elf_ppc64_reloc_type r_type)
3685 {
3686   switch (r_type)
3687     {
3688     default:
3689       return 1;
3690
3691     case R_PPC64_REL32:
3692     case R_PPC64_REL64:
3693     case R_PPC64_REL30:
3694       return 0;
3695
3696     case R_PPC64_TPREL16:
3697     case R_PPC64_TPREL16_LO:
3698     case R_PPC64_TPREL16_HI:
3699     case R_PPC64_TPREL16_HA:
3700     case R_PPC64_TPREL16_DS:
3701     case R_PPC64_TPREL16_LO_DS:
3702     case R_PPC64_TPREL16_HIGH:
3703     case R_PPC64_TPREL16_HIGHA:
3704     case R_PPC64_TPREL16_HIGHER:
3705     case R_PPC64_TPREL16_HIGHERA:
3706     case R_PPC64_TPREL16_HIGHEST:
3707     case R_PPC64_TPREL16_HIGHESTA:
3708     case R_PPC64_TPREL64:
3709       return !info->executable;
3710     }
3711 }
3712
3713 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3714    copying dynamic variables from a shared lib into an app's dynbss
3715    section, and instead use a dynamic relocation to point into the
3716    shared lib.  With code that gcc generates, it's vital that this be
3717    enabled;  In the PowerPC64 ABI, the address of a function is actually
3718    the address of a function descriptor, which resides in the .opd
3719    section.  gcc uses the descriptor directly rather than going via the
3720    GOT as some other ABI's do, which means that initialized function
3721    pointers must reference the descriptor.  Thus, a function pointer
3722    initialized to the address of a function in a shared library will
3723    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3724    redefines the function descriptor symbol to point to the copy.  This
3725    presents a problem as a plt entry for that function is also
3726    initialized from the function descriptor symbol and the copy reloc
3727    may not be initialized first.  */
3728 #define ELIMINATE_COPY_RELOCS 1
3729
3730 /* Section name for stubs is the associated section name plus this
3731    string.  */
3732 #define STUB_SUFFIX ".stub"
3733
3734 /* Linker stubs.
3735    ppc_stub_long_branch:
3736    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3737    destination, but a 24 bit branch in a stub section will reach.
3738    .    b       dest
3739
3740    ppc_stub_plt_branch:
3741    Similar to the above, but a 24 bit branch in the stub section won't
3742    reach its destination.
3743    .    addis   %r11,%r2,xxx@toc@ha
3744    .    ld      %r12,xxx@toc@l(%r11)
3745    .    mtctr   %r12
3746    .    bctr
3747
3748    ppc_stub_plt_call:
3749    Used to call a function in a shared library.  If it so happens that
3750    the plt entry referenced crosses a 64k boundary, then an extra
3751    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3752    .    std     %r2,40(%r1)
3753    .    addis   %r11,%r2,xxx@toc@ha
3754    .    ld      %r12,xxx+0@toc@l(%r11)
3755    .    mtctr   %r12
3756    .    ld      %r2,xxx+8@toc@l(%r11)
3757    .    ld      %r11,xxx+16@toc@l(%r11)
3758    .    bctr
3759
3760    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3761    code to adjust the value and save r2 to support multiple toc sections.
3762    A ppc_stub_long_branch with an r2 offset looks like:
3763    .    std     %r2,40(%r1)
3764    .    addis   %r2,%r2,off@ha
3765    .    addi    %r2,%r2,off@l
3766    .    b       dest
3767
3768    A ppc_stub_plt_branch with an r2 offset looks like:
3769    .    std     %r2,40(%r1)
3770    .    addis   %r11,%r2,xxx@toc@ha
3771    .    ld      %r12,xxx@toc@l(%r11)
3772    .    addis   %r2,%r2,off@ha
3773    .    addi    %r2,%r2,off@l
3774    .    mtctr   %r12
3775    .    bctr
3776
3777    In cases where the "addis" instruction would add zero, the "addis" is
3778    omitted and following instructions modified slightly in some cases.
3779 */
3780
3781 enum ppc_stub_type {
3782   ppc_stub_none,
3783   ppc_stub_long_branch,
3784   ppc_stub_long_branch_r2off,
3785   ppc_stub_plt_branch,
3786   ppc_stub_plt_branch_r2off,
3787   ppc_stub_plt_call,
3788   ppc_stub_plt_call_r2save,
3789   ppc_stub_global_entry
3790 };
3791
3792 struct ppc_stub_hash_entry {
3793
3794   /* Base hash table entry structure.  */
3795   struct bfd_hash_entry root;
3796
3797   enum ppc_stub_type stub_type;
3798
3799   /* The stub section.  */
3800   asection *stub_sec;
3801
3802   /* Offset within stub_sec of the beginning of this stub.  */
3803   bfd_vma stub_offset;
3804
3805   /* Given the symbol's value and its section we can determine its final
3806      value when building the stubs (so the stub knows where to jump.  */
3807   bfd_vma target_value;
3808   asection *target_section;
3809
3810   /* The symbol table entry, if any, that this was derived from.  */
3811   struct ppc_link_hash_entry *h;
3812   struct plt_entry *plt_ent;
3813
3814   /* Where this stub is being called from, or, in the case of combined
3815      stub sections, the first input section in the group.  */
3816   asection *id_sec;
3817
3818   /* Symbol st_other.  */
3819   unsigned char other;
3820 };
3821
3822 struct ppc_branch_hash_entry {
3823
3824   /* Base hash table entry structure.  */
3825   struct bfd_hash_entry root;
3826
3827   /* Offset within branch lookup table.  */
3828   unsigned int offset;
3829
3830   /* Generation marker.  */
3831   unsigned int iter;
3832 };
3833
3834 /* Used to track dynamic relocations for local symbols.  */
3835 struct ppc_dyn_relocs
3836 {
3837   struct ppc_dyn_relocs *next;
3838
3839   /* The input section of the reloc.  */
3840   asection *sec;
3841
3842   /* Total number of relocs copied for the input section.  */
3843   unsigned int count : 31;
3844
3845   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3846   unsigned int ifunc : 1;
3847 };
3848
3849 struct ppc_link_hash_entry
3850 {
3851   struct elf_link_hash_entry elf;
3852
3853   union {
3854     /* A pointer to the most recently used stub hash entry against this
3855        symbol.  */
3856     struct ppc_stub_hash_entry *stub_cache;
3857
3858     /* A pointer to the next symbol starting with a '.'  */
3859     struct ppc_link_hash_entry *next_dot_sym;
3860   } u;
3861
3862   /* Track dynamic relocs copied for this symbol.  */
3863   struct elf_dyn_relocs *dyn_relocs;
3864
3865   /* Link between function code and descriptor symbols.  */
3866   struct ppc_link_hash_entry *oh;
3867
3868   /* Flag function code and descriptor symbols.  */
3869   unsigned int is_func:1;
3870   unsigned int is_func_descriptor:1;
3871   unsigned int fake:1;
3872
3873   /* Whether global opd/toc sym has been adjusted or not.
3874      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3875      should be set for all globals defined in any opd/toc section.  */
3876   unsigned int adjust_done:1;
3877
3878   /* Set if we twiddled this symbol to weak at some stage.  */
3879   unsigned int was_undefined:1;
3880
3881   /* Contexts in which symbol is used in the GOT (or TOC).
3882      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3883      corresponding relocs are encountered during check_relocs.
3884      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3885      indicate the corresponding GOT entry type is not needed.
3886      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3887      a TPREL one.  We use a separate flag rather than setting TPREL
3888      just for convenience in distinguishing the two cases.  */
3889 #define TLS_GD           1      /* GD reloc. */
3890 #define TLS_LD           2      /* LD reloc. */
3891 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3892 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3893 #define TLS_TLS         16      /* Any TLS reloc.  */
3894 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3895 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3896 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3897   unsigned char tls_mask;
3898 };
3899
3900 /* ppc64 ELF linker hash table.  */
3901
3902 struct ppc_link_hash_table
3903 {
3904   struct elf_link_hash_table elf;
3905
3906   /* The stub hash table.  */
3907   struct bfd_hash_table stub_hash_table;
3908
3909   /* Another hash table for plt_branch stubs.  */
3910   struct bfd_hash_table branch_hash_table;
3911
3912   /* Hash table for function prologue tocsave.  */
3913   htab_t tocsave_htab;
3914
3915   /* Various options and other info passed from the linker.  */
3916   struct ppc64_elf_params *params;
3917
3918   /* Array to keep track of which stub sections have been created, and
3919      information on stub grouping.  */
3920   struct map_stub {
3921     /* This is the section to which stubs in the group will be attached.  */
3922     asection *link_sec;
3923     /* The stub section.  */
3924     asection *stub_sec;
3925     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3926     bfd_vma toc_off;
3927   } *stub_group;
3928
3929   /* Temp used when calculating TOC pointers.  */
3930   bfd_vma toc_curr;
3931   bfd *toc_bfd;
3932   asection *toc_first_sec;
3933
3934   /* Highest input section id.  */
3935   int top_id;
3936
3937   /* Highest output section index.  */
3938   int top_index;
3939
3940   /* Used when adding symbols.  */
3941   struct ppc_link_hash_entry *dot_syms;
3942
3943   /* List of input sections for each output section.  */
3944   asection **input_list;
3945
3946   /* Shortcuts to get to dynamic linker sections.  */
3947   asection *dynbss;
3948   asection *relbss;
3949   asection *glink;
3950   asection *sfpr;
3951   asection *brlt;
3952   asection *relbrlt;
3953   asection *glink_eh_frame;
3954
3955   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3956   struct ppc_link_hash_entry *tls_get_addr;
3957   struct ppc_link_hash_entry *tls_get_addr_fd;
3958
3959   /* The size of reliplt used by got entry relocs.  */
3960   bfd_size_type got_reli_size;
3961
3962   /* Statistics.  */
3963   unsigned long stub_count[ppc_stub_global_entry];
3964
3965   /* Number of stubs against global syms.  */
3966   unsigned long stub_globals;
3967
3968   /* Set if we're linking code with function descriptors.  */
3969   unsigned int opd_abi:1;
3970
3971   /* Support for multiple toc sections.  */
3972   unsigned int do_multi_toc:1;
3973   unsigned int multi_toc_needed:1;
3974   unsigned int second_toc_pass:1;
3975   unsigned int do_toc_opt:1;
3976
3977   /* Set on error.  */
3978   unsigned int stub_error:1;
3979
3980   /* Temp used by ppc64_elf_before_check_relocs.  */
3981   unsigned int twiddled_syms:1;
3982
3983   /* Incremented every time we size stubs.  */
3984   unsigned int stub_iteration;
3985
3986   /* Small local sym cache.  */
3987   struct sym_cache sym_cache;
3988 };
3989
3990 /* Rename some of the generic section flags to better document how they
3991    are used here.  */
3992
3993 /* Nonzero if this section has TLS related relocations.  */
3994 #define has_tls_reloc sec_flg0
3995
3996 /* Nonzero if this section has a call to __tls_get_addr.  */
3997 #define has_tls_get_addr_call sec_flg1
3998
3999 /* Nonzero if this section has any toc or got relocs.  */
4000 #define has_toc_reloc sec_flg2
4001
4002 /* Nonzero if this section has a call to another section that uses
4003    the toc or got.  */
4004 #define makes_toc_func_call sec_flg3
4005
4006 /* Recursion protection when determining above flag.  */
4007 #define call_check_in_progress sec_flg4
4008 #define call_check_done sec_flg5
4009
4010 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4011
4012 #define ppc_hash_table(p) \
4013   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4014   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4015
4016 #define ppc_stub_hash_lookup(table, string, create, copy) \
4017   ((struct ppc_stub_hash_entry *) \
4018    bfd_hash_lookup ((table), (string), (create), (copy)))
4019
4020 #define ppc_branch_hash_lookup(table, string, create, copy) \
4021   ((struct ppc_branch_hash_entry *) \
4022    bfd_hash_lookup ((table), (string), (create), (copy)))
4023
4024 /* Create an entry in the stub hash table.  */
4025
4026 static struct bfd_hash_entry *
4027 stub_hash_newfunc (struct bfd_hash_entry *entry,
4028                    struct bfd_hash_table *table,
4029                    const char *string)
4030 {
4031   /* Allocate the structure if it has not already been allocated by a
4032      subclass.  */
4033   if (entry == NULL)
4034     {
4035       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4036       if (entry == NULL)
4037         return entry;
4038     }
4039
4040   /* Call the allocation method of the superclass.  */
4041   entry = bfd_hash_newfunc (entry, table, string);
4042   if (entry != NULL)
4043     {
4044       struct ppc_stub_hash_entry *eh;
4045
4046       /* Initialize the local fields.  */
4047       eh = (struct ppc_stub_hash_entry *) entry;
4048       eh->stub_type = ppc_stub_none;
4049       eh->stub_sec = NULL;
4050       eh->stub_offset = 0;
4051       eh->target_value = 0;
4052       eh->target_section = NULL;
4053       eh->h = NULL;
4054       eh->plt_ent = NULL;
4055       eh->id_sec = NULL;
4056       eh->other = 0;
4057     }
4058
4059   return entry;
4060 }
4061
4062 /* Create an entry in the branch hash table.  */
4063
4064 static struct bfd_hash_entry *
4065 branch_hash_newfunc (struct bfd_hash_entry *entry,
4066                      struct bfd_hash_table *table,
4067                      const char *string)
4068 {
4069   /* Allocate the structure if it has not already been allocated by a
4070      subclass.  */
4071   if (entry == NULL)
4072     {
4073       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4074       if (entry == NULL)
4075         return entry;
4076     }
4077
4078   /* Call the allocation method of the superclass.  */
4079   entry = bfd_hash_newfunc (entry, table, string);
4080   if (entry != NULL)
4081     {
4082       struct ppc_branch_hash_entry *eh;
4083
4084       /* Initialize the local fields.  */
4085       eh = (struct ppc_branch_hash_entry *) entry;
4086       eh->offset = 0;
4087       eh->iter = 0;
4088     }
4089
4090   return entry;
4091 }
4092
4093 /* Create an entry in a ppc64 ELF linker hash table.  */
4094
4095 static struct bfd_hash_entry *
4096 link_hash_newfunc (struct bfd_hash_entry *entry,
4097                    struct bfd_hash_table *table,
4098                    const char *string)
4099 {
4100   /* Allocate the structure if it has not already been allocated by a
4101      subclass.  */
4102   if (entry == NULL)
4103     {
4104       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4105       if (entry == NULL)
4106         return entry;
4107     }
4108
4109   /* Call the allocation method of the superclass.  */
4110   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4111   if (entry != NULL)
4112     {
4113       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4114
4115       memset (&eh->u.stub_cache, 0,
4116               (sizeof (struct ppc_link_hash_entry)
4117                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4118
4119       /* When making function calls, old ABI code references function entry
4120          points (dot symbols), while new ABI code references the function
4121          descriptor symbol.  We need to make any combination of reference and
4122          definition work together, without breaking archive linking.
4123
4124          For a defined function "foo" and an undefined call to "bar":
4125          An old object defines "foo" and ".foo", references ".bar" (possibly
4126          "bar" too).
4127          A new object defines "foo" and references "bar".
4128
4129          A new object thus has no problem with its undefined symbols being
4130          satisfied by definitions in an old object.  On the other hand, the
4131          old object won't have ".bar" satisfied by a new object.
4132
4133          Keep a list of newly added dot-symbols.  */
4134
4135       if (string[0] == '.')
4136         {
4137           struct ppc_link_hash_table *htab;
4138
4139           htab = (struct ppc_link_hash_table *) table;
4140           eh->u.next_dot_sym = htab->dot_syms;
4141           htab->dot_syms = eh;
4142         }
4143     }
4144
4145   return entry;
4146 }
4147
4148 struct tocsave_entry {
4149   asection *sec;
4150   bfd_vma offset;
4151 };
4152
4153 static hashval_t
4154 tocsave_htab_hash (const void *p)
4155 {
4156   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4157   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4158 }
4159
4160 static int
4161 tocsave_htab_eq (const void *p1, const void *p2)
4162 {
4163   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4164   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4165   return e1->sec == e2->sec && e1->offset == e2->offset;
4166 }
4167
4168 /* Destroy a ppc64 ELF linker hash table.  */
4169
4170 static void
4171 ppc64_elf_link_hash_table_free (bfd *obfd)
4172 {
4173   struct ppc_link_hash_table *htab;
4174
4175   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4176   if (htab->tocsave_htab)
4177     htab_delete (htab->tocsave_htab);
4178   bfd_hash_table_free (&htab->branch_hash_table);
4179   bfd_hash_table_free (&htab->stub_hash_table);
4180   _bfd_elf_link_hash_table_free (obfd);
4181 }
4182
4183 /* Create a ppc64 ELF linker hash table.  */
4184
4185 static struct bfd_link_hash_table *
4186 ppc64_elf_link_hash_table_create (bfd *abfd)
4187 {
4188   struct ppc_link_hash_table *htab;
4189   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4190
4191   htab = bfd_zmalloc (amt);
4192   if (htab == NULL)
4193     return NULL;
4194
4195   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4196                                       sizeof (struct ppc_link_hash_entry),
4197                                       PPC64_ELF_DATA))
4198     {
4199       free (htab);
4200       return NULL;
4201     }
4202
4203   /* Init the stub hash table too.  */
4204   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4205                             sizeof (struct ppc_stub_hash_entry)))
4206     {
4207       _bfd_elf_link_hash_table_free (abfd);
4208       return NULL;
4209     }
4210
4211   /* And the branch hash table.  */
4212   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4213                             sizeof (struct ppc_branch_hash_entry)))
4214     {
4215       bfd_hash_table_free (&htab->stub_hash_table);
4216       _bfd_elf_link_hash_table_free (abfd);
4217       return NULL;
4218     }
4219
4220   htab->tocsave_htab = htab_try_create (1024,
4221                                         tocsave_htab_hash,
4222                                         tocsave_htab_eq,
4223                                         NULL);
4224   if (htab->tocsave_htab == NULL)
4225     {
4226       ppc64_elf_link_hash_table_free (abfd);
4227       return NULL;
4228     }
4229   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4230
4231   /* Initializing two fields of the union is just cosmetic.  We really
4232      only care about glist, but when compiled on a 32-bit host the
4233      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4234      debugger inspection of these fields look nicer.  */
4235   htab->elf.init_got_refcount.refcount = 0;
4236   htab->elf.init_got_refcount.glist = NULL;
4237   htab->elf.init_plt_refcount.refcount = 0;
4238   htab->elf.init_plt_refcount.glist = NULL;
4239   htab->elf.init_got_offset.offset = 0;
4240   htab->elf.init_got_offset.glist = NULL;
4241   htab->elf.init_plt_offset.offset = 0;
4242   htab->elf.init_plt_offset.glist = NULL;
4243
4244   return &htab->elf.root;
4245 }
4246
4247 /* Create sections for linker generated code.  */
4248
4249 static bfd_boolean
4250 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4251 {
4252   struct ppc_link_hash_table *htab;
4253   flagword flags;
4254
4255   htab = ppc_hash_table (info);
4256
4257   /* Create .sfpr for code to save and restore fp regs.  */
4258   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4259            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4260   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4261                                                    flags);
4262   if (htab->sfpr == NULL
4263       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4264     return FALSE;
4265
4266   /* Create .glink for lazy dynamic linking support.  */
4267   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4268                                                     flags);
4269   if (htab->glink == NULL
4270       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4271     return FALSE;
4272
4273   if (!info->no_ld_generated_unwind_info)
4274     {
4275       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4276                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4277       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4278                                                                  ".eh_frame",
4279                                                                  flags);
4280       if (htab->glink_eh_frame == NULL
4281           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4282         return FALSE;
4283     }
4284
4285   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4286   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4287   if (htab->elf.iplt == NULL
4288       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4289     return FALSE;
4290
4291   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4292            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4293   htab->elf.irelplt
4294     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4295   if (htab->elf.irelplt == NULL
4296       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4297     return FALSE;
4298
4299   /* Create branch lookup table for plt_branch stubs.  */
4300   flags = (SEC_ALLOC | SEC_LOAD
4301            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4302   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4303                                                    flags);
4304   if (htab->brlt == NULL
4305       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4306     return FALSE;
4307
4308   if (!info->shared)
4309     return TRUE;
4310
4311   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4312            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4313   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4314                                                       ".rela.branch_lt",
4315                                                       flags);
4316   if (htab->relbrlt == NULL
4317       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4318     return FALSE;
4319
4320   return TRUE;
4321 }
4322
4323 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4324
4325 bfd_boolean
4326 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4327                          struct ppc64_elf_params *params)
4328 {
4329   struct ppc_link_hash_table *htab;
4330
4331   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4332
4333 /* Always hook our dynamic sections into the first bfd, which is the
4334    linker created stub bfd.  This ensures that the GOT header is at
4335    the start of the output TOC section.  */
4336   htab = ppc_hash_table (info);
4337   if (htab == NULL)
4338     return FALSE;
4339   htab->elf.dynobj = params->stub_bfd;
4340   htab->params = params;
4341
4342   if (info->relocatable)
4343     return TRUE;
4344
4345   return create_linkage_sections (htab->elf.dynobj, info);
4346 }
4347
4348 /* Build a name for an entry in the stub hash table.  */
4349
4350 static char *
4351 ppc_stub_name (const asection *input_section,
4352                const asection *sym_sec,
4353                const struct ppc_link_hash_entry *h,
4354                const Elf_Internal_Rela *rel)
4355 {
4356   char *stub_name;
4357   ssize_t len;
4358
4359   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4360      offsets from a sym as a branch target?  In fact, we could
4361      probably assume the addend is always zero.  */
4362   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4363
4364   if (h)
4365     {
4366       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4367       stub_name = bfd_malloc (len);
4368       if (stub_name == NULL)
4369         return stub_name;
4370
4371       len = sprintf (stub_name, "%08x.%s+%x",
4372                      input_section->id & 0xffffffff,
4373                      h->elf.root.root.string,
4374                      (int) rel->r_addend & 0xffffffff);
4375     }
4376   else
4377     {
4378       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4379       stub_name = bfd_malloc (len);
4380       if (stub_name == NULL)
4381         return stub_name;
4382
4383       len = sprintf (stub_name, "%08x.%x:%x+%x",
4384                      input_section->id & 0xffffffff,
4385                      sym_sec->id & 0xffffffff,
4386                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4387                      (int) rel->r_addend & 0xffffffff);
4388     }
4389   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4390     stub_name[len - 2] = 0;
4391   return stub_name;
4392 }
4393
4394 /* Look up an entry in the stub hash.  Stub entries are cached because
4395    creating the stub name takes a bit of time.  */
4396
4397 static struct ppc_stub_hash_entry *
4398 ppc_get_stub_entry (const asection *input_section,
4399                     const asection *sym_sec,
4400                     struct ppc_link_hash_entry *h,
4401                     const Elf_Internal_Rela *rel,
4402                     struct ppc_link_hash_table *htab)
4403 {
4404   struct ppc_stub_hash_entry *stub_entry;
4405   const asection *id_sec;
4406
4407   /* If this input section is part of a group of sections sharing one
4408      stub section, then use the id of the first section in the group.
4409      Stub names need to include a section id, as there may well be
4410      more than one stub used to reach say, printf, and we need to
4411      distinguish between them.  */
4412   id_sec = htab->stub_group[input_section->id].link_sec;
4413
4414   if (h != NULL && h->u.stub_cache != NULL
4415       && h->u.stub_cache->h == h
4416       && h->u.stub_cache->id_sec == id_sec)
4417     {
4418       stub_entry = h->u.stub_cache;
4419     }
4420   else
4421     {
4422       char *stub_name;
4423
4424       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4425       if (stub_name == NULL)
4426         return NULL;
4427
4428       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4429                                          stub_name, FALSE, FALSE);
4430       if (h != NULL)
4431         h->u.stub_cache = stub_entry;
4432
4433       free (stub_name);
4434     }
4435
4436   return stub_entry;
4437 }
4438
4439 /* Add a new stub entry to the stub hash.  Not all fields of the new
4440    stub entry are initialised.  */
4441
4442 static struct ppc_stub_hash_entry *
4443 ppc_add_stub (const char *stub_name,
4444               asection *section,
4445               struct bfd_link_info *info)
4446 {
4447   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4448   asection *link_sec;
4449   asection *stub_sec;
4450   struct ppc_stub_hash_entry *stub_entry;
4451
4452   link_sec = htab->stub_group[section->id].link_sec;
4453   stub_sec = htab->stub_group[section->id].stub_sec;
4454   if (stub_sec == NULL)
4455     {
4456       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4457       if (stub_sec == NULL)
4458         {
4459           size_t namelen;
4460           bfd_size_type len;
4461           char *s_name;
4462
4463           namelen = strlen (link_sec->name);
4464           len = namelen + sizeof (STUB_SUFFIX);
4465           s_name = bfd_alloc (htab->params->stub_bfd, len);
4466           if (s_name == NULL)
4467             return NULL;
4468
4469           memcpy (s_name, link_sec->name, namelen);
4470           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4471           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4472           if (stub_sec == NULL)
4473             return NULL;
4474           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4475         }
4476       htab->stub_group[section->id].stub_sec = stub_sec;
4477     }
4478
4479   /* Enter this entry into the linker stub hash table.  */
4480   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4481                                      TRUE, FALSE);
4482   if (stub_entry == NULL)
4483     {
4484       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4485                               section->owner, stub_name);
4486       return NULL;
4487     }
4488
4489   stub_entry->stub_sec = stub_sec;
4490   stub_entry->stub_offset = 0;
4491   stub_entry->id_sec = link_sec;
4492   return stub_entry;
4493 }
4494
4495 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4496    not already done.  */
4497
4498 static bfd_boolean
4499 create_got_section (bfd *abfd, struct bfd_link_info *info)
4500 {
4501   asection *got, *relgot;
4502   flagword flags;
4503   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4504
4505   if (!is_ppc64_elf (abfd))
4506     return FALSE;
4507   if (htab == NULL)
4508     return FALSE;
4509
4510   if (!htab->elf.sgot
4511       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4512     return FALSE;
4513
4514   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4515            | SEC_LINKER_CREATED);
4516
4517   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4518   if (!got
4519       || !bfd_set_section_alignment (abfd, got, 3))
4520     return FALSE;
4521
4522   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4523                                                flags | SEC_READONLY);
4524   if (!relgot
4525       || ! bfd_set_section_alignment (abfd, relgot, 3))
4526     return FALSE;
4527
4528   ppc64_elf_tdata (abfd)->got = got;
4529   ppc64_elf_tdata (abfd)->relgot = relgot;
4530   return TRUE;
4531 }
4532
4533 /* Create the dynamic sections, and set up shortcuts.  */
4534
4535 static bfd_boolean
4536 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4537 {
4538   struct ppc_link_hash_table *htab;
4539
4540   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4541     return FALSE;
4542
4543   htab = ppc_hash_table (info);
4544   if (htab == NULL)
4545     return FALSE;
4546
4547   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4548   if (!info->shared)
4549     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4550
4551   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4552       || (!info->shared && !htab->relbss))
4553     abort ();
4554
4555   return TRUE;
4556 }
4557
4558 /* Follow indirect and warning symbol links.  */
4559
4560 static inline struct bfd_link_hash_entry *
4561 follow_link (struct bfd_link_hash_entry *h)
4562 {
4563   while (h->type == bfd_link_hash_indirect
4564          || h->type == bfd_link_hash_warning)
4565     h = h->u.i.link;
4566   return h;
4567 }
4568
4569 static inline struct elf_link_hash_entry *
4570 elf_follow_link (struct elf_link_hash_entry *h)
4571 {
4572   return (struct elf_link_hash_entry *) follow_link (&h->root);
4573 }
4574
4575 static inline struct ppc_link_hash_entry *
4576 ppc_follow_link (struct ppc_link_hash_entry *h)
4577 {
4578   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4579 }
4580
4581 /* Merge PLT info on FROM with that on TO.  */
4582
4583 static void
4584 move_plt_plist (struct ppc_link_hash_entry *from,
4585                 struct ppc_link_hash_entry *to)
4586 {
4587   if (from->elf.plt.plist != NULL)
4588     {
4589       if (to->elf.plt.plist != NULL)
4590         {
4591           struct plt_entry **entp;
4592           struct plt_entry *ent;
4593
4594           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4595             {
4596               struct plt_entry *dent;
4597
4598               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4599                 if (dent->addend == ent->addend)
4600                   {
4601                     dent->plt.refcount += ent->plt.refcount;
4602                     *entp = ent->next;
4603                     break;
4604                   }
4605               if (dent == NULL)
4606                 entp = &ent->next;
4607             }
4608           *entp = to->elf.plt.plist;
4609         }
4610
4611       to->elf.plt.plist = from->elf.plt.plist;
4612       from->elf.plt.plist = NULL;
4613     }
4614 }
4615
4616 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4617
4618 static void
4619 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4620                                 struct elf_link_hash_entry *dir,
4621                                 struct elf_link_hash_entry *ind)
4622 {
4623   struct ppc_link_hash_entry *edir, *eind;
4624
4625   edir = (struct ppc_link_hash_entry *) dir;
4626   eind = (struct ppc_link_hash_entry *) ind;
4627
4628   edir->is_func |= eind->is_func;
4629   edir->is_func_descriptor |= eind->is_func_descriptor;
4630   edir->tls_mask |= eind->tls_mask;
4631   if (eind->oh != NULL)
4632     edir->oh = ppc_follow_link (eind->oh);
4633
4634   /* If called to transfer flags for a weakdef during processing
4635      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4636      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4637   if (!(ELIMINATE_COPY_RELOCS
4638         && eind->elf.root.type != bfd_link_hash_indirect
4639         && edir->elf.dynamic_adjusted))
4640     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4641
4642   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4643   edir->elf.ref_regular |= eind->elf.ref_regular;
4644   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4645   edir->elf.needs_plt |= eind->elf.needs_plt;
4646   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4647
4648   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4649   if (eind->dyn_relocs != NULL)
4650     {
4651       if (edir->dyn_relocs != NULL)
4652         {
4653           struct elf_dyn_relocs **pp;
4654           struct elf_dyn_relocs *p;
4655
4656           /* Add reloc counts against the indirect sym to the direct sym
4657              list.  Merge any entries against the same section.  */
4658           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4659             {
4660               struct elf_dyn_relocs *q;
4661
4662               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4663                 if (q->sec == p->sec)
4664                   {
4665                     q->pc_count += p->pc_count;
4666                     q->count += p->count;
4667                     *pp = p->next;
4668                     break;
4669                   }
4670               if (q == NULL)
4671                 pp = &p->next;
4672             }
4673           *pp = edir->dyn_relocs;
4674         }
4675
4676       edir->dyn_relocs = eind->dyn_relocs;
4677       eind->dyn_relocs = NULL;
4678     }
4679
4680   /* If we were called to copy over info for a weak sym, that's all.
4681      You might think dyn_relocs need not be copied over;  After all,
4682      both syms will be dynamic or both non-dynamic so we're just
4683      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4684      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4685      dyn_relocs in read-only sections, and it does so on what is the
4686      DIR sym here.  */
4687   if (eind->elf.root.type != bfd_link_hash_indirect)
4688     return;
4689
4690   /* Copy over got entries that we may have already seen to the
4691      symbol which just became indirect.  */
4692   if (eind->elf.got.glist != NULL)
4693     {
4694       if (edir->elf.got.glist != NULL)
4695         {
4696           struct got_entry **entp;
4697           struct got_entry *ent;
4698
4699           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4700             {
4701               struct got_entry *dent;
4702
4703               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4704                 if (dent->addend == ent->addend
4705                     && dent->owner == ent->owner
4706                     && dent->tls_type == ent->tls_type)
4707                   {
4708                     dent->got.refcount += ent->got.refcount;
4709                     *entp = ent->next;
4710                     break;
4711                   }
4712               if (dent == NULL)
4713                 entp = &ent->next;
4714             }
4715           *entp = edir->elf.got.glist;
4716         }
4717
4718       edir->elf.got.glist = eind->elf.got.glist;
4719       eind->elf.got.glist = NULL;
4720     }
4721
4722   /* And plt entries.  */
4723   move_plt_plist (eind, edir);
4724
4725   if (eind->elf.dynindx != -1)
4726     {
4727       if (edir->elf.dynindx != -1)
4728         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4729                                 edir->elf.dynstr_index);
4730       edir->elf.dynindx = eind->elf.dynindx;
4731       edir->elf.dynstr_index = eind->elf.dynstr_index;
4732       eind->elf.dynindx = -1;
4733       eind->elf.dynstr_index = 0;
4734     }
4735 }
4736
4737 /* Find the function descriptor hash entry from the given function code
4738    hash entry FH.  Link the entries via their OH fields.  */
4739
4740 static struct ppc_link_hash_entry *
4741 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4742 {
4743   struct ppc_link_hash_entry *fdh = fh->oh;
4744
4745   if (fdh == NULL)
4746     {
4747       const char *fd_name = fh->elf.root.root.string + 1;
4748
4749       fdh = (struct ppc_link_hash_entry *)
4750         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4751       if (fdh == NULL)
4752         return fdh;
4753
4754       fdh->is_func_descriptor = 1;
4755       fdh->oh = fh;
4756       fh->is_func = 1;
4757       fh->oh = fdh;
4758     }
4759
4760   return ppc_follow_link (fdh);
4761 }
4762
4763 /* Make a fake function descriptor sym for the code sym FH.  */
4764
4765 static struct ppc_link_hash_entry *
4766 make_fdh (struct bfd_link_info *info,
4767           struct ppc_link_hash_entry *fh)
4768 {
4769   bfd *abfd;
4770   asymbol *newsym;
4771   struct bfd_link_hash_entry *bh;
4772   struct ppc_link_hash_entry *fdh;
4773
4774   abfd = fh->elf.root.u.undef.abfd;
4775   newsym = bfd_make_empty_symbol (abfd);
4776   newsym->name = fh->elf.root.root.string + 1;
4777   newsym->section = bfd_und_section_ptr;
4778   newsym->value = 0;
4779   newsym->flags = BSF_WEAK;
4780
4781   bh = NULL;
4782   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4783                                          newsym->flags, newsym->section,
4784                                          newsym->value, NULL, FALSE, FALSE,
4785                                          &bh))
4786     return NULL;
4787
4788   fdh = (struct ppc_link_hash_entry *) bh;
4789   fdh->elf.non_elf = 0;
4790   fdh->fake = 1;
4791   fdh->is_func_descriptor = 1;
4792   fdh->oh = fh;
4793   fh->is_func = 1;
4794   fh->oh = fdh;
4795   return fdh;
4796 }
4797
4798 /* Fix function descriptor symbols defined in .opd sections to be
4799    function type.  */
4800
4801 static bfd_boolean
4802 ppc64_elf_add_symbol_hook (bfd *ibfd,
4803                            struct bfd_link_info *info,
4804                            Elf_Internal_Sym *isym,
4805                            const char **name,
4806                            flagword *flags ATTRIBUTE_UNUSED,
4807                            asection **sec,
4808                            bfd_vma *value ATTRIBUTE_UNUSED)
4809 {
4810   if ((ibfd->flags & DYNAMIC) == 0
4811       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4812     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4813
4814   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4815     {
4816       if ((ibfd->flags & DYNAMIC) == 0)
4817         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4818     }
4819   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4820     ;
4821   else if (*sec != NULL
4822            && strcmp ((*sec)->name, ".opd") == 0)
4823     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4824
4825   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4826     {
4827       if (abiversion (ibfd) == 0)
4828         set_abiversion (ibfd, 2);
4829       else if (abiversion (ibfd) == 1)
4830         {
4831           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4832                                     " for ABI version 1\n"), name);
4833           bfd_set_error (bfd_error_bad_value);
4834           return FALSE;
4835         }
4836     }
4837
4838   return TRUE;
4839 }
4840
4841 /* Merge non-visibility st_other attributes: local entry point.  */
4842
4843 static void
4844 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4845                                   const Elf_Internal_Sym *isym,
4846                                   bfd_boolean definition,
4847                                   bfd_boolean dynamic)
4848 {
4849   if (definition && !dynamic)
4850     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4851                 | ELF_ST_VISIBILITY (h->other));
4852 }
4853
4854 /* This function makes an old ABI object reference to ".bar" cause the
4855    inclusion of a new ABI object archive that defines "bar".
4856    NAME is a symbol defined in an archive.  Return a symbol in the hash
4857    table that might be satisfied by the archive symbols.  */
4858
4859 static struct elf_link_hash_entry *
4860 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4861                                  struct bfd_link_info *info,
4862                                  const char *name)
4863 {
4864   struct elf_link_hash_entry *h;
4865   char *dot_name;
4866   size_t len;
4867
4868   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4869   if (h != NULL
4870       /* Don't return this sym if it is a fake function descriptor
4871          created by add_symbol_adjust.  */
4872       && !(h->root.type == bfd_link_hash_undefweak
4873            && ((struct ppc_link_hash_entry *) h)->fake))
4874     return h;
4875
4876   if (name[0] == '.')
4877     return h;
4878
4879   len = strlen (name);
4880   dot_name = bfd_alloc (abfd, len + 2);
4881   if (dot_name == NULL)
4882     return (struct elf_link_hash_entry *) 0 - 1;
4883   dot_name[0] = '.';
4884   memcpy (dot_name + 1, name, len + 1);
4885   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4886   bfd_release (abfd, dot_name);
4887   return h;
4888 }
4889
4890 /* This function satisfies all old ABI object references to ".bar" if a
4891    new ABI object defines "bar".  Well, at least, undefined dot symbols
4892    are made weak.  This stops later archive searches from including an
4893    object if we already have a function descriptor definition.  It also
4894    prevents the linker complaining about undefined symbols.
4895    We also check and correct mismatched symbol visibility here.  The
4896    most restrictive visibility of the function descriptor and the
4897    function entry symbol is used.  */
4898
4899 static bfd_boolean
4900 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4901 {
4902   struct ppc_link_hash_table *htab;
4903   struct ppc_link_hash_entry *fdh;
4904
4905   if (eh->elf.root.type == bfd_link_hash_indirect)
4906     return TRUE;
4907
4908   if (eh->elf.root.type == bfd_link_hash_warning)
4909     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4910
4911   if (eh->elf.root.root.string[0] != '.')
4912     abort ();
4913
4914   htab = ppc_hash_table (info);
4915   if (htab == NULL)
4916     return FALSE;
4917
4918   fdh = lookup_fdh (eh, htab);
4919   if (fdh == NULL)
4920     {
4921       if (!info->relocatable
4922           && (eh->elf.root.type == bfd_link_hash_undefined
4923               || eh->elf.root.type == bfd_link_hash_undefweak)
4924           && eh->elf.ref_regular)
4925         {
4926           /* Make an undefweak function descriptor sym, which is enough to
4927              pull in an --as-needed shared lib, but won't cause link
4928              errors.  Archives are handled elsewhere.  */
4929           fdh = make_fdh (info, eh);
4930           if (fdh == NULL)
4931             return FALSE;
4932           fdh->elf.ref_regular = 1;
4933         }
4934     }
4935   else
4936     {
4937       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4938       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4939       if (entry_vis < descr_vis)
4940         fdh->elf.other += entry_vis - descr_vis;
4941       else if (entry_vis > descr_vis)
4942         eh->elf.other += descr_vis - entry_vis;
4943
4944       if ((fdh->elf.root.type == bfd_link_hash_defined
4945            || fdh->elf.root.type == bfd_link_hash_defweak)
4946           && eh->elf.root.type == bfd_link_hash_undefined)
4947         {
4948           eh->elf.root.type = bfd_link_hash_undefweak;
4949           eh->was_undefined = 1;
4950           htab->twiddled_syms = 1;
4951         }
4952     }
4953
4954   return TRUE;
4955 }
4956
4957 /* Set up opd section info and abiversion for IBFD, and process list
4958    of dot-symbols we made in link_hash_newfunc.  */
4959
4960 static bfd_boolean
4961 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4962 {
4963   struct ppc_link_hash_table *htab;
4964   struct ppc_link_hash_entry **p, *eh;
4965
4966   if (!is_ppc64_elf (info->output_bfd))
4967     return TRUE;
4968   htab = ppc_hash_table (info);
4969   if (htab == NULL)
4970     return FALSE;
4971
4972   if (is_ppc64_elf (ibfd))
4973     {
4974       asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4975
4976       if (opd != NULL && opd->size != 0)
4977         {
4978           if (abiversion (ibfd) == 0)
4979             set_abiversion (ibfd, 1);
4980           else if (abiversion (ibfd) == 2)
4981             {
4982               info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4983                                         " version %d\n"),
4984                                       ibfd, abiversion (ibfd));
4985               bfd_set_error (bfd_error_bad_value);
4986               return FALSE;
4987             }
4988
4989           if ((ibfd->flags & DYNAMIC) == 0
4990               && (opd->flags & SEC_RELOC) != 0
4991               && opd->reloc_count != 0
4992               && !bfd_is_abs_section (opd->output_section))
4993             {
4994               /* Garbage collection needs some extra help with .opd sections.
4995                  We don't want to necessarily keep everything referenced by
4996                  relocs in .opd, as that would keep all functions.  Instead,
4997                  if we reference an .opd symbol (a function descriptor), we
4998                  want to keep the function code symbol's section.  This is
4999                  easy for global symbols, but for local syms we need to keep
5000                  information about the associated function section.  */
5001               bfd_size_type amt;
5002               asection **opd_sym_map;
5003
5004               amt = opd->size * sizeof (*opd_sym_map) / 8;
5005               opd_sym_map = bfd_zalloc (ibfd, amt);
5006               if (opd_sym_map == NULL)
5007                 return FALSE;
5008               ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5009               BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5010               ppc64_elf_section_data (opd)->sec_type = sec_opd;
5011             }
5012         }
5013
5014       /* For input files without an explicit abiversion in e_flags
5015          we should have flagged any with symbol st_other bits set
5016          as ELFv1 and above flagged those with .opd as ELFv2.
5017          Set the output abiversion if not yet set, and for any input
5018          still ambiguous, take its abiversion from the output.
5019          Differences in ABI are reported later.  */
5020       if (abiversion (info->output_bfd) == 0)
5021         set_abiversion (info->output_bfd, abiversion (ibfd));
5022       else if (abiversion (ibfd) == 0)
5023         set_abiversion (ibfd, abiversion (info->output_bfd));
5024
5025       p = &htab->dot_syms;
5026       while ((eh = *p) != NULL)
5027         {
5028           *p = NULL;
5029           if (&eh->elf == htab->elf.hgot)
5030             ;
5031           else if (htab->elf.hgot == NULL
5032                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5033             htab->elf.hgot = &eh->elf;
5034           else if (!add_symbol_adjust (eh, info))
5035             return FALSE;
5036           p = &eh->u.next_dot_sym;
5037         }
5038     }
5039
5040   /* Clear the list for non-ppc64 input files.  */
5041   p = &htab->dot_syms;
5042   while ((eh = *p) != NULL)
5043     {
5044       *p = NULL;
5045       p = &eh->u.next_dot_sym;
5046     }
5047
5048   /* We need to fix the undefs list for any syms we have twiddled to
5049      undef_weak.  */
5050   if (htab->twiddled_syms)
5051     {
5052       bfd_link_repair_undef_list (&htab->elf.root);
5053       htab->twiddled_syms = 0;
5054     }
5055   return TRUE;
5056 }
5057
5058 /* Undo hash table changes when an --as-needed input file is determined
5059    not to be needed.  */
5060
5061 static bfd_boolean
5062 ppc64_elf_notice_as_needed (bfd *ibfd,
5063                             struct bfd_link_info *info,
5064                             enum notice_asneeded_action act)
5065 {
5066   if (act == notice_not_needed)
5067     {
5068       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5069
5070       if (htab == NULL)
5071         return FALSE;
5072
5073       htab->dot_syms = NULL;
5074     }
5075   return _bfd_elf_notice_as_needed (ibfd, info, act);
5076 }
5077
5078 /* If --just-symbols against a final linked binary, then assume we need
5079    toc adjusting stubs when calling functions defined there.  */
5080
5081 static void
5082 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5083 {
5084   if ((sec->flags & SEC_CODE) != 0
5085       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5086       && is_ppc64_elf (sec->owner))
5087     {
5088       if (abiversion (sec->owner) >= 2
5089           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5090         sec->has_toc_reloc = 1;
5091     }
5092   _bfd_elf_link_just_syms (sec, info);
5093 }
5094
5095 static struct plt_entry **
5096 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5097                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5098 {
5099   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5100   struct plt_entry **local_plt;
5101   unsigned char *local_got_tls_masks;
5102
5103   if (local_got_ents == NULL)
5104     {
5105       bfd_size_type size = symtab_hdr->sh_info;
5106
5107       size *= (sizeof (*local_got_ents)
5108                + sizeof (*local_plt)
5109                + sizeof (*local_got_tls_masks));
5110       local_got_ents = bfd_zalloc (abfd, size);
5111       if (local_got_ents == NULL)
5112         return NULL;
5113       elf_local_got_ents (abfd) = local_got_ents;
5114     }
5115
5116   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5117     {
5118       struct got_entry *ent;
5119
5120       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5121         if (ent->addend == r_addend
5122             && ent->owner == abfd
5123             && ent->tls_type == tls_type)
5124           break;
5125       if (ent == NULL)
5126         {
5127           bfd_size_type amt = sizeof (*ent);
5128           ent = bfd_alloc (abfd, amt);
5129           if (ent == NULL)
5130             return FALSE;
5131           ent->next = local_got_ents[r_symndx];
5132           ent->addend = r_addend;
5133           ent->owner = abfd;
5134           ent->tls_type = tls_type;
5135           ent->is_indirect = FALSE;
5136           ent->got.refcount = 0;
5137           local_got_ents[r_symndx] = ent;
5138         }
5139       ent->got.refcount += 1;
5140     }
5141
5142   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5143   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5144   local_got_tls_masks[r_symndx] |= tls_type;
5145
5146   return local_plt + r_symndx;
5147 }
5148
5149 static bfd_boolean
5150 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5151 {
5152   struct plt_entry *ent;
5153
5154   for (ent = *plist; ent != NULL; ent = ent->next)
5155     if (ent->addend == addend)
5156       break;
5157   if (ent == NULL)
5158     {
5159       bfd_size_type amt = sizeof (*ent);
5160       ent = bfd_alloc (abfd, amt);
5161       if (ent == NULL)
5162         return FALSE;
5163       ent->next = *plist;
5164       ent->addend = addend;
5165       ent->plt.refcount = 0;
5166       *plist = ent;
5167     }
5168   ent->plt.refcount += 1;
5169   return TRUE;
5170 }
5171
5172 static bfd_boolean
5173 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5174 {
5175   return (r_type == R_PPC64_REL24
5176           || r_type == R_PPC64_REL14
5177           || r_type == R_PPC64_REL14_BRTAKEN
5178           || r_type == R_PPC64_REL14_BRNTAKEN
5179           || r_type == R_PPC64_ADDR24
5180           || r_type == R_PPC64_ADDR14
5181           || r_type == R_PPC64_ADDR14_BRTAKEN
5182           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5183 }
5184
5185 /* Look through the relocs for a section during the first phase, and
5186    calculate needed space in the global offset table, procedure
5187    linkage table, and dynamic reloc sections.  */
5188
5189 static bfd_boolean
5190 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5191                         asection *sec, const Elf_Internal_Rela *relocs)
5192 {
5193   struct ppc_link_hash_table *htab;
5194   Elf_Internal_Shdr *symtab_hdr;
5195   struct elf_link_hash_entry **sym_hashes;
5196   const Elf_Internal_Rela *rel;
5197   const Elf_Internal_Rela *rel_end;
5198   asection *sreloc;
5199   asection **opd_sym_map;
5200   struct elf_link_hash_entry *tga, *dottga;
5201
5202   if (info->relocatable)
5203     return TRUE;
5204
5205   /* Don't do anything special with non-loaded, non-alloced sections.
5206      In particular, any relocs in such sections should not affect GOT
5207      and PLT reference counting (ie. we don't allow them to create GOT
5208      or PLT entries), there's no possibility or desire to optimize TLS
5209      relocs, and there's not much point in propagating relocs to shared
5210      libs that the dynamic linker won't relocate.  */
5211   if ((sec->flags & SEC_ALLOC) == 0)
5212     return TRUE;
5213
5214   BFD_ASSERT (is_ppc64_elf (abfd));
5215
5216   htab = ppc_hash_table (info);
5217   if (htab == NULL)
5218     return FALSE;
5219
5220   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5221                               FALSE, FALSE, TRUE);
5222   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5223                                  FALSE, FALSE, TRUE);
5224   symtab_hdr = &elf_symtab_hdr (abfd);
5225   sym_hashes = elf_sym_hashes (abfd);
5226   sreloc = NULL;
5227   opd_sym_map = NULL;
5228   if (ppc64_elf_section_data (sec) != NULL
5229       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5230     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5231
5232   rel_end = relocs + sec->reloc_count;
5233   for (rel = relocs; rel < rel_end; rel++)
5234     {
5235       unsigned long r_symndx;
5236       struct elf_link_hash_entry *h;
5237       enum elf_ppc64_reloc_type r_type;
5238       int tls_type;
5239       struct _ppc64_elf_section_data *ppc64_sec;
5240       struct plt_entry **ifunc;
5241
5242       r_symndx = ELF64_R_SYM (rel->r_info);
5243       if (r_symndx < symtab_hdr->sh_info)
5244         h = NULL;
5245       else
5246         {
5247           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5248           h = elf_follow_link (h);
5249
5250           /* PR15323, ref flags aren't set for references in the same
5251              object.  */
5252           h->root.non_ir_ref = 1;
5253
5254           if (h == htab->elf.hgot)
5255             sec->has_toc_reloc = 1;
5256         }
5257
5258       tls_type = 0;
5259       ifunc = NULL;
5260       if (h != NULL)
5261         {
5262           if (h->type == STT_GNU_IFUNC)
5263             {
5264               h->needs_plt = 1;
5265               ifunc = &h->plt.plist;
5266             }
5267         }
5268       else
5269         {
5270           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5271                                                           abfd, r_symndx);
5272           if (isym == NULL)
5273             return FALSE;
5274
5275           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5276             {
5277               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5278                                              rel->r_addend, PLT_IFUNC);
5279               if (ifunc == NULL)
5280                 return FALSE;
5281             }
5282         }
5283       r_type = ELF64_R_TYPE (rel->r_info);
5284       if (is_branch_reloc (r_type))
5285         {
5286           if (h != NULL && (h == tga || h == dottga))
5287             {
5288               if (rel != relocs
5289                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5290                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5291                 /* We have a new-style __tls_get_addr call with a marker
5292                    reloc.  */
5293                 ;
5294               else
5295                 /* Mark this section as having an old-style call.  */
5296                 sec->has_tls_get_addr_call = 1;
5297             }
5298
5299           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5300           if (ifunc != NULL
5301               && !update_plt_info (abfd, ifunc, rel->r_addend))
5302             return FALSE;
5303         }
5304
5305       switch (r_type)
5306         {
5307         case R_PPC64_TLSGD:
5308         case R_PPC64_TLSLD:
5309           /* These special tls relocs tie a call to __tls_get_addr with
5310              its parameter symbol.  */
5311           break;
5312
5313         case R_PPC64_GOT_TLSLD16:
5314         case R_PPC64_GOT_TLSLD16_LO:
5315         case R_PPC64_GOT_TLSLD16_HI:
5316         case R_PPC64_GOT_TLSLD16_HA:
5317           tls_type = TLS_TLS | TLS_LD;
5318           goto dogottls;
5319
5320         case R_PPC64_GOT_TLSGD16:
5321         case R_PPC64_GOT_TLSGD16_LO:
5322         case R_PPC64_GOT_TLSGD16_HI:
5323         case R_PPC64_GOT_TLSGD16_HA:
5324           tls_type = TLS_TLS | TLS_GD;
5325           goto dogottls;
5326
5327         case R_PPC64_GOT_TPREL16_DS:
5328         case R_PPC64_GOT_TPREL16_LO_DS:
5329         case R_PPC64_GOT_TPREL16_HI:
5330         case R_PPC64_GOT_TPREL16_HA:
5331           if (info->shared)
5332             info->flags |= DF_STATIC_TLS;
5333           tls_type = TLS_TLS | TLS_TPREL;
5334           goto dogottls;
5335
5336         case R_PPC64_GOT_DTPREL16_DS:
5337         case R_PPC64_GOT_DTPREL16_LO_DS:
5338         case R_PPC64_GOT_DTPREL16_HI:
5339         case R_PPC64_GOT_DTPREL16_HA:
5340           tls_type = TLS_TLS | TLS_DTPREL;
5341         dogottls:
5342           sec->has_tls_reloc = 1;
5343           /* Fall thru */
5344
5345         case R_PPC64_GOT16:
5346         case R_PPC64_GOT16_DS:
5347         case R_PPC64_GOT16_HA:
5348         case R_PPC64_GOT16_HI:
5349         case R_PPC64_GOT16_LO:
5350         case R_PPC64_GOT16_LO_DS:
5351           /* This symbol requires a global offset table entry.  */
5352           sec->has_toc_reloc = 1;
5353           if (r_type == R_PPC64_GOT_TLSLD16
5354               || r_type == R_PPC64_GOT_TLSGD16
5355               || r_type == R_PPC64_GOT_TPREL16_DS
5356               || r_type == R_PPC64_GOT_DTPREL16_DS
5357               || r_type == R_PPC64_GOT16
5358               || r_type == R_PPC64_GOT16_DS)
5359             {
5360               htab->do_multi_toc = 1;
5361               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5362             }
5363
5364           if (ppc64_elf_tdata (abfd)->got == NULL
5365               && !create_got_section (abfd, info))
5366             return FALSE;
5367
5368           if (h != NULL)
5369             {
5370               struct ppc_link_hash_entry *eh;
5371               struct got_entry *ent;
5372
5373               eh = (struct ppc_link_hash_entry *) h;
5374               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5375                 if (ent->addend == rel->r_addend
5376                     && ent->owner == abfd
5377                     && ent->tls_type == tls_type)
5378                   break;
5379               if (ent == NULL)
5380                 {
5381                   bfd_size_type amt = sizeof (*ent);
5382                   ent = bfd_alloc (abfd, amt);
5383                   if (ent == NULL)
5384                     return FALSE;
5385                   ent->next = eh->elf.got.glist;
5386                   ent->addend = rel->r_addend;
5387                   ent->owner = abfd;
5388                   ent->tls_type = tls_type;
5389                   ent->is_indirect = FALSE;
5390                   ent->got.refcount = 0;
5391                   eh->elf.got.glist = ent;
5392                 }
5393               ent->got.refcount += 1;
5394               eh->tls_mask |= tls_type;
5395             }
5396           else
5397             /* This is a global offset table entry for a local symbol.  */
5398             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5399                                         rel->r_addend, tls_type))
5400               return FALSE;
5401
5402           /* We may also need a plt entry if the symbol turns out to be
5403              an ifunc.  */
5404           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5405             {
5406               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5407                 return FALSE;
5408             }
5409           break;
5410
5411         case R_PPC64_PLT16_HA:
5412         case R_PPC64_PLT16_HI:
5413         case R_PPC64_PLT16_LO:
5414         case R_PPC64_PLT32:
5415         case R_PPC64_PLT64:
5416           /* This symbol requires a procedure linkage table entry.  We
5417              actually build the entry in adjust_dynamic_symbol,
5418              because this might be a case of linking PIC code without
5419              linking in any dynamic objects, in which case we don't
5420              need to generate a procedure linkage table after all.  */
5421           if (h == NULL)
5422             {
5423               /* It does not make sense to have a procedure linkage
5424                  table entry for a local symbol.  */
5425               bfd_set_error (bfd_error_bad_value);
5426               return FALSE;
5427             }
5428           else
5429             {
5430               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5431                 return FALSE;
5432               h->needs_plt = 1;
5433               if (h->root.root.string[0] == '.'
5434                   && h->root.root.string[1] != '\0')
5435                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5436             }
5437           break;
5438
5439           /* The following relocations don't need to propagate the
5440              relocation if linking a shared object since they are
5441              section relative.  */
5442         case R_PPC64_SECTOFF:
5443         case R_PPC64_SECTOFF_LO:
5444         case R_PPC64_SECTOFF_HI:
5445         case R_PPC64_SECTOFF_HA:
5446         case R_PPC64_SECTOFF_DS:
5447         case R_PPC64_SECTOFF_LO_DS:
5448         case R_PPC64_DTPREL16:
5449         case R_PPC64_DTPREL16_LO:
5450         case R_PPC64_DTPREL16_HI:
5451         case R_PPC64_DTPREL16_HA:
5452         case R_PPC64_DTPREL16_DS:
5453         case R_PPC64_DTPREL16_LO_DS:
5454         case R_PPC64_DTPREL16_HIGH:
5455         case R_PPC64_DTPREL16_HIGHA:
5456         case R_PPC64_DTPREL16_HIGHER:
5457         case R_PPC64_DTPREL16_HIGHERA:
5458         case R_PPC64_DTPREL16_HIGHEST:
5459         case R_PPC64_DTPREL16_HIGHESTA:
5460           break;
5461
5462           /* Nor do these.  */
5463         case R_PPC64_REL16:
5464         case R_PPC64_REL16_LO:
5465         case R_PPC64_REL16_HI:
5466         case R_PPC64_REL16_HA:
5467           break;
5468
5469           /* Not supported as a dynamic relocation.  */
5470         case R_PPC64_ADDR64_LOCAL:
5471           if (info->shared)
5472             {
5473               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5474                 ppc_howto_init ();
5475               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5476                                         "in shared libraries and PIEs.\n"),
5477                                       abfd, sec, rel->r_offset,
5478                                       ppc64_elf_howto_table[r_type]->name);
5479               bfd_set_error (bfd_error_bad_value);
5480               return FALSE;
5481             }
5482           break;
5483
5484         case R_PPC64_TOC16:
5485         case R_PPC64_TOC16_DS:
5486           htab->do_multi_toc = 1;
5487           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5488         case R_PPC64_TOC16_LO:
5489         case R_PPC64_TOC16_HI:
5490         case R_PPC64_TOC16_HA:
5491         case R_PPC64_TOC16_LO_DS:
5492           sec->has_toc_reloc = 1;
5493           break;
5494
5495           /* This relocation describes the C++ object vtable hierarchy.
5496              Reconstruct it for later use during GC.  */
5497         case R_PPC64_GNU_VTINHERIT:
5498           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5499             return FALSE;
5500           break;
5501
5502           /* This relocation describes which C++ vtable entries are actually
5503              used.  Record for later use during GC.  */
5504         case R_PPC64_GNU_VTENTRY:
5505           BFD_ASSERT (h != NULL);
5506           if (h != NULL
5507               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5508             return FALSE;
5509           break;
5510
5511         case R_PPC64_REL14:
5512         case R_PPC64_REL14_BRTAKEN:
5513         case R_PPC64_REL14_BRNTAKEN:
5514           {
5515             asection *dest = NULL;
5516
5517             /* Heuristic: If jumping outside our section, chances are
5518                we are going to need a stub.  */
5519             if (h != NULL)
5520               {
5521                 /* If the sym is weak it may be overridden later, so
5522                    don't assume we know where a weak sym lives.  */
5523                 if (h->root.type == bfd_link_hash_defined)
5524                   dest = h->root.u.def.section;
5525               }
5526             else
5527               {
5528                 Elf_Internal_Sym *isym;
5529
5530                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5531                                               abfd, r_symndx);
5532                 if (isym == NULL)
5533                   return FALSE;
5534
5535                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5536               }
5537
5538             if (dest != sec)
5539               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5540           }
5541           /* Fall through.  */
5542
5543         case R_PPC64_REL24:
5544           if (h != NULL && ifunc == NULL)
5545             {
5546               /* We may need a .plt entry if the function this reloc
5547                  refers to is in a shared lib.  */
5548               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5549                 return FALSE;
5550               h->needs_plt = 1;
5551               if (h->root.root.string[0] == '.'
5552                   && h->root.root.string[1] != '\0')
5553                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5554               if (h == tga || h == dottga)
5555                 sec->has_tls_reloc = 1;
5556             }
5557           break;
5558
5559         case R_PPC64_TPREL64:
5560           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5561           if (info->shared)
5562             info->flags |= DF_STATIC_TLS;
5563           goto dotlstoc;
5564
5565         case R_PPC64_DTPMOD64:
5566           if (rel + 1 < rel_end
5567               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5568               && rel[1].r_offset == rel->r_offset + 8)
5569             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5570           else
5571             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5572           goto dotlstoc;
5573
5574         case R_PPC64_DTPREL64:
5575           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5576           if (rel != relocs
5577               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5578               && rel[-1].r_offset == rel->r_offset - 8)
5579             /* This is the second reloc of a dtpmod, dtprel pair.
5580                Don't mark with TLS_DTPREL.  */
5581             goto dodyn;
5582
5583         dotlstoc:
5584           sec->has_tls_reloc = 1;
5585           if (h != NULL)
5586             {
5587               struct ppc_link_hash_entry *eh;
5588               eh = (struct ppc_link_hash_entry *) h;
5589               eh->tls_mask |= tls_type;
5590             }
5591           else
5592             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5593                                         rel->r_addend, tls_type))
5594               return FALSE;
5595
5596           ppc64_sec = ppc64_elf_section_data (sec);
5597           if (ppc64_sec->sec_type != sec_toc)
5598             {
5599               bfd_size_type amt;
5600
5601               /* One extra to simplify get_tls_mask.  */
5602               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5603               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5604               if (ppc64_sec->u.toc.symndx == NULL)
5605                 return FALSE;
5606               amt = sec->size * sizeof (bfd_vma) / 8;
5607               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5608               if (ppc64_sec->u.toc.add == NULL)
5609                 return FALSE;
5610               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5611               ppc64_sec->sec_type = sec_toc;
5612             }
5613           BFD_ASSERT (rel->r_offset % 8 == 0);
5614           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5615           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5616
5617           /* Mark the second slot of a GD or LD entry.
5618              -1 to indicate GD and -2 to indicate LD.  */
5619           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5620             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5621           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5622             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5623           goto dodyn;
5624
5625         case R_PPC64_TPREL16:
5626         case R_PPC64_TPREL16_LO:
5627         case R_PPC64_TPREL16_HI:
5628         case R_PPC64_TPREL16_HA:
5629         case R_PPC64_TPREL16_DS:
5630         case R_PPC64_TPREL16_LO_DS:
5631         case R_PPC64_TPREL16_HIGH:
5632         case R_PPC64_TPREL16_HIGHA:
5633         case R_PPC64_TPREL16_HIGHER:
5634         case R_PPC64_TPREL16_HIGHERA:
5635         case R_PPC64_TPREL16_HIGHEST:
5636         case R_PPC64_TPREL16_HIGHESTA:
5637           if (info->shared)
5638             {
5639               info->flags |= DF_STATIC_TLS;
5640               goto dodyn;
5641             }
5642           break;
5643
5644         case R_PPC64_ADDR64:
5645           if (opd_sym_map != NULL
5646               && rel + 1 < rel_end
5647               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5648             {
5649               if (h != NULL)
5650                 {
5651                   if (h->root.root.string[0] == '.'
5652                       && h->root.root.string[1] != 0
5653                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5654                     ;
5655                   else
5656                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5657                 }
5658               else
5659                 {
5660                   asection *s;
5661                   Elf_Internal_Sym *isym;
5662
5663                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5664                                                 abfd, r_symndx);
5665                   if (isym == NULL)
5666                     return FALSE;
5667
5668                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5669                   if (s != NULL && s != sec)
5670                     opd_sym_map[rel->r_offset / 8] = s;
5671                 }
5672             }
5673           /* Fall through.  */
5674
5675         case R_PPC64_ADDR16:
5676         case R_PPC64_ADDR16_DS:
5677         case R_PPC64_ADDR16_HA:
5678         case R_PPC64_ADDR16_HI:
5679         case R_PPC64_ADDR16_HIGH:
5680         case R_PPC64_ADDR16_HIGHA:
5681         case R_PPC64_ADDR16_HIGHER:
5682         case R_PPC64_ADDR16_HIGHERA:
5683         case R_PPC64_ADDR16_HIGHEST:
5684         case R_PPC64_ADDR16_HIGHESTA:
5685         case R_PPC64_ADDR16_LO:
5686         case R_PPC64_ADDR16_LO_DS:
5687           if (h != NULL && !info->shared && abiversion (abfd) != 1
5688               && rel->r_addend == 0)
5689             {
5690               /* We may need a .plt entry if this reloc refers to a
5691                  function in a shared lib.  */
5692               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5693                 return FALSE;
5694               h->pointer_equality_needed = 1;
5695             }
5696           /* Fall through.  */
5697
5698         case R_PPC64_REL30:
5699         case R_PPC64_REL32:
5700         case R_PPC64_REL64:
5701         case R_PPC64_ADDR14:
5702         case R_PPC64_ADDR14_BRNTAKEN:
5703         case R_PPC64_ADDR14_BRTAKEN:
5704         case R_PPC64_ADDR24:
5705         case R_PPC64_ADDR32:
5706         case R_PPC64_UADDR16:
5707         case R_PPC64_UADDR32:
5708         case R_PPC64_UADDR64:
5709         case R_PPC64_TOC:
5710           if (h != NULL && !info->shared)
5711             /* We may need a copy reloc.  */
5712             h->non_got_ref = 1;
5713
5714           /* Don't propagate .opd relocs.  */
5715           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5716             break;
5717
5718           /* If we are creating a shared library, and this is a reloc
5719              against a global symbol, or a non PC relative reloc
5720              against a local symbol, then we need to copy the reloc
5721              into the shared library.  However, if we are linking with
5722              -Bsymbolic, we do not need to copy a reloc against a
5723              global symbol which is defined in an object we are
5724              including in the link (i.e., DEF_REGULAR is set).  At
5725              this point we have not seen all the input files, so it is
5726              possible that DEF_REGULAR is not set now but will be set
5727              later (it is never cleared).  In case of a weak definition,
5728              DEF_REGULAR may be cleared later by a strong definition in
5729              a shared library.  We account for that possibility below by
5730              storing information in the dyn_relocs field of the hash
5731              table entry.  A similar situation occurs when creating
5732              shared libraries and symbol visibility changes render the
5733              symbol local.
5734
5735              If on the other hand, we are creating an executable, we
5736              may need to keep relocations for symbols satisfied by a
5737              dynamic library if we manage to avoid copy relocs for the
5738              symbol.  */
5739         dodyn:
5740           if ((info->shared
5741                && (must_be_dyn_reloc (info, r_type)
5742                    || (h != NULL
5743                        && (!SYMBOLIC_BIND (info, h)
5744                            || h->root.type == bfd_link_hash_defweak
5745                            || !h->def_regular))))
5746               || (ELIMINATE_COPY_RELOCS
5747                   && !info->shared
5748                   && h != NULL
5749                   && (h->root.type == bfd_link_hash_defweak
5750                       || !h->def_regular))
5751               || (!info->shared
5752                   && ifunc != NULL))
5753             {
5754               /* We must copy these reloc types into the output file.
5755                  Create a reloc section in dynobj and make room for
5756                  this reloc.  */
5757               if (sreloc == NULL)
5758                 {
5759                   sreloc = _bfd_elf_make_dynamic_reloc_section
5760                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5761
5762                   if (sreloc == NULL)
5763                     return FALSE;
5764                 }
5765
5766               /* If this is a global symbol, we count the number of
5767                  relocations we need for this symbol.  */
5768               if (h != NULL)
5769                 {
5770                   struct elf_dyn_relocs *p;
5771                   struct elf_dyn_relocs **head;
5772
5773                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5774                   p = *head;
5775                   if (p == NULL || p->sec != sec)
5776                     {
5777                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5778                       if (p == NULL)
5779                         return FALSE;
5780                       p->next = *head;
5781                       *head = p;
5782                       p->sec = sec;
5783                       p->count = 0;
5784                       p->pc_count = 0;
5785                     }
5786                   p->count += 1;
5787                   if (!must_be_dyn_reloc (info, r_type))
5788                     p->pc_count += 1;
5789                 }
5790               else
5791                 {
5792                   /* Track dynamic relocs needed for local syms too.
5793                      We really need local syms available to do this
5794                      easily.  Oh well.  */
5795                   struct ppc_dyn_relocs *p;
5796                   struct ppc_dyn_relocs **head;
5797                   bfd_boolean is_ifunc;
5798                   asection *s;
5799                   void *vpp;
5800                   Elf_Internal_Sym *isym;
5801
5802                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5803                                                 abfd, r_symndx);
5804                   if (isym == NULL)
5805                     return FALSE;
5806
5807                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5808                   if (s == NULL)
5809                     s = sec;
5810
5811                   vpp = &elf_section_data (s)->local_dynrel;
5812                   head = (struct ppc_dyn_relocs **) vpp;
5813                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5814                   p = *head;
5815                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5816                     p = p->next;
5817                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5818                     {
5819                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5820                       if (p == NULL)
5821                         return FALSE;
5822                       p->next = *head;
5823                       *head = p;
5824                       p->sec = sec;
5825                       p->ifunc = is_ifunc;
5826                       p->count = 0;
5827                     }
5828                   p->count += 1;
5829                 }
5830             }
5831           break;
5832
5833         default:
5834           break;
5835         }
5836     }
5837
5838   return TRUE;
5839 }
5840
5841 /* Merge backend specific data from an object file to the output
5842    object file when linking.  */
5843
5844 static bfd_boolean
5845 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5846 {
5847   unsigned long iflags, oflags;
5848
5849   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5850     return TRUE;
5851
5852   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5853     return TRUE;
5854
5855   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5856     return FALSE;
5857
5858   iflags = elf_elfheader (ibfd)->e_flags;
5859   oflags = elf_elfheader (obfd)->e_flags;
5860
5861   if (iflags & ~EF_PPC64_ABI)
5862     {
5863       (*_bfd_error_handler)
5864         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5865       bfd_set_error (bfd_error_bad_value);
5866       return FALSE;
5867     }
5868   else if (iflags != oflags && iflags != 0)
5869     {
5870       (*_bfd_error_handler)
5871         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5872          ibfd, iflags, oflags);
5873       bfd_set_error (bfd_error_bad_value);
5874       return FALSE;
5875     }
5876
5877   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5878   _bfd_elf_merge_object_attributes (ibfd, obfd);
5879
5880   return TRUE;
5881 }
5882
5883 static bfd_boolean
5884 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5885 {
5886   /* Print normal ELF private data.  */
5887   _bfd_elf_print_private_bfd_data (abfd, ptr);
5888
5889   if (elf_elfheader (abfd)->e_flags != 0)
5890     {
5891       FILE *file = ptr;
5892
5893       /* xgettext:c-format */
5894       fprintf (file, _("private flags = 0x%lx:"),
5895                elf_elfheader (abfd)->e_flags);
5896
5897       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5898         fprintf (file, _(" [abiv%ld]"),
5899                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5900       fputc ('\n', file);
5901     }
5902
5903   return TRUE;
5904 }
5905
5906 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5907    of the code entry point, and its section.  */
5908
5909 static bfd_vma
5910 opd_entry_value (asection *opd_sec,
5911                  bfd_vma offset,
5912                  asection **code_sec,
5913                  bfd_vma *code_off,
5914                  bfd_boolean in_code_sec)
5915 {
5916   bfd *opd_bfd = opd_sec->owner;
5917   Elf_Internal_Rela *relocs;
5918   Elf_Internal_Rela *lo, *hi, *look;
5919   bfd_vma val;
5920
5921   /* No relocs implies we are linking a --just-symbols object, or looking
5922      at a final linked executable with addr2line or somesuch.  */
5923   if (opd_sec->reloc_count == 0)
5924     {
5925       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5926
5927       if (contents == NULL)
5928         {
5929           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5930             return (bfd_vma) -1;
5931           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5932         }
5933
5934       val = bfd_get_64 (opd_bfd, contents + offset);
5935       if (code_sec != NULL)
5936         {
5937           asection *sec, *likely = NULL;
5938
5939           if (in_code_sec)
5940             {
5941               sec = *code_sec;
5942               if (sec->vma <= val
5943                   && val < sec->vma + sec->size)
5944                 likely = sec;
5945               else
5946                 val = -1;
5947             }
5948           else
5949             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5950               if (sec->vma <= val
5951                   && (sec->flags & SEC_LOAD) != 0
5952                   && (sec->flags & SEC_ALLOC) != 0)
5953                 likely = sec;
5954           if (likely != NULL)
5955             {
5956               *code_sec = likely;
5957               if (code_off != NULL)
5958                 *code_off = val - likely->vma;
5959             }
5960         }
5961       return val;
5962     }
5963
5964   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5965
5966   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5967   if (relocs == NULL)
5968     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5969
5970   /* Go find the opd reloc at the sym address.  */
5971   lo = relocs;
5972   BFD_ASSERT (lo != NULL);
5973   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5974   val = (bfd_vma) -1;
5975   while (lo < hi)
5976     {
5977       look = lo + (hi - lo) / 2;
5978       if (look->r_offset < offset)
5979         lo = look + 1;
5980       else if (look->r_offset > offset)
5981         hi = look;
5982       else
5983         {
5984           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5985
5986           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5987               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5988             {
5989               unsigned long symndx = ELF64_R_SYM (look->r_info);
5990               asection *sec;
5991
5992               if (symndx < symtab_hdr->sh_info
5993                   || elf_sym_hashes (opd_bfd) == NULL)
5994                 {
5995                   Elf_Internal_Sym *sym;
5996
5997                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5998                   if (sym == NULL)
5999                     {
6000                       size_t symcnt = symtab_hdr->sh_info;
6001                       if (elf_sym_hashes (opd_bfd) == NULL)
6002                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
6003                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
6004                                                   0, NULL, NULL, NULL);
6005                       if (sym == NULL)
6006                         break;
6007                       symtab_hdr->contents = (bfd_byte *) sym;
6008                     }
6009
6010                   sym += symndx;
6011                   val = sym->st_value;
6012                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6013                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6014                 }
6015               else
6016                 {
6017                   struct elf_link_hash_entry **sym_hashes;
6018                   struct elf_link_hash_entry *rh;
6019
6020                   sym_hashes = elf_sym_hashes (opd_bfd);
6021                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6022                   if (rh != NULL)
6023                     {
6024                       rh = elf_follow_link (rh);
6025                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6026                                   || rh->root.type == bfd_link_hash_defweak);
6027                       val = rh->root.u.def.value;
6028                       sec = rh->root.u.def.section;
6029                     }
6030                   else
6031                     {
6032                       /* Handle the odd case where we can be called
6033                          during bfd_elf_link_add_symbols before the
6034                          symbol hashes have been fully populated.  */
6035                       Elf_Internal_Sym *sym;
6036
6037                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6038                                                   symndx, NULL, NULL, NULL);
6039                       if (sym == NULL)
6040                         break;
6041
6042                       val = sym->st_value;
6043                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6044                       free (sym);
6045                     }
6046                 }
6047               val += look->r_addend;
6048               if (code_off != NULL)
6049                 *code_off = val;
6050               if (code_sec != NULL)
6051                 {
6052                   if (in_code_sec && *code_sec != sec)
6053                     return -1;
6054                   else
6055                     *code_sec = sec;
6056                 }
6057               if (sec != NULL && sec->output_section != NULL)
6058                 val += sec->output_section->vma + sec->output_offset;
6059             }
6060           break;
6061         }
6062     }
6063
6064   return val;
6065 }
6066
6067 /* If the ELF symbol SYM might be a function in SEC, return the
6068    function size and set *CODE_OFF to the function's entry point,
6069    otherwise return zero.  */
6070
6071 static bfd_size_type
6072 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6073                               bfd_vma *code_off)
6074 {
6075   bfd_size_type size;
6076
6077   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6078                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6079     return 0;
6080
6081   size = 0;
6082   if (!(sym->flags & BSF_SYNTHETIC))
6083     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6084
6085   if (strcmp (sym->section->name, ".opd") == 0)
6086     {
6087       if (opd_entry_value (sym->section, sym->value,
6088                            &sec, code_off, TRUE) == (bfd_vma) -1)
6089         return 0;
6090       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6091          symbol.  This size has nothing to do with the code size of the
6092          function, which is what we're supposed to return, but the
6093          code size isn't available without looking up the dot-sym.
6094          However, doing that would be a waste of time particularly
6095          since elf_find_function will look at the dot-sym anyway.
6096          Now, elf_find_function will keep the largest size of any
6097          function sym found at the code address of interest, so return
6098          1 here to avoid it incorrectly caching a larger function size
6099          for a small function.  This does mean we return the wrong
6100          size for a new-ABI function of size 24, but all that does is
6101          disable caching for such functions.  */
6102       if (size == 24)
6103         size = 1;
6104     }
6105   else
6106     {
6107       if (sym->section != sec)
6108         return 0;
6109       *code_off = sym->value;
6110     }
6111   if (size == 0)
6112     size = 1;
6113   return size;
6114 }
6115
6116 /* Return true if symbol is defined in a regular object file.  */
6117
6118 static bfd_boolean
6119 is_static_defined (struct elf_link_hash_entry *h)
6120 {
6121   return ((h->root.type == bfd_link_hash_defined
6122            || h->root.type == bfd_link_hash_defweak)
6123           && h->root.u.def.section != NULL
6124           && h->root.u.def.section->output_section != NULL);
6125 }
6126
6127 /* If FDH is a function descriptor symbol, return the associated code
6128    entry symbol if it is defined.  Return NULL otherwise.  */
6129
6130 static struct ppc_link_hash_entry *
6131 defined_code_entry (struct ppc_link_hash_entry *fdh)
6132 {
6133   if (fdh->is_func_descriptor)
6134     {
6135       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6136       if (fh->elf.root.type == bfd_link_hash_defined
6137           || fh->elf.root.type == bfd_link_hash_defweak)
6138         return fh;
6139     }
6140   return NULL;
6141 }
6142
6143 /* If FH is a function code entry symbol, return the associated
6144    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6145
6146 static struct ppc_link_hash_entry *
6147 defined_func_desc (struct ppc_link_hash_entry *fh)
6148 {
6149   if (fh->oh != NULL
6150       && fh->oh->is_func_descriptor)
6151     {
6152       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6153       if (fdh->elf.root.type == bfd_link_hash_defined
6154           || fdh->elf.root.type == bfd_link_hash_defweak)
6155         return fdh;
6156     }
6157   return NULL;
6158 }
6159
6160 /* Mark all our entry sym sections, both opd and code section.  */
6161
6162 static void
6163 ppc64_elf_gc_keep (struct bfd_link_info *info)
6164 {
6165   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6166   struct bfd_sym_chain *sym;
6167
6168   if (htab == NULL)
6169     return;
6170
6171   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6172     {
6173       struct ppc_link_hash_entry *eh, *fh;
6174       asection *sec;
6175
6176       eh = (struct ppc_link_hash_entry *)
6177         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6178       if (eh == NULL)
6179         continue;
6180       if (eh->elf.root.type != bfd_link_hash_defined
6181           && eh->elf.root.type != bfd_link_hash_defweak)
6182         continue;
6183
6184       fh = defined_code_entry (eh);
6185       if (fh != NULL)
6186         {
6187           sec = fh->elf.root.u.def.section;
6188           sec->flags |= SEC_KEEP;
6189         }
6190       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6191                && opd_entry_value (eh->elf.root.u.def.section,
6192                                    eh->elf.root.u.def.value,
6193                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6194         sec->flags |= SEC_KEEP;
6195
6196       sec = eh->elf.root.u.def.section;
6197       sec->flags |= SEC_KEEP;
6198     }
6199 }
6200
6201 /* Mark sections containing dynamically referenced symbols.  When
6202    building shared libraries, we must assume that any visible symbol is
6203    referenced.  */
6204
6205 static bfd_boolean
6206 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6207 {
6208   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6209   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6210   struct ppc_link_hash_entry *fdh;
6211   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6212
6213   /* Dynamic linking info is on the func descriptor sym.  */
6214   fdh = defined_func_desc (eh);
6215   if (fdh != NULL)
6216     eh = fdh;
6217
6218   if ((eh->elf.root.type == bfd_link_hash_defined
6219        || eh->elf.root.type == bfd_link_hash_defweak)
6220       && (eh->elf.ref_dynamic
6221           || (eh->elf.def_regular
6222               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6223               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6224               && (!info->executable
6225                   || info->export_dynamic
6226                   || (eh->elf.dynamic
6227                       && d != NULL
6228                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6229               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6230                   || !bfd_hide_sym_by_version (info->version_info,
6231                                                eh->elf.root.root.string)))))
6232     {
6233       asection *code_sec;
6234       struct ppc_link_hash_entry *fh;
6235
6236       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6237
6238       /* Function descriptor syms cause the associated
6239          function code sym section to be marked.  */
6240       fh = defined_code_entry (eh);
6241       if (fh != NULL)
6242         {
6243           code_sec = fh->elf.root.u.def.section;
6244           code_sec->flags |= SEC_KEEP;
6245         }
6246       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6247                && opd_entry_value (eh->elf.root.u.def.section,
6248                                    eh->elf.root.u.def.value,
6249                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6250         code_sec->flags |= SEC_KEEP;
6251     }
6252
6253   return TRUE;
6254 }
6255
6256 /* Return the section that should be marked against GC for a given
6257    relocation.  */
6258
6259 static asection *
6260 ppc64_elf_gc_mark_hook (asection *sec,
6261                         struct bfd_link_info *info,
6262                         Elf_Internal_Rela *rel,
6263                         struct elf_link_hash_entry *h,
6264                         Elf_Internal_Sym *sym)
6265 {
6266   asection *rsec;
6267
6268   /* Syms return NULL if we're marking .opd, so we avoid marking all
6269      function sections, as all functions are referenced in .opd.  */
6270   rsec = NULL;
6271   if (get_opd_info (sec) != NULL)
6272     return rsec;
6273
6274   if (h != NULL)
6275     {
6276       enum elf_ppc64_reloc_type r_type;
6277       struct ppc_link_hash_entry *eh, *fh, *fdh;
6278
6279       r_type = ELF64_R_TYPE (rel->r_info);
6280       switch (r_type)
6281         {
6282         case R_PPC64_GNU_VTINHERIT:
6283         case R_PPC64_GNU_VTENTRY:
6284           break;
6285
6286         default:
6287           switch (h->root.type)
6288             {
6289             case bfd_link_hash_defined:
6290             case bfd_link_hash_defweak:
6291               eh = (struct ppc_link_hash_entry *) h;
6292               fdh = defined_func_desc (eh);
6293               if (fdh != NULL)
6294                 eh = fdh;
6295
6296               /* Function descriptor syms cause the associated
6297                  function code sym section to be marked.  */
6298               fh = defined_code_entry (eh);
6299               if (fh != NULL)
6300                 {
6301                   /* They also mark their opd section.  */
6302                   eh->elf.root.u.def.section->gc_mark = 1;
6303
6304                   rsec = fh->elf.root.u.def.section;
6305                 }
6306               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6307                        && opd_entry_value (eh->elf.root.u.def.section,
6308                                            eh->elf.root.u.def.value,
6309                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6310                 eh->elf.root.u.def.section->gc_mark = 1;
6311               else
6312                 rsec = h->root.u.def.section;
6313               break;
6314
6315             case bfd_link_hash_common:
6316               rsec = h->root.u.c.p->section;
6317               break;
6318
6319             default:
6320               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6321             }
6322         }
6323     }
6324   else
6325     {
6326       struct _opd_sec_data *opd;
6327
6328       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6329       opd = get_opd_info (rsec);
6330       if (opd != NULL && opd->func_sec != NULL)
6331         {
6332           rsec->gc_mark = 1;
6333
6334           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6335         }
6336     }
6337
6338   return rsec;
6339 }
6340
6341 /* Update the .got, .plt. and dynamic reloc reference counts for the
6342    section being removed.  */
6343
6344 static bfd_boolean
6345 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6346                          asection *sec, const Elf_Internal_Rela *relocs)
6347 {
6348   struct ppc_link_hash_table *htab;
6349   Elf_Internal_Shdr *symtab_hdr;
6350   struct elf_link_hash_entry **sym_hashes;
6351   struct got_entry **local_got_ents;
6352   const Elf_Internal_Rela *rel, *relend;
6353
6354   if (info->relocatable)
6355     return TRUE;
6356
6357   if ((sec->flags & SEC_ALLOC) == 0)
6358     return TRUE;
6359
6360   elf_section_data (sec)->local_dynrel = NULL;
6361
6362   htab = ppc_hash_table (info);
6363   if (htab == NULL)
6364     return FALSE;
6365
6366   symtab_hdr = &elf_symtab_hdr (abfd);
6367   sym_hashes = elf_sym_hashes (abfd);
6368   local_got_ents = elf_local_got_ents (abfd);
6369
6370   relend = relocs + sec->reloc_count;
6371   for (rel = relocs; rel < relend; rel++)
6372     {
6373       unsigned long r_symndx;
6374       enum elf_ppc64_reloc_type r_type;
6375       struct elf_link_hash_entry *h = NULL;
6376       unsigned char tls_type = 0;
6377
6378       r_symndx = ELF64_R_SYM (rel->r_info);
6379       r_type = ELF64_R_TYPE (rel->r_info);
6380       if (r_symndx >= symtab_hdr->sh_info)
6381         {
6382           struct ppc_link_hash_entry *eh;
6383           struct elf_dyn_relocs **pp;
6384           struct elf_dyn_relocs *p;
6385
6386           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6387           h = elf_follow_link (h);
6388           eh = (struct ppc_link_hash_entry *) h;
6389
6390           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6391             if (p->sec == sec)
6392               {
6393                 /* Everything must go for SEC.  */
6394                 *pp = p->next;
6395                 break;
6396               }
6397         }
6398
6399       if (is_branch_reloc (r_type))
6400         {
6401           struct plt_entry **ifunc = NULL;
6402           if (h != NULL)
6403             {
6404               if (h->type == STT_GNU_IFUNC)
6405                 ifunc = &h->plt.plist;
6406             }
6407           else if (local_got_ents != NULL)
6408             {
6409               struct plt_entry **local_plt = (struct plt_entry **)
6410                 (local_got_ents + symtab_hdr->sh_info);
6411               unsigned char *local_got_tls_masks = (unsigned char *)
6412                 (local_plt + symtab_hdr->sh_info);
6413               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6414                 ifunc = local_plt + r_symndx;
6415             }
6416           if (ifunc != NULL)
6417             {
6418               struct plt_entry *ent;
6419
6420               for (ent = *ifunc; ent != NULL; ent = ent->next)
6421                 if (ent->addend == rel->r_addend)
6422                   break;
6423               if (ent == NULL)
6424                 abort ();
6425               if (ent->plt.refcount > 0)
6426                 ent->plt.refcount -= 1;
6427               continue;
6428             }
6429         }
6430
6431       switch (r_type)
6432         {
6433         case R_PPC64_GOT_TLSLD16:
6434         case R_PPC64_GOT_TLSLD16_LO:
6435         case R_PPC64_GOT_TLSLD16_HI:
6436         case R_PPC64_GOT_TLSLD16_HA:
6437           tls_type = TLS_TLS | TLS_LD;
6438           goto dogot;
6439
6440         case R_PPC64_GOT_TLSGD16:
6441         case R_PPC64_GOT_TLSGD16_LO:
6442         case R_PPC64_GOT_TLSGD16_HI:
6443         case R_PPC64_GOT_TLSGD16_HA:
6444           tls_type = TLS_TLS | TLS_GD;
6445           goto dogot;
6446
6447         case R_PPC64_GOT_TPREL16_DS:
6448         case R_PPC64_GOT_TPREL16_LO_DS:
6449         case R_PPC64_GOT_TPREL16_HI:
6450         case R_PPC64_GOT_TPREL16_HA:
6451           tls_type = TLS_TLS | TLS_TPREL;
6452           goto dogot;
6453
6454         case R_PPC64_GOT_DTPREL16_DS:
6455         case R_PPC64_GOT_DTPREL16_LO_DS:
6456         case R_PPC64_GOT_DTPREL16_HI:
6457         case R_PPC64_GOT_DTPREL16_HA:
6458           tls_type = TLS_TLS | TLS_DTPREL;
6459           goto dogot;
6460
6461         case R_PPC64_GOT16:
6462         case R_PPC64_GOT16_DS:
6463         case R_PPC64_GOT16_HA:
6464         case R_PPC64_GOT16_HI:
6465         case R_PPC64_GOT16_LO:
6466         case R_PPC64_GOT16_LO_DS:
6467         dogot:
6468           {
6469             struct got_entry *ent;
6470
6471             if (h != NULL)
6472               ent = h->got.glist;
6473             else
6474               ent = local_got_ents[r_symndx];
6475
6476             for (; ent != NULL; ent = ent->next)
6477               if (ent->addend == rel->r_addend
6478                   && ent->owner == abfd
6479                   && ent->tls_type == tls_type)
6480                 break;
6481             if (ent == NULL)
6482               abort ();
6483             if (ent->got.refcount > 0)
6484               ent->got.refcount -= 1;
6485           }
6486           break;
6487
6488         case R_PPC64_PLT16_HA:
6489         case R_PPC64_PLT16_HI:
6490         case R_PPC64_PLT16_LO:
6491         case R_PPC64_PLT32:
6492         case R_PPC64_PLT64:
6493         case R_PPC64_REL14:
6494         case R_PPC64_REL14_BRNTAKEN:
6495         case R_PPC64_REL14_BRTAKEN:
6496         case R_PPC64_REL24:
6497           if (h != NULL)
6498             {
6499               struct plt_entry *ent;
6500
6501               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6502                 if (ent->addend == rel->r_addend)
6503                   break;
6504               if (ent != NULL && ent->plt.refcount > 0)
6505                 ent->plt.refcount -= 1;
6506             }
6507           break;
6508
6509         default:
6510           break;
6511         }
6512     }
6513   return TRUE;
6514 }
6515
6516 /* The maximum size of .sfpr.  */
6517 #define SFPR_MAX (218*4)
6518
6519 struct sfpr_def_parms
6520 {
6521   const char name[12];
6522   unsigned char lo, hi;
6523   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6524   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6525 };
6526
6527 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6528
6529 static bfd_boolean
6530 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6531 {
6532   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6533   unsigned int i;
6534   size_t len = strlen (parm->name);
6535   bfd_boolean writing = FALSE;
6536   char sym[16];
6537
6538   if (htab == NULL)
6539     return FALSE;
6540
6541   memcpy (sym, parm->name, len);
6542   sym[len + 2] = 0;
6543
6544   for (i = parm->lo; i <= parm->hi; i++)
6545     {
6546       struct elf_link_hash_entry *h;
6547
6548       sym[len + 0] = i / 10 + '0';
6549       sym[len + 1] = i % 10 + '0';
6550       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6551       if (h != NULL
6552           && !h->def_regular)
6553         {
6554           h->root.type = bfd_link_hash_defined;
6555           h->root.u.def.section = htab->sfpr;
6556           h->root.u.def.value = htab->sfpr->size;
6557           h->type = STT_FUNC;
6558           h->def_regular = 1;
6559           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6560           writing = TRUE;
6561           if (htab->sfpr->contents == NULL)
6562             {
6563               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6564               if (htab->sfpr->contents == NULL)
6565                 return FALSE;
6566             }
6567         }
6568       if (writing)
6569         {
6570           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6571           if (i != parm->hi)
6572             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6573           else
6574             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6575           htab->sfpr->size = p - htab->sfpr->contents;
6576         }
6577     }
6578
6579   return TRUE;
6580 }
6581
6582 static bfd_byte *
6583 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6584 {
6585   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6586   return p + 4;
6587 }
6588
6589 static bfd_byte *
6590 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6591 {
6592   p = savegpr0 (abfd, p, r);
6593   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6594   p = p + 4;
6595   bfd_put_32 (abfd, BLR, p);
6596   return p + 4;
6597 }
6598
6599 static bfd_byte *
6600 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6601 {
6602   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6603   return p + 4;
6604 }
6605
6606 static bfd_byte *
6607 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6608 {
6609   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6610   p = p + 4;
6611   p = restgpr0 (abfd, p, r);
6612   bfd_put_32 (abfd, MTLR_R0, p);
6613   p = p + 4;
6614   if (r == 29)
6615     {
6616       p = restgpr0 (abfd, p, 30);
6617       p = restgpr0 (abfd, p, 31);
6618     }
6619   bfd_put_32 (abfd, BLR, p);
6620   return p + 4;
6621 }
6622
6623 static bfd_byte *
6624 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6625 {
6626   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6627   return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   p = savegpr1 (abfd, p, r);
6634   bfd_put_32 (abfd, BLR, p);
6635   return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6640 {
6641   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6642   return p + 4;
6643 }
6644
6645 static bfd_byte *
6646 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6647 {
6648   p = restgpr1 (abfd, p, r);
6649   bfd_put_32 (abfd, BLR, p);
6650   return p + 4;
6651 }
6652
6653 static bfd_byte *
6654 savefpr (bfd *abfd, bfd_byte *p, int r)
6655 {
6656   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6657   return p + 4;
6658 }
6659
6660 static bfd_byte *
6661 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6662 {
6663   p = savefpr (abfd, p, r);
6664   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6665   p = p + 4;
6666   bfd_put_32 (abfd, BLR, p);
6667   return p + 4;
6668 }
6669
6670 static bfd_byte *
6671 restfpr (bfd *abfd, bfd_byte *p, int r)
6672 {
6673   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6674   return p + 4;
6675 }
6676
6677 static bfd_byte *
6678 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6679 {
6680   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6681   p = p + 4;
6682   p = restfpr (abfd, p, r);
6683   bfd_put_32 (abfd, MTLR_R0, p);
6684   p = p + 4;
6685   if (r == 29)
6686     {
6687       p = restfpr (abfd, p, 30);
6688       p = restfpr (abfd, p, 31);
6689     }
6690   bfd_put_32 (abfd, BLR, p);
6691   return p + 4;
6692 }
6693
6694 static bfd_byte *
6695 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6696 {
6697   p = savefpr (abfd, p, r);
6698   bfd_put_32 (abfd, BLR, p);
6699   return p + 4;
6700 }
6701
6702 static bfd_byte *
6703 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6704 {
6705   p = restfpr (abfd, p, r);
6706   bfd_put_32 (abfd, BLR, p);
6707   return p + 4;
6708 }
6709
6710 static bfd_byte *
6711 savevr (bfd *abfd, bfd_byte *p, int r)
6712 {
6713   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6714   p = p + 4;
6715   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6716   return p + 4;
6717 }
6718
6719 static bfd_byte *
6720 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6721 {
6722   p = savevr (abfd, p, r);
6723   bfd_put_32 (abfd, BLR, p);
6724   return p + 4;
6725 }
6726
6727 static bfd_byte *
6728 restvr (bfd *abfd, bfd_byte *p, int r)
6729 {
6730   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6731   p = p + 4;
6732   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6733   return p + 4;
6734 }
6735
6736 static bfd_byte *
6737 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6738 {
6739   p = restvr (abfd, p, r);
6740   bfd_put_32 (abfd, BLR, p);
6741   return p + 4;
6742 }
6743
6744 /* Called via elf_link_hash_traverse to transfer dynamic linking
6745    information on function code symbol entries to their corresponding
6746    function descriptor symbol entries.  */
6747
6748 static bfd_boolean
6749 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6750 {
6751   struct bfd_link_info *info;
6752   struct ppc_link_hash_table *htab;
6753   struct plt_entry *ent;
6754   struct ppc_link_hash_entry *fh;
6755   struct ppc_link_hash_entry *fdh;
6756   bfd_boolean force_local;
6757
6758   fh = (struct ppc_link_hash_entry *) h;
6759   if (fh->elf.root.type == bfd_link_hash_indirect)
6760     return TRUE;
6761
6762   info = inf;
6763   htab = ppc_hash_table (info);
6764   if (htab == NULL)
6765     return FALSE;
6766
6767   /* Resolve undefined references to dot-symbols as the value
6768      in the function descriptor, if we have one in a regular object.
6769      This is to satisfy cases like ".quad .foo".  Calls to functions
6770      in dynamic objects are handled elsewhere.  */
6771   if (fh->elf.root.type == bfd_link_hash_undefweak
6772       && fh->was_undefined
6773       && (fdh = defined_func_desc (fh)) != NULL
6774       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6775       && opd_entry_value (fdh->elf.root.u.def.section,
6776                           fdh->elf.root.u.def.value,
6777                           &fh->elf.root.u.def.section,
6778                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6779     {
6780       fh->elf.root.type = fdh->elf.root.type;
6781       fh->elf.forced_local = 1;
6782       fh->elf.def_regular = fdh->elf.def_regular;
6783       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6784     }
6785
6786   /* If this is a function code symbol, transfer dynamic linking
6787      information to the function descriptor symbol.  */
6788   if (!fh->is_func)
6789     return TRUE;
6790
6791   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6792     if (ent->plt.refcount > 0)
6793       break;
6794   if (ent == NULL
6795       || fh->elf.root.root.string[0] != '.'
6796       || fh->elf.root.root.string[1] == '\0')
6797     return TRUE;
6798
6799   /* Find the corresponding function descriptor symbol.  Create it
6800      as undefined if necessary.  */
6801
6802   fdh = lookup_fdh (fh, htab);
6803   if (fdh == NULL
6804       && !info->executable
6805       && (fh->elf.root.type == bfd_link_hash_undefined
6806           || fh->elf.root.type == bfd_link_hash_undefweak))
6807     {
6808       fdh = make_fdh (info, fh);
6809       if (fdh == NULL)
6810         return FALSE;
6811     }
6812
6813   /* Fake function descriptors are made undefweak.  If the function
6814      code symbol is strong undefined, make the fake sym the same.
6815      If the function code symbol is defined, then force the fake
6816      descriptor local;  We can't support overriding of symbols in a
6817      shared library on a fake descriptor.  */
6818
6819   if (fdh != NULL
6820       && fdh->fake
6821       && fdh->elf.root.type == bfd_link_hash_undefweak)
6822     {
6823       if (fh->elf.root.type == bfd_link_hash_undefined)
6824         {
6825           fdh->elf.root.type = bfd_link_hash_undefined;
6826           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6827         }
6828       else if (fh->elf.root.type == bfd_link_hash_defined
6829                || fh->elf.root.type == bfd_link_hash_defweak)
6830         {
6831           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6832         }
6833     }
6834
6835   if (fdh != NULL
6836       && !fdh->elf.forced_local
6837       && (!info->executable
6838           || fdh->elf.def_dynamic
6839           || fdh->elf.ref_dynamic
6840           || (fdh->elf.root.type == bfd_link_hash_undefweak
6841               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6842     {
6843       if (fdh->elf.dynindx == -1)
6844         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6845           return FALSE;
6846       fdh->elf.ref_regular |= fh->elf.ref_regular;
6847       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6848       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6849       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6850       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6851         {
6852           move_plt_plist (fh, fdh);
6853           fdh->elf.needs_plt = 1;
6854         }
6855       fdh->is_func_descriptor = 1;
6856       fdh->oh = fh;
6857       fh->oh = fdh;
6858     }
6859
6860   /* Now that the info is on the function descriptor, clear the
6861      function code sym info.  Any function code syms for which we
6862      don't have a definition in a regular file, we force local.
6863      This prevents a shared library from exporting syms that have
6864      been imported from another library.  Function code syms that
6865      are really in the library we must leave global to prevent the
6866      linker dragging in a definition from a static library.  */
6867   force_local = (!fh->elf.def_regular
6868                  || fdh == NULL
6869                  || !fdh->elf.def_regular
6870                  || fdh->elf.forced_local);
6871   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6872
6873   return TRUE;
6874 }
6875
6876 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6877    this hook to a) provide some gcc support functions, and b) transfer
6878    dynamic linking information gathered so far on function code symbol
6879    entries, to their corresponding function descriptor symbol entries.  */
6880
6881 static bfd_boolean
6882 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6883                             struct bfd_link_info *info)
6884 {
6885   struct ppc_link_hash_table *htab;
6886   unsigned int i;
6887   static const struct sfpr_def_parms funcs[] =
6888     {
6889       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6890       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6891       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6892       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6893       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6894       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6895       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6896       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6897       { "._savef", 14, 31, savefpr, savefpr1_tail },
6898       { "._restf", 14, 31, restfpr, restfpr1_tail },
6899       { "_savevr_", 20, 31, savevr, savevr_tail },
6900       { "_restvr_", 20, 31, restvr, restvr_tail }
6901     };
6902
6903   htab = ppc_hash_table (info);
6904   if (htab == NULL)
6905     return FALSE;
6906
6907   if (!info->relocatable
6908       && htab->elf.hgot != NULL)
6909     {
6910       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6911       /* Make .TOC. defined so as to prevent it being made dynamic.
6912          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6913       htab->elf.hgot->type = STT_OBJECT;
6914       htab->elf.hgot->root.type = bfd_link_hash_defined;
6915       htab->elf.hgot->root.u.def.value = 0;
6916       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6917       htab->elf.hgot->def_regular = 1;
6918       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6919                                | STV_HIDDEN);
6920     }
6921
6922   if (htab->sfpr == NULL)
6923     /* We don't have any relocs.  */
6924     return TRUE;
6925
6926   /* Provide any missing _save* and _rest* functions.  */
6927   htab->sfpr->size = 0;
6928   if (htab->params->save_restore_funcs)
6929     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6930       if (!sfpr_define (info, &funcs[i]))
6931         return FALSE;
6932
6933   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6934
6935   if (htab->sfpr->size == 0)
6936     htab->sfpr->flags |= SEC_EXCLUDE;
6937
6938   return TRUE;
6939 }
6940
6941 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6942
6943 static bfd_boolean
6944 readonly_dynrelocs (struct elf_link_hash_entry *h)
6945 {
6946   struct ppc_link_hash_entry *eh;
6947   struct elf_dyn_relocs *p;
6948
6949   eh = (struct ppc_link_hash_entry *) h;
6950   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6951     {
6952       asection *s = p->sec->output_section;
6953
6954       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6955         return TRUE;
6956     }
6957   return FALSE;
6958 }
6959
6960 /* Adjust a symbol defined by a dynamic object and referenced by a
6961    regular object.  The current definition is in some section of the
6962    dynamic object, but we're not including those sections.  We have to
6963    change the definition to something the rest of the link can
6964    understand.  */
6965
6966 static bfd_boolean
6967 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6968                                  struct elf_link_hash_entry *h)
6969 {
6970   struct ppc_link_hash_table *htab;
6971   asection *s;
6972
6973   htab = ppc_hash_table (info);
6974   if (htab == NULL)
6975     return FALSE;
6976
6977   /* Deal with function syms.  */
6978   if (h->type == STT_FUNC
6979       || h->type == STT_GNU_IFUNC
6980       || h->needs_plt)
6981     {
6982       /* Clear procedure linkage table information for any symbol that
6983          won't need a .plt entry.  */
6984       struct plt_entry *ent;
6985       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6986         if (ent->plt.refcount > 0)
6987           break;
6988       if (ent == NULL
6989           || (h->type != STT_GNU_IFUNC
6990               && (SYMBOL_CALLS_LOCAL (info, h)
6991                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6992                       && h->root.type == bfd_link_hash_undefweak))))
6993         {
6994           h->plt.plist = NULL;
6995           h->needs_plt = 0;
6996         }
6997       else if (abiversion (info->output_bfd) == 2)
6998         {
6999           /* After adjust_dynamic_symbol, non_got_ref set in the
7000              non-shared case means that we have allocated space in
7001              .dynbss for the symbol and thus dyn_relocs for this
7002              symbol should be discarded.
7003              If we get here we know we are making a PLT entry for this
7004              symbol, and in an executable we'd normally resolve
7005              relocations against this symbol to the PLT entry.  Allow
7006              dynamic relocs if the reference is weak, and the dynamic
7007              relocs will not cause text relocation.  */
7008           if (!h->ref_regular_nonweak
7009               && h->non_got_ref
7010               && h->type != STT_GNU_IFUNC
7011               && !readonly_dynrelocs (h))
7012             h->non_got_ref = 0;
7013
7014           /* If making a plt entry, then we don't need copy relocs.  */
7015           return TRUE;
7016         }
7017     }
7018   else
7019     h->plt.plist = NULL;
7020
7021   /* If this is a weak symbol, and there is a real definition, the
7022      processor independent code will have arranged for us to see the
7023      real definition first, and we can just use the same value.  */
7024   if (h->u.weakdef != NULL)
7025     {
7026       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7027                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7028       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7029       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7030       if (ELIMINATE_COPY_RELOCS)
7031         h->non_got_ref = h->u.weakdef->non_got_ref;
7032       return TRUE;
7033     }
7034
7035   /* If we are creating a shared library, we must presume that the
7036      only references to the symbol are via the global offset table.
7037      For such cases we need not do anything here; the relocations will
7038      be handled correctly by relocate_section.  */
7039   if (info->shared)
7040     return TRUE;
7041
7042   /* If there are no references to this symbol that do not use the
7043      GOT, we don't need to generate a copy reloc.  */
7044   if (!h->non_got_ref)
7045     return TRUE;
7046
7047   /* Don't generate a copy reloc for symbols defined in the executable.  */
7048   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7049     return TRUE;
7050
7051   /* If we didn't find any dynamic relocs in read-only sections, then
7052      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7053   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7054     {
7055       h->non_got_ref = 0;
7056       return TRUE;
7057     }
7058
7059   if (h->plt.plist != NULL)
7060     {
7061       /* We should never get here, but unfortunately there are versions
7062          of gcc out there that improperly (for this ABI) put initialized
7063          function pointers, vtable refs and suchlike in read-only
7064          sections.  Allow them to proceed, but warn that this might
7065          break at runtime.  */
7066       info->callbacks->einfo
7067         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7068            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7069          h->root.root.string);
7070     }
7071
7072   /* This is a reference to a symbol defined by a dynamic object which
7073      is not a function.  */
7074
7075   /* We must allocate the symbol in our .dynbss section, which will
7076      become part of the .bss section of the executable.  There will be
7077      an entry for this symbol in the .dynsym section.  The dynamic
7078      object will contain position independent code, so all references
7079      from the dynamic object to this symbol will go through the global
7080      offset table.  The dynamic linker will use the .dynsym entry to
7081      determine the address it must put in the global offset table, so
7082      both the dynamic object and the regular object will refer to the
7083      same memory location for the variable.  */
7084
7085   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7086      to copy the initial value out of the dynamic object and into the
7087      runtime process image.  We need to remember the offset into the
7088      .rela.bss section we are going to use.  */
7089   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7090     {
7091       htab->relbss->size += sizeof (Elf64_External_Rela);
7092       h->needs_copy = 1;
7093     }
7094
7095   s = htab->dynbss;
7096
7097   return _bfd_elf_adjust_dynamic_copy (h, s);
7098 }
7099
7100 /* If given a function descriptor symbol, hide both the function code
7101    sym and the descriptor.  */
7102 static void
7103 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7104                        struct elf_link_hash_entry *h,
7105                        bfd_boolean force_local)
7106 {
7107   struct ppc_link_hash_entry *eh;
7108   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7109
7110   eh = (struct ppc_link_hash_entry *) h;
7111   if (eh->is_func_descriptor)
7112     {
7113       struct ppc_link_hash_entry *fh = eh->oh;
7114
7115       if (fh == NULL)
7116         {
7117           const char *p, *q;
7118           struct ppc_link_hash_table *htab;
7119           char save;
7120
7121           /* We aren't supposed to use alloca in BFD because on
7122              systems which do not have alloca the version in libiberty
7123              calls xmalloc, which might cause the program to crash
7124              when it runs out of memory.  This function doesn't have a
7125              return status, so there's no way to gracefully return an
7126              error.  So cheat.  We know that string[-1] can be safely
7127              accessed;  It's either a string in an ELF string table,
7128              or allocated in an objalloc structure.  */
7129
7130           p = eh->elf.root.root.string - 1;
7131           save = *p;
7132           *(char *) p = '.';
7133           htab = ppc_hash_table (info);
7134           if (htab == NULL)
7135             return;
7136
7137           fh = (struct ppc_link_hash_entry *)
7138             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7139           *(char *) p = save;
7140
7141           /* Unfortunately, if it so happens that the string we were
7142              looking for was allocated immediately before this string,
7143              then we overwrote the string terminator.  That's the only
7144              reason the lookup should fail.  */
7145           if (fh == NULL)
7146             {
7147               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7148               while (q >= eh->elf.root.root.string && *q == *p)
7149                 --q, --p;
7150               if (q < eh->elf.root.root.string && *p == '.')
7151                 fh = (struct ppc_link_hash_entry *)
7152                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7153             }
7154           if (fh != NULL)
7155             {
7156               eh->oh = fh;
7157               fh->oh = eh;
7158             }
7159         }
7160       if (fh != NULL)
7161         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7162     }
7163 }
7164
7165 static bfd_boolean
7166 get_sym_h (struct elf_link_hash_entry **hp,
7167            Elf_Internal_Sym **symp,
7168            asection **symsecp,
7169            unsigned char **tls_maskp,
7170            Elf_Internal_Sym **locsymsp,
7171            unsigned long r_symndx,
7172            bfd *ibfd)
7173 {
7174   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7175
7176   if (r_symndx >= symtab_hdr->sh_info)
7177     {
7178       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7179       struct elf_link_hash_entry *h;
7180
7181       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7182       h = elf_follow_link (h);
7183
7184       if (hp != NULL)
7185         *hp = h;
7186
7187       if (symp != NULL)
7188         *symp = NULL;
7189
7190       if (symsecp != NULL)
7191         {
7192           asection *symsec = NULL;
7193           if (h->root.type == bfd_link_hash_defined
7194               || h->root.type == bfd_link_hash_defweak)
7195             symsec = h->root.u.def.section;
7196           *symsecp = symsec;
7197         }
7198
7199       if (tls_maskp != NULL)
7200         {
7201           struct ppc_link_hash_entry *eh;
7202
7203           eh = (struct ppc_link_hash_entry *) h;
7204           *tls_maskp = &eh->tls_mask;
7205         }
7206     }
7207   else
7208     {
7209       Elf_Internal_Sym *sym;
7210       Elf_Internal_Sym *locsyms = *locsymsp;
7211
7212       if (locsyms == NULL)
7213         {
7214           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7215           if (locsyms == NULL)
7216             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7217                                             symtab_hdr->sh_info,
7218                                             0, NULL, NULL, NULL);
7219           if (locsyms == NULL)
7220             return FALSE;
7221           *locsymsp = locsyms;
7222         }
7223       sym = locsyms + r_symndx;
7224
7225       if (hp != NULL)
7226         *hp = NULL;
7227
7228       if (symp != NULL)
7229         *symp = sym;
7230
7231       if (symsecp != NULL)
7232         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7233
7234       if (tls_maskp != NULL)
7235         {
7236           struct got_entry **lgot_ents;
7237           unsigned char *tls_mask;
7238
7239           tls_mask = NULL;
7240           lgot_ents = elf_local_got_ents (ibfd);
7241           if (lgot_ents != NULL)
7242             {
7243               struct plt_entry **local_plt = (struct plt_entry **)
7244                 (lgot_ents + symtab_hdr->sh_info);
7245               unsigned char *lgot_masks = (unsigned char *)
7246                 (local_plt + symtab_hdr->sh_info);
7247               tls_mask = &lgot_masks[r_symndx];
7248             }
7249           *tls_maskp = tls_mask;
7250         }
7251     }
7252   return TRUE;
7253 }
7254
7255 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7256    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7257    type suitable for optimization, and 1 otherwise.  */
7258
7259 static int
7260 get_tls_mask (unsigned char **tls_maskp,
7261               unsigned long *toc_symndx,
7262               bfd_vma *toc_addend,
7263               Elf_Internal_Sym **locsymsp,
7264               const Elf_Internal_Rela *rel,
7265               bfd *ibfd)
7266 {
7267   unsigned long r_symndx;
7268   int next_r;
7269   struct elf_link_hash_entry *h;
7270   Elf_Internal_Sym *sym;
7271   asection *sec;
7272   bfd_vma off;
7273
7274   r_symndx = ELF64_R_SYM (rel->r_info);
7275   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7276     return 0;
7277
7278   if ((*tls_maskp != NULL && **tls_maskp != 0)
7279       || sec == NULL
7280       || ppc64_elf_section_data (sec) == NULL
7281       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7282     return 1;
7283
7284   /* Look inside a TOC section too.  */
7285   if (h != NULL)
7286     {
7287       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7288       off = h->root.u.def.value;
7289     }
7290   else
7291     off = sym->st_value;
7292   off += rel->r_addend;
7293   BFD_ASSERT (off % 8 == 0);
7294   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7295   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7296   if (toc_symndx != NULL)
7297     *toc_symndx = r_symndx;
7298   if (toc_addend != NULL)
7299     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7300   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7301     return 0;
7302   if ((h == NULL || is_static_defined (h))
7303       && (next_r == -1 || next_r == -2))
7304     return 1 - next_r;
7305   return 1;
7306 }
7307
7308 /* Find (or create) an entry in the tocsave hash table.  */
7309
7310 static struct tocsave_entry *
7311 tocsave_find (struct ppc_link_hash_table *htab,
7312               enum insert_option insert,
7313               Elf_Internal_Sym **local_syms,
7314               const Elf_Internal_Rela *irela,
7315               bfd *ibfd)
7316 {
7317   unsigned long r_indx;
7318   struct elf_link_hash_entry *h;
7319   Elf_Internal_Sym *sym;
7320   struct tocsave_entry ent, *p;
7321   hashval_t hash;
7322   struct tocsave_entry **slot;
7323
7324   r_indx = ELF64_R_SYM (irela->r_info);
7325   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7326     return NULL;
7327   if (ent.sec == NULL || ent.sec->output_section == NULL)
7328     {
7329       (*_bfd_error_handler)
7330         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7331       return NULL;
7332     }
7333
7334   if (h != NULL)
7335     ent.offset = h->root.u.def.value;
7336   else
7337     ent.offset = sym->st_value;
7338   ent.offset += irela->r_addend;
7339
7340   hash = tocsave_htab_hash (&ent);
7341   slot = ((struct tocsave_entry **)
7342           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7343   if (slot == NULL)
7344     return NULL;
7345
7346   if (*slot == NULL)
7347     {
7348       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7349       if (p == NULL)
7350         return NULL;
7351       *p = ent;
7352       *slot = p;
7353     }
7354   return *slot;
7355 }
7356
7357 /* Adjust all global syms defined in opd sections.  In gcc generated
7358    code for the old ABI, these will already have been done.  */
7359
7360 static bfd_boolean
7361 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7362 {
7363   struct ppc_link_hash_entry *eh;
7364   asection *sym_sec;
7365   struct _opd_sec_data *opd;
7366
7367   if (h->root.type == bfd_link_hash_indirect)
7368     return TRUE;
7369
7370   if (h->root.type != bfd_link_hash_defined
7371       && h->root.type != bfd_link_hash_defweak)
7372     return TRUE;
7373
7374   eh = (struct ppc_link_hash_entry *) h;
7375   if (eh->adjust_done)
7376     return TRUE;
7377
7378   sym_sec = eh->elf.root.u.def.section;
7379   opd = get_opd_info (sym_sec);
7380   if (opd != NULL && opd->adjust != NULL)
7381     {
7382       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7383       if (adjust == -1)
7384         {
7385           /* This entry has been deleted.  */
7386           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7387           if (dsec == NULL)
7388             {
7389               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7390                 if (discarded_section (dsec))
7391                   {
7392                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7393                     break;
7394                   }
7395             }
7396           eh->elf.root.u.def.value = 0;
7397           eh->elf.root.u.def.section = dsec;
7398         }
7399       else
7400         eh->elf.root.u.def.value += adjust;
7401       eh->adjust_done = 1;
7402     }
7403   return TRUE;
7404 }
7405
7406 /* Handles decrementing dynamic reloc counts for the reloc specified by
7407    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7408    have already been determined.  */
7409
7410 static bfd_boolean
7411 dec_dynrel_count (bfd_vma r_info,
7412                   asection *sec,
7413                   struct bfd_link_info *info,
7414                   Elf_Internal_Sym **local_syms,
7415                   struct elf_link_hash_entry *h,
7416                   Elf_Internal_Sym *sym)
7417 {
7418   enum elf_ppc64_reloc_type r_type;
7419   asection *sym_sec = NULL;
7420
7421   /* Can this reloc be dynamic?  This switch, and later tests here
7422      should be kept in sync with the code in check_relocs.  */
7423   r_type = ELF64_R_TYPE (r_info);
7424   switch (r_type)
7425     {
7426     default:
7427       return TRUE;
7428
7429     case R_PPC64_TPREL16:
7430     case R_PPC64_TPREL16_LO:
7431     case R_PPC64_TPREL16_HI:
7432     case R_PPC64_TPREL16_HA:
7433     case R_PPC64_TPREL16_DS:
7434     case R_PPC64_TPREL16_LO_DS:
7435     case R_PPC64_TPREL16_HIGH:
7436     case R_PPC64_TPREL16_HIGHA:
7437     case R_PPC64_TPREL16_HIGHER:
7438     case R_PPC64_TPREL16_HIGHERA:
7439     case R_PPC64_TPREL16_HIGHEST:
7440     case R_PPC64_TPREL16_HIGHESTA:
7441       if (!info->shared)
7442         return TRUE;
7443
7444     case R_PPC64_TPREL64:
7445     case R_PPC64_DTPMOD64:
7446     case R_PPC64_DTPREL64:
7447     case R_PPC64_ADDR64:
7448     case R_PPC64_REL30:
7449     case R_PPC64_REL32:
7450     case R_PPC64_REL64:
7451     case R_PPC64_ADDR14:
7452     case R_PPC64_ADDR14_BRNTAKEN:
7453     case R_PPC64_ADDR14_BRTAKEN:
7454     case R_PPC64_ADDR16:
7455     case R_PPC64_ADDR16_DS:
7456     case R_PPC64_ADDR16_HA:
7457     case R_PPC64_ADDR16_HI:
7458     case R_PPC64_ADDR16_HIGH:
7459     case R_PPC64_ADDR16_HIGHA:
7460     case R_PPC64_ADDR16_HIGHER:
7461     case R_PPC64_ADDR16_HIGHERA:
7462     case R_PPC64_ADDR16_HIGHEST:
7463     case R_PPC64_ADDR16_HIGHESTA:
7464     case R_PPC64_ADDR16_LO:
7465     case R_PPC64_ADDR16_LO_DS:
7466     case R_PPC64_ADDR24:
7467     case R_PPC64_ADDR32:
7468     case R_PPC64_UADDR16:
7469     case R_PPC64_UADDR32:
7470     case R_PPC64_UADDR64:
7471     case R_PPC64_TOC:
7472       break;
7473     }
7474
7475   if (local_syms != NULL)
7476     {
7477       unsigned long r_symndx;
7478       bfd *ibfd = sec->owner;
7479
7480       r_symndx = ELF64_R_SYM (r_info);
7481       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7482         return FALSE;
7483     }
7484
7485   if ((info->shared
7486        && (must_be_dyn_reloc (info, r_type)
7487            || (h != NULL
7488                && (!SYMBOLIC_BIND (info, h)
7489                    || h->root.type == bfd_link_hash_defweak
7490                    || !h->def_regular))))
7491       || (ELIMINATE_COPY_RELOCS
7492           && !info->shared
7493           && h != NULL
7494           && (h->root.type == bfd_link_hash_defweak
7495               || !h->def_regular)))
7496     ;
7497   else
7498     return TRUE;
7499
7500   if (h != NULL)
7501     {
7502       struct elf_dyn_relocs *p;
7503       struct elf_dyn_relocs **pp;
7504       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7505
7506       /* elf_gc_sweep may have already removed all dyn relocs associated
7507          with local syms for a given section.  Also, symbol flags are
7508          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7509          report a dynreloc miscount.  */
7510       if (*pp == NULL && info->gc_sections)
7511         return TRUE;
7512
7513       while ((p = *pp) != NULL)
7514         {
7515           if (p->sec == sec)
7516             {
7517               if (!must_be_dyn_reloc (info, r_type))
7518                 p->pc_count -= 1;
7519               p->count -= 1;
7520               if (p->count == 0)
7521                 *pp = p->next;
7522               return TRUE;
7523             }
7524           pp = &p->next;
7525         }
7526     }
7527   else
7528     {
7529       struct ppc_dyn_relocs *p;
7530       struct ppc_dyn_relocs **pp;
7531       void *vpp;
7532       bfd_boolean is_ifunc;
7533
7534       if (local_syms == NULL)
7535         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7536       if (sym_sec == NULL)
7537         sym_sec = sec;
7538
7539       vpp = &elf_section_data (sym_sec)->local_dynrel;
7540       pp = (struct ppc_dyn_relocs **) vpp;
7541
7542       if (*pp == NULL && info->gc_sections)
7543         return TRUE;
7544
7545       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7546       while ((p = *pp) != NULL)
7547         {
7548           if (p->sec == sec && p->ifunc == is_ifunc)
7549             {
7550               p->count -= 1;
7551               if (p->count == 0)
7552                 *pp = p->next;
7553               return TRUE;
7554             }
7555           pp = &p->next;
7556         }
7557     }
7558
7559   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7560                           sec->owner, sec);
7561   bfd_set_error (bfd_error_bad_value);
7562   return FALSE;
7563 }
7564
7565 /* Remove unused Official Procedure Descriptor entries.  Currently we
7566    only remove those associated with functions in discarded link-once
7567    sections, or weakly defined functions that have been overridden.  It
7568    would be possible to remove many more entries for statically linked
7569    applications.  */
7570
7571 bfd_boolean
7572 ppc64_elf_edit_opd (struct bfd_link_info *info)
7573 {
7574   bfd *ibfd;
7575   bfd_boolean some_edited = FALSE;
7576   asection *need_pad = NULL;
7577   struct ppc_link_hash_table *htab;
7578
7579   htab = ppc_hash_table (info);
7580   if (htab == NULL)
7581     return FALSE;
7582
7583   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7584     {
7585       asection *sec;
7586       Elf_Internal_Rela *relstart, *rel, *relend;
7587       Elf_Internal_Shdr *symtab_hdr;
7588       Elf_Internal_Sym *local_syms;
7589       bfd_vma offset;
7590       struct _opd_sec_data *opd;
7591       bfd_boolean need_edit, add_aux_fields;
7592       bfd_size_type cnt_16b = 0;
7593
7594       if (!is_ppc64_elf (ibfd))
7595         continue;
7596
7597       sec = bfd_get_section_by_name (ibfd, ".opd");
7598       if (sec == NULL || sec->size == 0)
7599         continue;
7600
7601       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7602         continue;
7603
7604       if (sec->output_section == bfd_abs_section_ptr)
7605         continue;
7606
7607       /* Look through the section relocs.  */
7608       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7609         continue;
7610
7611       local_syms = NULL;
7612       symtab_hdr = &elf_symtab_hdr (ibfd);
7613
7614       /* Read the relocations.  */
7615       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7616                                             info->keep_memory);
7617       if (relstart == NULL)
7618         return FALSE;
7619
7620       /* First run through the relocs to check they are sane, and to
7621          determine whether we need to edit this opd section.  */
7622       need_edit = FALSE;
7623       need_pad = sec;
7624       offset = 0;
7625       relend = relstart + sec->reloc_count;
7626       for (rel = relstart; rel < relend; )
7627         {
7628           enum elf_ppc64_reloc_type r_type;
7629           unsigned long r_symndx;
7630           asection *sym_sec;
7631           struct elf_link_hash_entry *h;
7632           Elf_Internal_Sym *sym;
7633
7634           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7635              only interested in the reloc pointing to a function entry
7636              point.  */
7637           if (rel->r_offset != offset
7638               || rel + 1 >= relend
7639               || (rel + 1)->r_offset != offset + 8)
7640             {
7641               /* If someone messes with .opd alignment then after a
7642                  "ld -r" we might have padding in the middle of .opd.
7643                  Also, there's nothing to prevent someone putting
7644                  something silly in .opd with the assembler.  No .opd
7645                  optimization for them!  */
7646             broken_opd:
7647               (*_bfd_error_handler)
7648                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7649               need_edit = FALSE;
7650               break;
7651             }
7652
7653           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7654               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7655             {
7656               (*_bfd_error_handler)
7657                 (_("%B: unexpected reloc type %u in .opd section"),
7658                  ibfd, r_type);
7659               need_edit = FALSE;
7660               break;
7661             }
7662
7663           r_symndx = ELF64_R_SYM (rel->r_info);
7664           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7665                           r_symndx, ibfd))
7666             goto error_ret;
7667
7668           if (sym_sec == NULL || sym_sec->owner == NULL)
7669             {
7670               const char *sym_name;
7671               if (h != NULL)
7672                 sym_name = h->root.root.string;
7673               else
7674                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7675                                              sym_sec);
7676
7677               (*_bfd_error_handler)
7678                 (_("%B: undefined sym `%s' in .opd section"),
7679                  ibfd, sym_name);
7680               need_edit = FALSE;
7681               break;
7682             }
7683
7684           /* opd entries are always for functions defined in the
7685              current input bfd.  If the symbol isn't defined in the
7686              input bfd, then we won't be using the function in this
7687              bfd;  It must be defined in a linkonce section in another
7688              bfd, or is weak.  It's also possible that we are
7689              discarding the function due to a linker script /DISCARD/,
7690              which we test for via the output_section.  */
7691           if (sym_sec->owner != ibfd
7692               || sym_sec->output_section == bfd_abs_section_ptr)
7693             need_edit = TRUE;
7694
7695           rel += 2;
7696           if (rel == relend
7697               || (rel + 1 == relend && rel->r_offset == offset + 16))
7698             {
7699               if (sec->size == offset + 24)
7700                 {
7701                   need_pad = NULL;
7702                   break;
7703                 }
7704               if (rel == relend && sec->size == offset + 16)
7705                 {
7706                   cnt_16b++;
7707                   break;
7708                 }
7709               goto broken_opd;
7710             }
7711
7712           if (rel->r_offset == offset + 24)
7713             offset += 24;
7714           else if (rel->r_offset != offset + 16)
7715             goto broken_opd;
7716           else if (rel + 1 < relend
7717                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7718                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7719             {
7720               offset += 16;
7721               cnt_16b++;
7722             }
7723           else if (rel + 2 < relend
7724                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7725                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7726             {
7727               offset += 24;
7728               rel += 1;
7729             }
7730           else
7731             goto broken_opd;
7732         }
7733
7734       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7735
7736       if (need_edit || add_aux_fields)
7737         {
7738           Elf_Internal_Rela *write_rel;
7739           Elf_Internal_Shdr *rel_hdr;
7740           bfd_byte *rptr, *wptr;
7741           bfd_byte *new_contents;
7742           bfd_boolean skip;
7743           long opd_ent_size;
7744           bfd_size_type amt;
7745
7746           new_contents = NULL;
7747           amt = sec->size * sizeof (long) / 8;
7748           opd = &ppc64_elf_section_data (sec)->u.opd;
7749           opd->adjust = bfd_zalloc (sec->owner, amt);
7750           if (opd->adjust == NULL)
7751             return FALSE;
7752           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7753
7754           /* This seems a waste of time as input .opd sections are all
7755              zeros as generated by gcc, but I suppose there's no reason
7756              this will always be so.  We might start putting something in
7757              the third word of .opd entries.  */
7758           if ((sec->flags & SEC_IN_MEMORY) == 0)
7759             {
7760               bfd_byte *loc;
7761               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7762                 {
7763                   if (loc != NULL)
7764                     free (loc);
7765                 error_ret:
7766                   if (local_syms != NULL
7767                       && symtab_hdr->contents != (unsigned char *) local_syms)
7768                     free (local_syms);
7769                   if (elf_section_data (sec)->relocs != relstart)
7770                     free (relstart);
7771                   return FALSE;
7772                 }
7773               sec->contents = loc;
7774               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7775             }
7776
7777           elf_section_data (sec)->relocs = relstart;
7778
7779           new_contents = sec->contents;
7780           if (add_aux_fields)
7781             {
7782               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7783               if (new_contents == NULL)
7784                 return FALSE;
7785               need_pad = FALSE;
7786             }
7787           wptr = new_contents;
7788           rptr = sec->contents;
7789
7790           write_rel = relstart;
7791           skip = FALSE;
7792           offset = 0;
7793           opd_ent_size = 0;
7794           for (rel = relstart; rel < relend; rel++)
7795             {
7796               unsigned long r_symndx;
7797               asection *sym_sec;
7798               struct elf_link_hash_entry *h;
7799               Elf_Internal_Sym *sym;
7800
7801               r_symndx = ELF64_R_SYM (rel->r_info);
7802               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7803                               r_symndx, ibfd))
7804                 goto error_ret;
7805
7806               if (rel->r_offset == offset)
7807                 {
7808                   struct ppc_link_hash_entry *fdh = NULL;
7809
7810                   /* See if the .opd entry is full 24 byte or
7811                      16 byte (with fd_aux entry overlapped with next
7812                      fd_func).  */
7813                   opd_ent_size = 24;
7814                   if ((rel + 2 == relend && sec->size == offset + 16)
7815                       || (rel + 3 < relend
7816                           && rel[2].r_offset == offset + 16
7817                           && rel[3].r_offset == offset + 24
7818                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7819                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7820                     opd_ent_size = 16;
7821
7822                   if (h != NULL
7823                       && h->root.root.string[0] == '.')
7824                     {
7825                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7826                       if (fdh != NULL
7827                           && fdh->elf.root.type != bfd_link_hash_defined
7828                           && fdh->elf.root.type != bfd_link_hash_defweak)
7829                         fdh = NULL;
7830                     }
7831
7832                   skip = (sym_sec->owner != ibfd
7833                           || sym_sec->output_section == bfd_abs_section_ptr);
7834                   if (skip)
7835                     {
7836                       if (fdh != NULL && sym_sec->owner == ibfd)
7837                         {
7838                           /* Arrange for the function descriptor sym
7839                              to be dropped.  */
7840                           fdh->elf.root.u.def.value = 0;
7841                           fdh->elf.root.u.def.section = sym_sec;
7842                         }
7843                       opd->adjust[rel->r_offset / 8] = -1;
7844                     }
7845                   else
7846                     {
7847                       /* We'll be keeping this opd entry.  */
7848
7849                       if (fdh != NULL)
7850                         {
7851                           /* Redefine the function descriptor symbol to
7852                              this location in the opd section.  It is
7853                              necessary to update the value here rather
7854                              than using an array of adjustments as we do
7855                              for local symbols, because various places
7856                              in the generic ELF code use the value
7857                              stored in u.def.value.  */
7858                           fdh->elf.root.u.def.value = wptr - new_contents;
7859                           fdh->adjust_done = 1;
7860                         }
7861
7862                       /* Local syms are a bit tricky.  We could
7863                          tweak them as they can be cached, but
7864                          we'd need to look through the local syms
7865                          for the function descriptor sym which we
7866                          don't have at the moment.  So keep an
7867                          array of adjustments.  */
7868                       opd->adjust[rel->r_offset / 8]
7869                         = (wptr - new_contents) - (rptr - sec->contents);
7870
7871                       if (wptr != rptr)
7872                         memcpy (wptr, rptr, opd_ent_size);
7873                       wptr += opd_ent_size;
7874                       if (add_aux_fields && opd_ent_size == 16)
7875                         {
7876                           memset (wptr, '\0', 8);
7877                           wptr += 8;
7878                         }
7879                     }
7880                   rptr += opd_ent_size;
7881                   offset += opd_ent_size;
7882                 }
7883
7884               if (skip)
7885                 {
7886                   if (!NO_OPD_RELOCS
7887                       && !info->relocatable
7888                       && !dec_dynrel_count (rel->r_info, sec, info,
7889                                             NULL, h, sym))
7890                     goto error_ret;
7891                 }
7892               else
7893                 {
7894                   /* We need to adjust any reloc offsets to point to the
7895                      new opd entries.  While we're at it, we may as well
7896                      remove redundant relocs.  */
7897                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7898                   if (write_rel != rel)
7899                     memcpy (write_rel, rel, sizeof (*rel));
7900                   ++write_rel;
7901                 }
7902             }
7903
7904           sec->size = wptr - new_contents;
7905           sec->reloc_count = write_rel - relstart;
7906           if (add_aux_fields)
7907             {
7908               free (sec->contents);
7909               sec->contents = new_contents;
7910             }
7911
7912           /* Fudge the header size too, as this is used later in
7913              elf_bfd_final_link if we are emitting relocs.  */
7914           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7915           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7916           some_edited = TRUE;
7917         }
7918       else if (elf_section_data (sec)->relocs != relstart)
7919         free (relstart);
7920
7921       if (local_syms != NULL
7922           && symtab_hdr->contents != (unsigned char *) local_syms)
7923         {
7924           if (!info->keep_memory)
7925             free (local_syms);
7926           else
7927             symtab_hdr->contents = (unsigned char *) local_syms;
7928         }
7929     }
7930
7931   if (some_edited)
7932     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7933
7934   /* If we are doing a final link and the last .opd entry is just 16 byte
7935      long, add a 8 byte padding after it.  */
7936   if (need_pad != NULL && !info->relocatable)
7937     {
7938       bfd_byte *p;
7939
7940       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7941         {
7942           BFD_ASSERT (need_pad->size > 0);
7943
7944           p = bfd_malloc (need_pad->size + 8);
7945           if (p == NULL)
7946             return FALSE;
7947
7948           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7949                                           p, 0, need_pad->size))
7950             return FALSE;
7951
7952           need_pad->contents = p;
7953           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7954         }
7955       else
7956         {
7957           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7958           if (p == NULL)
7959             return FALSE;
7960
7961           need_pad->contents = p;
7962         }
7963
7964       memset (need_pad->contents + need_pad->size, 0, 8);
7965       need_pad->size += 8;
7966     }
7967
7968   return TRUE;
7969 }
7970
7971 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7972
7973 asection *
7974 ppc64_elf_tls_setup (struct bfd_link_info *info)
7975 {
7976   struct ppc_link_hash_table *htab;
7977
7978   htab = ppc_hash_table (info);
7979   if (htab == NULL)
7980     return NULL;
7981
7982   if (abiversion (info->output_bfd) == 1)
7983     htab->opd_abi = 1;
7984
7985   if (htab->params->no_multi_toc)
7986     htab->do_multi_toc = 0;
7987   else if (!htab->do_multi_toc)
7988     htab->params->no_multi_toc = 1;
7989
7990   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7991                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7992                                               FALSE, FALSE, TRUE));
7993   /* Move dynamic linking info to the function descriptor sym.  */
7994   if (htab->tls_get_addr != NULL)
7995     func_desc_adjust (&htab->tls_get_addr->elf, info);
7996   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7997                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7998                                                  FALSE, FALSE, TRUE));
7999   if (!htab->params->no_tls_get_addr_opt)
8000     {
8001       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8002
8003       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8004                                   FALSE, FALSE, TRUE);
8005       if (opt != NULL)
8006         func_desc_adjust (opt, info);
8007       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8008                                      FALSE, FALSE, TRUE);
8009       if (opt_fd != NULL
8010           && (opt_fd->root.type == bfd_link_hash_defined
8011               || opt_fd->root.type == bfd_link_hash_defweak))
8012         {
8013           /* If glibc supports an optimized __tls_get_addr call stub,
8014              signalled by the presence of __tls_get_addr_opt, and we'll
8015              be calling __tls_get_addr via a plt call stub, then
8016              make __tls_get_addr point to __tls_get_addr_opt.  */
8017           tga_fd = &htab->tls_get_addr_fd->elf;
8018           if (htab->elf.dynamic_sections_created
8019               && tga_fd != NULL
8020               && (tga_fd->type == STT_FUNC
8021                   || tga_fd->needs_plt)
8022               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8023                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8024                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8025             {
8026               struct plt_entry *ent;
8027
8028               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8029                 if (ent->plt.refcount > 0)
8030                   break;
8031               if (ent != NULL)
8032                 {
8033                   tga_fd->root.type = bfd_link_hash_indirect;
8034                   tga_fd->root.u.i.link = &opt_fd->root;
8035                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8036                   if (opt_fd->dynindx != -1)
8037                     {
8038                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8039                       opt_fd->dynindx = -1;
8040                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8041                                               opt_fd->dynstr_index);
8042                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8043                         return NULL;
8044                     }
8045                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8046                   tga = &htab->tls_get_addr->elf;
8047                   if (opt != NULL && tga != NULL)
8048                     {
8049                       tga->root.type = bfd_link_hash_indirect;
8050                       tga->root.u.i.link = &opt->root;
8051                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8052                       _bfd_elf_link_hash_hide_symbol (info, opt,
8053                                                       tga->forced_local);
8054                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8055                     }
8056                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8057                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8058                   if (htab->tls_get_addr != NULL)
8059                     {
8060                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8061                       htab->tls_get_addr->is_func = 1;
8062                     }
8063                 }
8064             }
8065         }
8066       else
8067         htab->params->no_tls_get_addr_opt = TRUE;
8068     }
8069   return _bfd_elf_tls_setup (info->output_bfd, info);
8070 }
8071
8072 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8073    HASH1 or HASH2.  */
8074
8075 static bfd_boolean
8076 branch_reloc_hash_match (const bfd *ibfd,
8077                          const Elf_Internal_Rela *rel,
8078                          const struct ppc_link_hash_entry *hash1,
8079                          const struct ppc_link_hash_entry *hash2)
8080 {
8081   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8082   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8083   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8084
8085   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8086     {
8087       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8088       struct elf_link_hash_entry *h;
8089
8090       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8091       h = elf_follow_link (h);
8092       if (h == &hash1->elf || h == &hash2->elf)
8093         return TRUE;
8094     }
8095   return FALSE;
8096 }
8097
8098 /* Run through all the TLS relocs looking for optimization
8099    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8100    a preliminary section layout so that we know the TLS segment
8101    offsets.  We can't optimize earlier because some optimizations need
8102    to know the tp offset, and we need to optimize before allocating
8103    dynamic relocations.  */
8104
8105 bfd_boolean
8106 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8107 {
8108   bfd *ibfd;
8109   asection *sec;
8110   struct ppc_link_hash_table *htab;
8111   unsigned char *toc_ref;
8112   int pass;
8113
8114   if (info->relocatable || !info->executable)
8115     return TRUE;
8116
8117   htab = ppc_hash_table (info);
8118   if (htab == NULL)
8119     return FALSE;
8120
8121   /* Make two passes over the relocs.  On the first pass, mark toc
8122      entries involved with tls relocs, and check that tls relocs
8123      involved in setting up a tls_get_addr call are indeed followed by
8124      such a call.  If they are not, we can't do any tls optimization.
8125      On the second pass twiddle tls_mask flags to notify
8126      relocate_section that optimization can be done, and adjust got
8127      and plt refcounts.  */
8128   toc_ref = NULL;
8129   for (pass = 0; pass < 2; ++pass)
8130     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8131       {
8132         Elf_Internal_Sym *locsyms = NULL;
8133         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8134
8135         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8136           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8137             {
8138               Elf_Internal_Rela *relstart, *rel, *relend;
8139               bfd_boolean found_tls_get_addr_arg = 0;
8140
8141               /* Read the relocations.  */
8142               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8143                                                     info->keep_memory);
8144               if (relstart == NULL)
8145                 {
8146                   free (toc_ref);
8147                   return FALSE;
8148                 }
8149
8150               relend = relstart + sec->reloc_count;
8151               for (rel = relstart; rel < relend; rel++)
8152                 {
8153                   enum elf_ppc64_reloc_type r_type;
8154                   unsigned long r_symndx;
8155                   struct elf_link_hash_entry *h;
8156                   Elf_Internal_Sym *sym;
8157                   asection *sym_sec;
8158                   unsigned char *tls_mask;
8159                   unsigned char tls_set, tls_clear, tls_type = 0;
8160                   bfd_vma value;
8161                   bfd_boolean ok_tprel, is_local;
8162                   long toc_ref_index = 0;
8163                   int expecting_tls_get_addr = 0;
8164                   bfd_boolean ret = FALSE;
8165
8166                   r_symndx = ELF64_R_SYM (rel->r_info);
8167                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8168                                   r_symndx, ibfd))
8169                     {
8170                     err_free_rel:
8171                       if (elf_section_data (sec)->relocs != relstart)
8172                         free (relstart);
8173                       if (toc_ref != NULL)
8174                         free (toc_ref);
8175                       if (locsyms != NULL
8176                           && (elf_symtab_hdr (ibfd).contents
8177                               != (unsigned char *) locsyms))
8178                         free (locsyms);
8179                       return ret;
8180                     }
8181
8182                   if (h != NULL)
8183                     {
8184                       if (h->root.type == bfd_link_hash_defined
8185                           || h->root.type == bfd_link_hash_defweak)
8186                         value = h->root.u.def.value;
8187                       else if (h->root.type == bfd_link_hash_undefweak)
8188                         value = 0;
8189                       else
8190                         {
8191                           found_tls_get_addr_arg = 0;
8192                           continue;
8193                         }
8194                     }
8195                   else
8196                     /* Symbols referenced by TLS relocs must be of type
8197                        STT_TLS.  So no need for .opd local sym adjust.  */
8198                     value = sym->st_value;
8199
8200                   ok_tprel = FALSE;
8201                   is_local = FALSE;
8202                   if (h == NULL
8203                       || !h->def_dynamic)
8204                     {
8205                       is_local = TRUE;
8206                       if (h != NULL
8207                           && h->root.type == bfd_link_hash_undefweak)
8208                         ok_tprel = TRUE;
8209                       else
8210                         {
8211                           value += sym_sec->output_offset;
8212                           value += sym_sec->output_section->vma;
8213                           value -= htab->elf.tls_sec->vma;
8214                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8215                                       < (bfd_vma) 1 << 32);
8216                         }
8217                     }
8218
8219                   r_type = ELF64_R_TYPE (rel->r_info);
8220                   /* If this section has old-style __tls_get_addr calls
8221                      without marker relocs, then check that each
8222                      __tls_get_addr call reloc is preceded by a reloc
8223                      that conceivably belongs to the __tls_get_addr arg
8224                      setup insn.  If we don't find matching arg setup
8225                      relocs, don't do any tls optimization.  */
8226                   if (pass == 0
8227                       && sec->has_tls_get_addr_call
8228                       && h != NULL
8229                       && (h == &htab->tls_get_addr->elf
8230                           || h == &htab->tls_get_addr_fd->elf)
8231                       && !found_tls_get_addr_arg
8232                       && is_branch_reloc (r_type))
8233                     {
8234                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8235                                                 "TLS optimization disabled\n"),
8236                                               ibfd, sec, rel->r_offset);
8237                       ret = TRUE;
8238                       goto err_free_rel;
8239                     }
8240
8241                   found_tls_get_addr_arg = 0;
8242                   switch (r_type)
8243                     {
8244                     case R_PPC64_GOT_TLSLD16:
8245                     case R_PPC64_GOT_TLSLD16_LO:
8246                       expecting_tls_get_addr = 1;
8247                       found_tls_get_addr_arg = 1;
8248                       /* Fall thru */
8249
8250                     case R_PPC64_GOT_TLSLD16_HI:
8251                     case R_PPC64_GOT_TLSLD16_HA:
8252                       /* These relocs should never be against a symbol
8253                          defined in a shared lib.  Leave them alone if
8254                          that turns out to be the case.  */
8255                       if (!is_local)
8256                         continue;
8257
8258                       /* LD -> LE */
8259                       tls_set = 0;
8260                       tls_clear = TLS_LD;
8261                       tls_type = TLS_TLS | TLS_LD;
8262                       break;
8263
8264                     case R_PPC64_GOT_TLSGD16:
8265                     case R_PPC64_GOT_TLSGD16_LO:
8266                       expecting_tls_get_addr = 1;
8267                       found_tls_get_addr_arg = 1;
8268                       /* Fall thru */
8269
8270                     case R_PPC64_GOT_TLSGD16_HI:
8271                     case R_PPC64_GOT_TLSGD16_HA:
8272                       if (ok_tprel)
8273                         /* GD -> LE */
8274                         tls_set = 0;
8275                       else
8276                         /* GD -> IE */
8277                         tls_set = TLS_TLS | TLS_TPRELGD;
8278                       tls_clear = TLS_GD;
8279                       tls_type = TLS_TLS | TLS_GD;
8280                       break;
8281
8282                     case R_PPC64_GOT_TPREL16_DS:
8283                     case R_PPC64_GOT_TPREL16_LO_DS:
8284                     case R_PPC64_GOT_TPREL16_HI:
8285                     case R_PPC64_GOT_TPREL16_HA:
8286                       if (ok_tprel)
8287                         {
8288                           /* IE -> LE */
8289                           tls_set = 0;
8290                           tls_clear = TLS_TPREL;
8291                           tls_type = TLS_TLS | TLS_TPREL;
8292                           break;
8293                         }
8294                       continue;
8295
8296                     case R_PPC64_TLSGD:
8297                     case R_PPC64_TLSLD:
8298                       found_tls_get_addr_arg = 1;
8299                       /* Fall thru */
8300
8301                     case R_PPC64_TLS:
8302                     case R_PPC64_TOC16:
8303                     case R_PPC64_TOC16_LO:
8304                       if (sym_sec == NULL || sym_sec != toc)
8305                         continue;
8306
8307                       /* Mark this toc entry as referenced by a TLS
8308                          code sequence.  We can do that now in the
8309                          case of R_PPC64_TLS, and after checking for
8310                          tls_get_addr for the TOC16 relocs.  */
8311                       if (toc_ref == NULL)
8312                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8313                       if (toc_ref == NULL)
8314                         goto err_free_rel;
8315
8316                       if (h != NULL)
8317                         value = h->root.u.def.value;
8318                       else
8319                         value = sym->st_value;
8320                       value += rel->r_addend;
8321                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8322                       toc_ref_index = (value + toc->output_offset) / 8;
8323                       if (r_type == R_PPC64_TLS
8324                           || r_type == R_PPC64_TLSGD
8325                           || r_type == R_PPC64_TLSLD)
8326                         {
8327                           toc_ref[toc_ref_index] = 1;
8328                           continue;
8329                         }
8330
8331                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8332                         continue;
8333
8334                       tls_set = 0;
8335                       tls_clear = 0;
8336                       expecting_tls_get_addr = 2;
8337                       break;
8338
8339                     case R_PPC64_TPREL64:
8340                       if (pass == 0
8341                           || sec != toc
8342                           || toc_ref == NULL
8343                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8344                         continue;
8345                       if (ok_tprel)
8346                         {
8347                           /* IE -> LE */
8348                           tls_set = TLS_EXPLICIT;
8349                           tls_clear = TLS_TPREL;
8350                           break;
8351                         }
8352                       continue;
8353
8354                     case R_PPC64_DTPMOD64:
8355                       if (pass == 0
8356                           || sec != toc
8357                           || toc_ref == NULL
8358                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8359                         continue;
8360                       if (rel + 1 < relend
8361                           && (rel[1].r_info
8362                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8363                           && rel[1].r_offset == rel->r_offset + 8)
8364                         {
8365                           if (ok_tprel)
8366                             /* GD -> LE */
8367                             tls_set = TLS_EXPLICIT | TLS_GD;
8368                           else
8369                             /* GD -> IE */
8370                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8371                           tls_clear = TLS_GD;
8372                         }
8373                       else
8374                         {
8375                           if (!is_local)
8376                             continue;
8377
8378                           /* LD -> LE */
8379                           tls_set = TLS_EXPLICIT;
8380                           tls_clear = TLS_LD;
8381                         }
8382                       break;
8383
8384                     default:
8385                       continue;
8386                     }
8387
8388                   if (pass == 0)
8389                     {
8390                       if (!expecting_tls_get_addr
8391                           || !sec->has_tls_get_addr_call)
8392                         continue;
8393
8394                       if (rel + 1 < relend
8395                           && branch_reloc_hash_match (ibfd, rel + 1,
8396                                                       htab->tls_get_addr,
8397                                                       htab->tls_get_addr_fd))
8398                         {
8399                           if (expecting_tls_get_addr == 2)
8400                             {
8401                               /* Check for toc tls entries.  */
8402                               unsigned char *toc_tls;
8403                               int retval;
8404
8405                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8406                                                      &locsyms,
8407                                                      rel, ibfd);
8408                               if (retval == 0)
8409                                 goto err_free_rel;
8410                               if (toc_tls != NULL)
8411                                 {
8412                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8413                                     found_tls_get_addr_arg = 1;
8414                                   if (retval > 1)
8415                                     toc_ref[toc_ref_index] = 1;
8416                                 }
8417                             }
8418                           continue;
8419                         }
8420
8421                       if (expecting_tls_get_addr != 1)
8422                         continue;
8423
8424                       /* Uh oh, we didn't find the expected call.  We
8425                          could just mark this symbol to exclude it
8426                          from tls optimization but it's safer to skip
8427                          the entire optimization.  */
8428                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8429                                                 "TLS optimization disabled\n"),
8430                                               ibfd, sec, rel->r_offset);
8431                       ret = TRUE;
8432                       goto err_free_rel;
8433                     }
8434
8435                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8436                     {
8437                       struct plt_entry *ent;
8438                       for (ent = htab->tls_get_addr->elf.plt.plist;
8439                            ent != NULL;
8440                            ent = ent->next)
8441                         if (ent->addend == 0)
8442                           {
8443                             if (ent->plt.refcount > 0)
8444                               {
8445                                 ent->plt.refcount -= 1;
8446                                 expecting_tls_get_addr = 0;
8447                               }
8448                             break;
8449                           }
8450                     }
8451
8452                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8453                     {
8454                       struct plt_entry *ent;
8455                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8456                            ent != NULL;
8457                            ent = ent->next)
8458                         if (ent->addend == 0)
8459                           {
8460                             if (ent->plt.refcount > 0)
8461                               ent->plt.refcount -= 1;
8462                             break;
8463                           }
8464                     }
8465
8466                   if (tls_clear == 0)
8467                     continue;
8468
8469                   if ((tls_set & TLS_EXPLICIT) == 0)
8470                     {
8471                       struct got_entry *ent;
8472
8473                       /* Adjust got entry for this reloc.  */
8474                       if (h != NULL)
8475                         ent = h->got.glist;
8476                       else
8477                         ent = elf_local_got_ents (ibfd)[r_symndx];
8478
8479                       for (; ent != NULL; ent = ent->next)
8480                         if (ent->addend == rel->r_addend
8481                             && ent->owner == ibfd
8482                             && ent->tls_type == tls_type)
8483                           break;
8484                       if (ent == NULL)
8485                         abort ();
8486
8487                       if (tls_set == 0)
8488                         {
8489                           /* We managed to get rid of a got entry.  */
8490                           if (ent->got.refcount > 0)
8491                             ent->got.refcount -= 1;
8492                         }
8493                     }
8494                   else
8495                     {
8496                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8497                          we'll lose one or two dyn relocs.  */
8498                       if (!dec_dynrel_count (rel->r_info, sec, info,
8499                                              NULL, h, sym))
8500                         return FALSE;
8501
8502                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8503                         {
8504                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8505                                                  NULL, h, sym))
8506                             return FALSE;
8507                         }
8508                     }
8509
8510                   *tls_mask |= tls_set;
8511                   *tls_mask &= ~tls_clear;
8512                 }
8513
8514               if (elf_section_data (sec)->relocs != relstart)
8515                 free (relstart);
8516             }
8517
8518         if (locsyms != NULL
8519             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8520           {
8521             if (!info->keep_memory)
8522               free (locsyms);
8523             else
8524               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8525           }
8526       }
8527
8528   if (toc_ref != NULL)
8529     free (toc_ref);
8530   return TRUE;
8531 }
8532
8533 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8534    the values of any global symbols in a toc section that has been
8535    edited.  Globals in toc sections should be a rarity, so this function
8536    sets a flag if any are found in toc sections other than the one just
8537    edited, so that futher hash table traversals can be avoided.  */
8538
8539 struct adjust_toc_info
8540 {
8541   asection *toc;
8542   unsigned long *skip;
8543   bfd_boolean global_toc_syms;
8544 };
8545
8546 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8547
8548 static bfd_boolean
8549 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8550 {
8551   struct ppc_link_hash_entry *eh;
8552   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8553   unsigned long i;
8554
8555   if (h->root.type != bfd_link_hash_defined
8556       && h->root.type != bfd_link_hash_defweak)
8557     return TRUE;
8558
8559   eh = (struct ppc_link_hash_entry *) h;
8560   if (eh->adjust_done)
8561     return TRUE;
8562
8563   if (eh->elf.root.u.def.section == toc_inf->toc)
8564     {
8565       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8566         i = toc_inf->toc->rawsize >> 3;
8567       else
8568         i = eh->elf.root.u.def.value >> 3;
8569
8570       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8571         {
8572           (*_bfd_error_handler)
8573             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8574           do
8575             ++i;
8576           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8577           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8578         }
8579
8580       eh->elf.root.u.def.value -= toc_inf->skip[i];
8581       eh->adjust_done = 1;
8582     }
8583   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8584     toc_inf->global_toc_syms = TRUE;
8585
8586   return TRUE;
8587 }
8588
8589 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8590
8591 static bfd_boolean
8592 ok_lo_toc_insn (unsigned int insn)
8593 {
8594   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8595           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8596           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8597           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8598           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8599           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8600           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8601           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8602           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8603           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8604           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8605           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8606           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8607           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8608           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8609               && (insn & 3) != 1)
8610           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8611               && ((insn & 3) == 0 || (insn & 3) == 3))
8612           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8613 }
8614
8615 /* Examine all relocs referencing .toc sections in order to remove
8616    unused .toc entries.  */
8617
8618 bfd_boolean
8619 ppc64_elf_edit_toc (struct bfd_link_info *info)
8620 {
8621   bfd *ibfd;
8622   struct adjust_toc_info toc_inf;
8623   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8624
8625   htab->do_toc_opt = 1;
8626   toc_inf.global_toc_syms = TRUE;
8627   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8628     {
8629       asection *toc, *sec;
8630       Elf_Internal_Shdr *symtab_hdr;
8631       Elf_Internal_Sym *local_syms;
8632       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8633       unsigned long *skip, *drop;
8634       unsigned char *used;
8635       unsigned char *keep, last, some_unused;
8636
8637       if (!is_ppc64_elf (ibfd))
8638         continue;
8639
8640       toc = bfd_get_section_by_name (ibfd, ".toc");
8641       if (toc == NULL
8642           || toc->size == 0
8643           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8644           || discarded_section (toc))
8645         continue;
8646
8647       toc_relocs = NULL;
8648       local_syms = NULL;
8649       symtab_hdr = &elf_symtab_hdr (ibfd);
8650
8651       /* Look at sections dropped from the final link.  */
8652       skip = NULL;
8653       relstart = NULL;
8654       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8655         {
8656           if (sec->reloc_count == 0
8657               || !discarded_section (sec)
8658               || get_opd_info (sec)
8659               || (sec->flags & SEC_ALLOC) == 0
8660               || (sec->flags & SEC_DEBUGGING) != 0)
8661             continue;
8662
8663           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8664           if (relstart == NULL)
8665             goto error_ret;
8666
8667           /* Run through the relocs to see which toc entries might be
8668              unused.  */
8669           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8670             {
8671               enum elf_ppc64_reloc_type r_type;
8672               unsigned long r_symndx;
8673               asection *sym_sec;
8674               struct elf_link_hash_entry *h;
8675               Elf_Internal_Sym *sym;
8676               bfd_vma val;
8677
8678               r_type = ELF64_R_TYPE (rel->r_info);
8679               switch (r_type)
8680                 {
8681                 default:
8682                   continue;
8683
8684                 case R_PPC64_TOC16:
8685                 case R_PPC64_TOC16_LO:
8686                 case R_PPC64_TOC16_HI:
8687                 case R_PPC64_TOC16_HA:
8688                 case R_PPC64_TOC16_DS:
8689                 case R_PPC64_TOC16_LO_DS:
8690                   break;
8691                 }
8692
8693               r_symndx = ELF64_R_SYM (rel->r_info);
8694               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8695                               r_symndx, ibfd))
8696                 goto error_ret;
8697
8698               if (sym_sec != toc)
8699                 continue;
8700
8701               if (h != NULL)
8702                 val = h->root.u.def.value;
8703               else
8704                 val = sym->st_value;
8705               val += rel->r_addend;
8706
8707               if (val >= toc->size)
8708                 continue;
8709
8710               /* Anything in the toc ought to be aligned to 8 bytes.
8711                  If not, don't mark as unused.  */
8712               if (val & 7)
8713                 continue;
8714
8715               if (skip == NULL)
8716                 {
8717                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8718                   if (skip == NULL)
8719                     goto error_ret;
8720                 }
8721
8722               skip[val >> 3] = ref_from_discarded;
8723             }
8724
8725           if (elf_section_data (sec)->relocs != relstart)
8726             free (relstart);
8727         }
8728
8729       /* For largetoc loads of address constants, we can convert
8730          .  addis rx,2,addr@got@ha
8731          .  ld ry,addr@got@l(rx)
8732          to
8733          .  addis rx,2,addr@toc@ha
8734          .  addi ry,rx,addr@toc@l
8735          when addr is within 2G of the toc pointer.  This then means
8736          that the word storing "addr" in the toc is no longer needed.  */
8737
8738       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8739           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8740           && toc->reloc_count != 0)
8741         {
8742           /* Read toc relocs.  */
8743           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8744                                                   info->keep_memory);
8745           if (toc_relocs == NULL)
8746             goto error_ret;
8747
8748           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8749             {
8750               enum elf_ppc64_reloc_type r_type;
8751               unsigned long r_symndx;
8752               asection *sym_sec;
8753               struct elf_link_hash_entry *h;
8754               Elf_Internal_Sym *sym;
8755               bfd_vma val, addr;
8756
8757               r_type = ELF64_R_TYPE (rel->r_info);
8758               if (r_type != R_PPC64_ADDR64)
8759                 continue;
8760
8761               r_symndx = ELF64_R_SYM (rel->r_info);
8762               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8763                               r_symndx, ibfd))
8764                 goto error_ret;
8765
8766               if (sym_sec == NULL
8767                   || discarded_section (sym_sec))
8768                 continue;
8769
8770               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8771                 continue;
8772
8773               if (h != NULL)
8774                 {
8775                   if (h->type == STT_GNU_IFUNC)
8776                     continue;
8777                   val = h->root.u.def.value;
8778                 }
8779               else
8780                 {
8781                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8782                     continue;
8783                   val = sym->st_value;
8784                 }
8785               val += rel->r_addend;
8786               val += sym_sec->output_section->vma + sym_sec->output_offset;
8787
8788               /* We don't yet know the exact toc pointer value, but we
8789                  know it will be somewhere in the toc section.  Don't
8790                  optimize if the difference from any possible toc
8791                  pointer is outside [ff..f80008000, 7fff7fff].  */
8792               addr = toc->output_section->vma + TOC_BASE_OFF;
8793               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8794                 continue;
8795
8796               addr = toc->output_section->vma + toc->output_section->rawsize;
8797               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8798                 continue;
8799
8800               if (skip == NULL)
8801                 {
8802                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8803                   if (skip == NULL)
8804                     goto error_ret;
8805                 }
8806
8807               skip[rel->r_offset >> 3]
8808                 |= can_optimize | ((rel - toc_relocs) << 2);
8809             }
8810         }
8811
8812       if (skip == NULL)
8813         continue;
8814
8815       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8816       if (used == NULL)
8817         {
8818         error_ret:
8819           if (local_syms != NULL
8820               && symtab_hdr->contents != (unsigned char *) local_syms)
8821             free (local_syms);
8822           if (sec != NULL
8823               && relstart != NULL
8824               && elf_section_data (sec)->relocs != relstart)
8825             free (relstart);
8826           if (toc_relocs != NULL
8827               && elf_section_data (toc)->relocs != toc_relocs)
8828             free (toc_relocs);
8829           if (skip != NULL)
8830             free (skip);
8831           return FALSE;
8832         }
8833
8834       /* Now check all kept sections that might reference the toc.
8835          Check the toc itself last.  */
8836       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8837                   : ibfd->sections);
8838            sec != NULL;
8839            sec = (sec == toc ? NULL
8840                   : sec->next == NULL ? toc
8841                   : sec->next == toc && toc->next ? toc->next
8842                   : sec->next))
8843         {
8844           int repeat;
8845
8846           if (sec->reloc_count == 0
8847               || discarded_section (sec)
8848               || get_opd_info (sec)
8849               || (sec->flags & SEC_ALLOC) == 0
8850               || (sec->flags & SEC_DEBUGGING) != 0)
8851             continue;
8852
8853           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8854                                                 info->keep_memory);
8855           if (relstart == NULL)
8856             {
8857               free (used);
8858               goto error_ret;
8859             }
8860
8861           /* Mark toc entries referenced as used.  */
8862           do
8863             {
8864               repeat = 0;
8865               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8866                 {
8867                   enum elf_ppc64_reloc_type r_type;
8868                   unsigned long r_symndx;
8869                   asection *sym_sec;
8870                   struct elf_link_hash_entry *h;
8871                   Elf_Internal_Sym *sym;
8872                   bfd_vma val;
8873                   enum {no_check, check_lo, check_ha} insn_check;
8874
8875                   r_type = ELF64_R_TYPE (rel->r_info);
8876                   switch (r_type)
8877                     {
8878                     default:
8879                       insn_check = no_check;
8880                       break;
8881
8882                     case R_PPC64_GOT_TLSLD16_HA:
8883                     case R_PPC64_GOT_TLSGD16_HA:
8884                     case R_PPC64_GOT_TPREL16_HA:
8885                     case R_PPC64_GOT_DTPREL16_HA:
8886                     case R_PPC64_GOT16_HA:
8887                     case R_PPC64_TOC16_HA:
8888                       insn_check = check_ha;
8889                       break;
8890
8891                     case R_PPC64_GOT_TLSLD16_LO:
8892                     case R_PPC64_GOT_TLSGD16_LO:
8893                     case R_PPC64_GOT_TPREL16_LO_DS:
8894                     case R_PPC64_GOT_DTPREL16_LO_DS:
8895                     case R_PPC64_GOT16_LO:
8896                     case R_PPC64_GOT16_LO_DS:
8897                     case R_PPC64_TOC16_LO:
8898                     case R_PPC64_TOC16_LO_DS:
8899                       insn_check = check_lo;
8900                       break;
8901                     }
8902
8903                   if (insn_check != no_check)
8904                     {
8905                       bfd_vma off = rel->r_offset & ~3;
8906                       unsigned char buf[4];
8907                       unsigned int insn;
8908
8909                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8910                         {
8911                           free (used);
8912                           goto error_ret;
8913                         }
8914                       insn = bfd_get_32 (ibfd, buf);
8915                       if (insn_check == check_lo
8916                           ? !ok_lo_toc_insn (insn)
8917                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8918                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8919                         {
8920                           char str[12];
8921
8922                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8923                           sprintf (str, "%#08x", insn);
8924                           info->callbacks->einfo
8925                             (_("%P: %H: toc optimization is not supported for"
8926                                " %s instruction.\n"),
8927                              ibfd, sec, rel->r_offset & ~3, str);
8928                         }
8929                     }
8930
8931                   switch (r_type)
8932                     {
8933                     case R_PPC64_TOC16:
8934                     case R_PPC64_TOC16_LO:
8935                     case R_PPC64_TOC16_HI:
8936                     case R_PPC64_TOC16_HA:
8937                     case R_PPC64_TOC16_DS:
8938                     case R_PPC64_TOC16_LO_DS:
8939                       /* In case we're taking addresses of toc entries.  */
8940                     case R_PPC64_ADDR64:
8941                       break;
8942
8943                     default:
8944                       continue;
8945                     }
8946
8947                   r_symndx = ELF64_R_SYM (rel->r_info);
8948                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8949                                   r_symndx, ibfd))
8950                     {
8951                       free (used);
8952                       goto error_ret;
8953                     }
8954
8955                   if (sym_sec != toc)
8956                     continue;
8957
8958                   if (h != NULL)
8959                     val = h->root.u.def.value;
8960                   else
8961                     val = sym->st_value;
8962                   val += rel->r_addend;
8963
8964                   if (val >= toc->size)
8965                     continue;
8966
8967                   if ((skip[val >> 3] & can_optimize) != 0)
8968                     {
8969                       bfd_vma off;
8970                       unsigned char opc;
8971
8972                       switch (r_type)
8973                         {
8974                         case R_PPC64_TOC16_HA:
8975                           break;
8976
8977                         case R_PPC64_TOC16_LO_DS:
8978                           off = rel->r_offset;
8979                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8980                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8981                                                          off, 1))
8982                             {
8983                               free (used);
8984                               goto error_ret;
8985                             }
8986                           if ((opc & (0x3f << 2)) == (58u << 2))
8987                             break;
8988                           /* Fall thru */
8989
8990                         default:
8991                           /* Wrong sort of reloc, or not a ld.  We may
8992                              as well clear ref_from_discarded too.  */
8993                           skip[val >> 3] = 0;
8994                         }
8995                     }
8996
8997                   if (sec != toc)
8998                     used[val >> 3] = 1;
8999                   /* For the toc section, we only mark as used if this
9000                      entry itself isn't unused.  */
9001                   else if ((used[rel->r_offset >> 3]
9002                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9003                            && !used[val >> 3])
9004                     {
9005                       /* Do all the relocs again, to catch reference
9006                          chains.  */
9007                       repeat = 1;
9008                       used[val >> 3] = 1;
9009                     }
9010                 }
9011             }
9012           while (repeat);
9013
9014           if (elf_section_data (sec)->relocs != relstart)
9015             free (relstart);
9016         }
9017
9018       /* Merge the used and skip arrays.  Assume that TOC
9019          doublewords not appearing as either used or unused belong
9020          to to an entry more than one doubleword in size.  */
9021       for (drop = skip, keep = used, last = 0, some_unused = 0;
9022            drop < skip + (toc->size + 7) / 8;
9023            ++drop, ++keep)
9024         {
9025           if (*keep)
9026             {
9027               *drop &= ~ref_from_discarded;
9028               if ((*drop & can_optimize) != 0)
9029                 some_unused = 1;
9030               last = 0;
9031             }
9032           else if ((*drop & ref_from_discarded) != 0)
9033             {
9034               some_unused = 1;
9035               last = ref_from_discarded;
9036             }
9037           else
9038             *drop = last;
9039         }
9040
9041       free (used);
9042
9043       if (some_unused)
9044         {
9045           bfd_byte *contents, *src;
9046           unsigned long off;
9047           Elf_Internal_Sym *sym;
9048           bfd_boolean local_toc_syms = FALSE;
9049
9050           /* Shuffle the toc contents, and at the same time convert the
9051              skip array from booleans into offsets.  */
9052           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9053             goto error_ret;
9054
9055           elf_section_data (toc)->this_hdr.contents = contents;
9056
9057           for (src = contents, off = 0, drop = skip;
9058                src < contents + toc->size;
9059                src += 8, ++drop)
9060             {
9061               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9062                 off += 8;
9063               else if (off != 0)
9064                 {
9065                   *drop = off;
9066                   memcpy (src - off, src, 8);
9067                 }
9068             }
9069           *drop = off;
9070           toc->rawsize = toc->size;
9071           toc->size = src - contents - off;
9072
9073           /* Adjust addends for relocs against the toc section sym,
9074              and optimize any accesses we can.  */
9075           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9076             {
9077               if (sec->reloc_count == 0
9078                   || discarded_section (sec))
9079                 continue;
9080
9081               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9082                                                     info->keep_memory);
9083               if (relstart == NULL)
9084                 goto error_ret;
9085
9086               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9087                 {
9088                   enum elf_ppc64_reloc_type r_type;
9089                   unsigned long r_symndx;
9090                   asection *sym_sec;
9091                   struct elf_link_hash_entry *h;
9092                   bfd_vma val;
9093
9094                   r_type = ELF64_R_TYPE (rel->r_info);
9095                   switch (r_type)
9096                     {
9097                     default:
9098                       continue;
9099
9100                     case R_PPC64_TOC16:
9101                     case R_PPC64_TOC16_LO:
9102                     case R_PPC64_TOC16_HI:
9103                     case R_PPC64_TOC16_HA:
9104                     case R_PPC64_TOC16_DS:
9105                     case R_PPC64_TOC16_LO_DS:
9106                     case R_PPC64_ADDR64:
9107                       break;
9108                     }
9109
9110                   r_symndx = ELF64_R_SYM (rel->r_info);
9111                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9112                                   r_symndx, ibfd))
9113                     goto error_ret;
9114
9115                   if (sym_sec != toc)
9116                     continue;
9117
9118                   if (h != NULL)
9119                     val = h->root.u.def.value;
9120                   else
9121                     {
9122                       val = sym->st_value;
9123                       if (val != 0)
9124                         local_toc_syms = TRUE;
9125                     }
9126
9127                   val += rel->r_addend;
9128
9129                   if (val > toc->rawsize)
9130                     val = toc->rawsize;
9131                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9132                     continue;
9133                   else if ((skip[val >> 3] & can_optimize) != 0)
9134                     {
9135                       Elf_Internal_Rela *tocrel
9136                         = toc_relocs + (skip[val >> 3] >> 2);
9137                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9138
9139                       switch (r_type)
9140                         {
9141                         case R_PPC64_TOC16_HA:
9142                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9143                           break;
9144
9145                         case R_PPC64_TOC16_LO_DS:
9146                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9147                           break;
9148
9149                         default:
9150                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9151                             ppc_howto_init ();
9152                           info->callbacks->einfo
9153                             (_("%P: %H: %s references "
9154                                "optimized away TOC entry\n"),
9155                              ibfd, sec, rel->r_offset,
9156                              ppc64_elf_howto_table[r_type]->name);
9157                           bfd_set_error (bfd_error_bad_value);
9158                           goto error_ret;
9159                         }
9160                       rel->r_addend = tocrel->r_addend;
9161                       elf_section_data (sec)->relocs = relstart;
9162                       continue;
9163                     }
9164
9165                   if (h != NULL || sym->st_value != 0)
9166                     continue;
9167
9168                   rel->r_addend -= skip[val >> 3];
9169                   elf_section_data (sec)->relocs = relstart;
9170                 }
9171
9172               if (elf_section_data (sec)->relocs != relstart)
9173                 free (relstart);
9174             }
9175
9176           /* We shouldn't have local or global symbols defined in the TOC,
9177              but handle them anyway.  */
9178           if (local_syms != NULL)
9179             for (sym = local_syms;
9180                  sym < local_syms + symtab_hdr->sh_info;
9181                  ++sym)
9182               if (sym->st_value != 0
9183                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9184                 {
9185                   unsigned long i;
9186
9187                   if (sym->st_value > toc->rawsize)
9188                     i = toc->rawsize >> 3;
9189                   else
9190                     i = sym->st_value >> 3;
9191
9192                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9193                     {
9194                       if (local_toc_syms)
9195                         (*_bfd_error_handler)
9196                           (_("%s defined on removed toc entry"),
9197                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9198                       do
9199                         ++i;
9200                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9201                       sym->st_value = (bfd_vma) i << 3;
9202                     }
9203
9204                   sym->st_value -= skip[i];
9205                   symtab_hdr->contents = (unsigned char *) local_syms;
9206                 }
9207
9208           /* Adjust any global syms defined in this toc input section.  */
9209           if (toc_inf.global_toc_syms)
9210             {
9211               toc_inf.toc = toc;
9212               toc_inf.skip = skip;
9213               toc_inf.global_toc_syms = FALSE;
9214               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9215                                       &toc_inf);
9216             }
9217
9218           if (toc->reloc_count != 0)
9219             {
9220               Elf_Internal_Shdr *rel_hdr;
9221               Elf_Internal_Rela *wrel;
9222               bfd_size_type sz;
9223
9224               /* Remove unused toc relocs, and adjust those we keep.  */
9225               if (toc_relocs == NULL)
9226                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9227                                                         info->keep_memory);
9228               if (toc_relocs == NULL)
9229                 goto error_ret;
9230
9231               wrel = toc_relocs;
9232               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9233                 if ((skip[rel->r_offset >> 3]
9234                      & (ref_from_discarded | can_optimize)) == 0)
9235                   {
9236                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9237                     wrel->r_info = rel->r_info;
9238                     wrel->r_addend = rel->r_addend;
9239                     ++wrel;
9240                   }
9241                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9242                                             &local_syms, NULL, NULL))
9243                   goto error_ret;
9244
9245               elf_section_data (toc)->relocs = toc_relocs;
9246               toc->reloc_count = wrel - toc_relocs;
9247               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9248               sz = rel_hdr->sh_entsize;
9249               rel_hdr->sh_size = toc->reloc_count * sz;
9250             }
9251         }
9252       else if (toc_relocs != NULL
9253                && elf_section_data (toc)->relocs != toc_relocs)
9254         free (toc_relocs);
9255
9256       if (local_syms != NULL
9257           && symtab_hdr->contents != (unsigned char *) local_syms)
9258         {
9259           if (!info->keep_memory)
9260             free (local_syms);
9261           else
9262             symtab_hdr->contents = (unsigned char *) local_syms;
9263         }
9264       free (skip);
9265     }
9266
9267   return TRUE;
9268 }
9269
9270 /* Return true iff input section I references the TOC using
9271    instructions limited to +/-32k offsets.  */
9272
9273 bfd_boolean
9274 ppc64_elf_has_small_toc_reloc (asection *i)
9275 {
9276   return (is_ppc64_elf (i->owner)
9277           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9278 }
9279
9280 /* Allocate space for one GOT entry.  */
9281
9282 static void
9283 allocate_got (struct elf_link_hash_entry *h,
9284               struct bfd_link_info *info,
9285               struct got_entry *gent)
9286 {
9287   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9288   bfd_boolean dyn;
9289   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9290   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9291                  ? 16 : 8);
9292   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9293                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9294   asection *got = ppc64_elf_tdata (gent->owner)->got;
9295
9296   gent->got.offset = got->size;
9297   got->size += entsize;
9298
9299   dyn = htab->elf.dynamic_sections_created;
9300   if (h->type == STT_GNU_IFUNC)
9301     {
9302       htab->elf.irelplt->size += rentsize;
9303       htab->got_reli_size += rentsize;
9304     }
9305   else if ((info->shared
9306             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9307            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9308                || h->root.type != bfd_link_hash_undefweak))
9309     {
9310       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9311       relgot->size += rentsize;
9312     }
9313 }
9314
9315 /* This function merges got entries in the same toc group.  */
9316
9317 static void
9318 merge_got_entries (struct got_entry **pent)
9319 {
9320   struct got_entry *ent, *ent2;
9321
9322   for (ent = *pent; ent != NULL; ent = ent->next)
9323     if (!ent->is_indirect)
9324       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9325         if (!ent2->is_indirect
9326             && ent2->addend == ent->addend
9327             && ent2->tls_type == ent->tls_type
9328             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9329           {
9330             ent2->is_indirect = TRUE;
9331             ent2->got.ent = ent;
9332           }
9333 }
9334
9335 /* Allocate space in .plt, .got and associated reloc sections for
9336    dynamic relocs.  */
9337
9338 static bfd_boolean
9339 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9340 {
9341   struct bfd_link_info *info;
9342   struct ppc_link_hash_table *htab;
9343   asection *s;
9344   struct ppc_link_hash_entry *eh;
9345   struct elf_dyn_relocs *p;
9346   struct got_entry **pgent, *gent;
9347
9348   if (h->root.type == bfd_link_hash_indirect)
9349     return TRUE;
9350
9351   info = (struct bfd_link_info *) inf;
9352   htab = ppc_hash_table (info);
9353   if (htab == NULL)
9354     return FALSE;
9355
9356   if ((htab->elf.dynamic_sections_created
9357        && h->dynindx != -1
9358        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9359       || h->type == STT_GNU_IFUNC)
9360     {
9361       struct plt_entry *pent;
9362       bfd_boolean doneone = FALSE;
9363       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9364         if (pent->plt.refcount > 0)
9365           {
9366             if (!htab->elf.dynamic_sections_created
9367                 || h->dynindx == -1)
9368               {
9369                 s = htab->elf.iplt;
9370                 pent->plt.offset = s->size;
9371                 s->size += PLT_ENTRY_SIZE (htab);
9372                 s = htab->elf.irelplt;
9373               }
9374             else
9375               {
9376                 /* If this is the first .plt entry, make room for the special
9377                    first entry.  */
9378                 s = htab->elf.splt;
9379                 if (s->size == 0)
9380                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9381
9382                 pent->plt.offset = s->size;
9383
9384                 /* Make room for this entry.  */
9385                 s->size += PLT_ENTRY_SIZE (htab);
9386
9387                 /* Make room for the .glink code.  */
9388                 s = htab->glink;
9389                 if (s->size == 0)
9390                   s->size += GLINK_CALL_STUB_SIZE;
9391                 if (htab->opd_abi)
9392                   {
9393                     /* We need bigger stubs past index 32767.  */
9394                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9395                       s->size += 4;
9396                     s->size += 2*4;
9397                   }
9398                 else
9399                   s->size += 4;
9400
9401                 /* We also need to make an entry in the .rela.plt section.  */
9402                 s = htab->elf.srelplt;
9403               }
9404             s->size += sizeof (Elf64_External_Rela);
9405             doneone = TRUE;
9406           }
9407         else
9408           pent->plt.offset = (bfd_vma) -1;
9409       if (!doneone)
9410         {
9411           h->plt.plist = NULL;
9412           h->needs_plt = 0;
9413         }
9414     }
9415   else
9416     {
9417       h->plt.plist = NULL;
9418       h->needs_plt = 0;
9419     }
9420
9421   eh = (struct ppc_link_hash_entry *) h;
9422   /* Run through the TLS GD got entries first if we're changing them
9423      to TPREL.  */
9424   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9425     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9426       if (gent->got.refcount > 0
9427           && (gent->tls_type & TLS_GD) != 0)
9428         {
9429           /* This was a GD entry that has been converted to TPREL.  If
9430              there happens to be a TPREL entry we can use that one.  */
9431           struct got_entry *ent;
9432           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9433             if (ent->got.refcount > 0
9434                 && (ent->tls_type & TLS_TPREL) != 0
9435                 && ent->addend == gent->addend
9436                 && ent->owner == gent->owner)
9437               {
9438                 gent->got.refcount = 0;
9439                 break;
9440               }
9441
9442           /* If not, then we'll be using our own TPREL entry.  */
9443           if (gent->got.refcount != 0)
9444             gent->tls_type = TLS_TLS | TLS_TPREL;
9445         }
9446
9447   /* Remove any list entry that won't generate a word in the GOT before
9448      we call merge_got_entries.  Otherwise we risk merging to empty
9449      entries.  */
9450   pgent = &h->got.glist;
9451   while ((gent = *pgent) != NULL)
9452     if (gent->got.refcount > 0)
9453       {
9454         if ((gent->tls_type & TLS_LD) != 0
9455             && !h->def_dynamic)
9456           {
9457             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9458             *pgent = gent->next;
9459           }
9460         else
9461           pgent = &gent->next;
9462       }
9463     else
9464       *pgent = gent->next;
9465
9466   if (!htab->do_multi_toc)
9467     merge_got_entries (&h->got.glist);
9468
9469   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9470     if (!gent->is_indirect)
9471       {
9472         /* Make sure this symbol is output as a dynamic symbol.
9473            Undefined weak syms won't yet be marked as dynamic,
9474            nor will all TLS symbols.  */
9475         if (h->dynindx == -1
9476             && !h->forced_local
9477             && h->type != STT_GNU_IFUNC
9478             && htab->elf.dynamic_sections_created)
9479           {
9480             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9481               return FALSE;
9482           }
9483
9484         if (!is_ppc64_elf (gent->owner))
9485           abort ();
9486
9487         allocate_got (h, info, gent);
9488       }
9489
9490   if (eh->dyn_relocs == NULL
9491       || (!htab->elf.dynamic_sections_created
9492           && h->type != STT_GNU_IFUNC))
9493     return TRUE;
9494
9495   /* In the shared -Bsymbolic case, discard space allocated for
9496      dynamic pc-relative relocs against symbols which turn out to be
9497      defined in regular objects.  For the normal shared case, discard
9498      space for relocs that have become local due to symbol visibility
9499      changes.  */
9500
9501   if (info->shared)
9502     {
9503       /* Relocs that use pc_count are those that appear on a call insn,
9504          or certain REL relocs (see must_be_dyn_reloc) that can be
9505          generated via assembly.  We want calls to protected symbols to
9506          resolve directly to the function rather than going via the plt.
9507          If people want function pointer comparisons to work as expected
9508          then they should avoid writing weird assembly.  */
9509       if (SYMBOL_CALLS_LOCAL (info, h))
9510         {
9511           struct elf_dyn_relocs **pp;
9512
9513           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9514             {
9515               p->count -= p->pc_count;
9516               p->pc_count = 0;
9517               if (p->count == 0)
9518                 *pp = p->next;
9519               else
9520                 pp = &p->next;
9521             }
9522         }
9523
9524       /* Also discard relocs on undefined weak syms with non-default
9525          visibility.  */
9526       if (eh->dyn_relocs != NULL
9527           && h->root.type == bfd_link_hash_undefweak)
9528         {
9529           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9530             eh->dyn_relocs = NULL;
9531
9532           /* Make sure this symbol is output as a dynamic symbol.
9533              Undefined weak syms won't yet be marked as dynamic.  */
9534           else if (h->dynindx == -1
9535                    && !h->forced_local)
9536             {
9537               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9538                 return FALSE;
9539             }
9540         }
9541     }
9542   else if (h->type == STT_GNU_IFUNC)
9543     {
9544       if (!h->non_got_ref)
9545         eh->dyn_relocs = NULL;
9546     }
9547   else if (ELIMINATE_COPY_RELOCS)
9548     {
9549       /* For the non-shared case, discard space for relocs against
9550          symbols which turn out to need copy relocs or are not
9551          dynamic.  */
9552
9553       if (!h->non_got_ref
9554           && !h->def_regular)
9555         {
9556           /* Make sure this symbol is output as a dynamic symbol.
9557              Undefined weak syms won't yet be marked as dynamic.  */
9558           if (h->dynindx == -1
9559               && !h->forced_local)
9560             {
9561               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9562                 return FALSE;
9563             }
9564
9565           /* If that succeeded, we know we'll be keeping all the
9566              relocs.  */
9567           if (h->dynindx != -1)
9568             goto keep;
9569         }
9570
9571       eh->dyn_relocs = NULL;
9572
9573     keep: ;
9574     }
9575
9576   /* Finally, allocate space.  */
9577   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9578     {
9579       asection *sreloc = elf_section_data (p->sec)->sreloc;
9580       if (eh->elf.type == STT_GNU_IFUNC)
9581         sreloc = htab->elf.irelplt;
9582       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9583     }
9584
9585   return TRUE;
9586 }
9587
9588 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9589    to set up space for global entry stubs.  These are put in glink,
9590    after the branch table.  */
9591
9592 static bfd_boolean
9593 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9594 {
9595   struct bfd_link_info *info;
9596   struct ppc_link_hash_table *htab;
9597   struct plt_entry *pent;
9598   asection *s;
9599
9600   if (h->root.type == bfd_link_hash_indirect)
9601     return TRUE;
9602
9603   if (!h->pointer_equality_needed)
9604     return TRUE;
9605
9606   if (h->def_regular)
9607     return TRUE;
9608
9609   info = inf;
9610   htab = ppc_hash_table (info);
9611   if (htab == NULL)
9612     return FALSE;
9613
9614   s = htab->glink;
9615   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9616     if (pent->plt.offset != (bfd_vma) -1
9617         && pent->addend == 0)
9618       {
9619         /* For ELFv2, if this symbol is not defined in a regular file
9620            and we are not generating a shared library or pie, then we
9621            need to define the symbol in the executable on a call stub.
9622            This is to avoid text relocations.  */
9623         s->size = (s->size + 15) & -16;
9624         h->root.u.def.section = s;
9625         h->root.u.def.value = s->size;
9626         s->size += 16;
9627         break;
9628       }
9629   return TRUE;
9630 }
9631
9632 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9633    read-only sections.  */
9634
9635 static bfd_boolean
9636 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9637 {
9638   if (h->root.type == bfd_link_hash_indirect)
9639     return TRUE;
9640
9641   if (readonly_dynrelocs (h))
9642     {
9643       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9644
9645       /* Not an error, just cut short the traversal.  */
9646       return FALSE;
9647     }
9648   return TRUE;
9649 }
9650
9651 /* Set the sizes of the dynamic sections.  */
9652
9653 static bfd_boolean
9654 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9655                                  struct bfd_link_info *info)
9656 {
9657   struct ppc_link_hash_table *htab;
9658   bfd *dynobj;
9659   asection *s;
9660   bfd_boolean relocs;
9661   bfd *ibfd;
9662   struct got_entry *first_tlsld;
9663
9664   htab = ppc_hash_table (info);
9665   if (htab == NULL)
9666     return FALSE;
9667
9668   dynobj = htab->elf.dynobj;
9669   if (dynobj == NULL)
9670     abort ();
9671
9672   if (htab->elf.dynamic_sections_created)
9673     {
9674       /* Set the contents of the .interp section to the interpreter.  */
9675       if (info->executable)
9676         {
9677           s = bfd_get_linker_section (dynobj, ".interp");
9678           if (s == NULL)
9679             abort ();
9680           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9681           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9682         }
9683     }
9684
9685   /* Set up .got offsets for local syms, and space for local dynamic
9686      relocs.  */
9687   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9688     {
9689       struct got_entry **lgot_ents;
9690       struct got_entry **end_lgot_ents;
9691       struct plt_entry **local_plt;
9692       struct plt_entry **end_local_plt;
9693       unsigned char *lgot_masks;
9694       bfd_size_type locsymcount;
9695       Elf_Internal_Shdr *symtab_hdr;
9696
9697       if (!is_ppc64_elf (ibfd))
9698         continue;
9699
9700       for (s = ibfd->sections; s != NULL; s = s->next)
9701         {
9702           struct ppc_dyn_relocs *p;
9703
9704           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9705             {
9706               if (!bfd_is_abs_section (p->sec)
9707                   && bfd_is_abs_section (p->sec->output_section))
9708                 {
9709                   /* Input section has been discarded, either because
9710                      it is a copy of a linkonce section or due to
9711                      linker script /DISCARD/, so we'll be discarding
9712                      the relocs too.  */
9713                 }
9714               else if (p->count != 0)
9715                 {
9716                   asection *srel = elf_section_data (p->sec)->sreloc;
9717                   if (p->ifunc)
9718                     srel = htab->elf.irelplt;
9719                   srel->size += p->count * sizeof (Elf64_External_Rela);
9720                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9721                     info->flags |= DF_TEXTREL;
9722                 }
9723             }
9724         }
9725
9726       lgot_ents = elf_local_got_ents (ibfd);
9727       if (!lgot_ents)
9728         continue;
9729
9730       symtab_hdr = &elf_symtab_hdr (ibfd);
9731       locsymcount = symtab_hdr->sh_info;
9732       end_lgot_ents = lgot_ents + locsymcount;
9733       local_plt = (struct plt_entry **) end_lgot_ents;
9734       end_local_plt = local_plt + locsymcount;
9735       lgot_masks = (unsigned char *) end_local_plt;
9736       s = ppc64_elf_tdata (ibfd)->got;
9737       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9738         {
9739           struct got_entry **pent, *ent;
9740
9741           pent = lgot_ents;
9742           while ((ent = *pent) != NULL)
9743             if (ent->got.refcount > 0)
9744               {
9745                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9746                   {
9747                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9748                     *pent = ent->next;
9749                   }
9750                 else
9751                   {
9752                     unsigned int ent_size = 8;
9753                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9754
9755                     ent->got.offset = s->size;
9756                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9757                       {
9758                         ent_size *= 2;
9759                         rel_size *= 2;
9760                       }
9761                     s->size += ent_size;
9762                     if ((*lgot_masks & PLT_IFUNC) != 0)
9763                       {
9764                         htab->elf.irelplt->size += rel_size;
9765                         htab->got_reli_size += rel_size;
9766                       }
9767                     else if (info->shared)
9768                       {
9769                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9770                         srel->size += rel_size;
9771                       }
9772                     pent = &ent->next;
9773                   }
9774               }
9775             else
9776               *pent = ent->next;
9777         }
9778
9779       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9780       for (; local_plt < end_local_plt; ++local_plt)
9781         {
9782           struct plt_entry *ent;
9783
9784           for (ent = *local_plt; ent != NULL; ent = ent->next)
9785             if (ent->plt.refcount > 0)
9786               {
9787                 s = htab->elf.iplt;
9788                 ent->plt.offset = s->size;
9789                 s->size += PLT_ENTRY_SIZE (htab);
9790
9791                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9792               }
9793             else
9794               ent->plt.offset = (bfd_vma) -1;
9795         }
9796     }
9797
9798   /* Allocate global sym .plt and .got entries, and space for global
9799      sym dynamic relocs.  */
9800   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9801   /* Stash the end of glink branch table.  */
9802   if (htab->glink != NULL)
9803     htab->glink->rawsize = htab->glink->size;
9804
9805   if (!htab->opd_abi && !info->shared)
9806     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9807
9808   first_tlsld = NULL;
9809   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9810     {
9811       struct got_entry *ent;
9812
9813       if (!is_ppc64_elf (ibfd))
9814         continue;
9815
9816       ent = ppc64_tlsld_got (ibfd);
9817       if (ent->got.refcount > 0)
9818         {
9819           if (!htab->do_multi_toc && first_tlsld != NULL)
9820             {
9821               ent->is_indirect = TRUE;
9822               ent->got.ent = first_tlsld;
9823             }
9824           else
9825             {
9826               if (first_tlsld == NULL)
9827                 first_tlsld = ent;
9828               s = ppc64_elf_tdata (ibfd)->got;
9829               ent->got.offset = s->size;
9830               ent->owner = ibfd;
9831               s->size += 16;
9832               if (info->shared)
9833                 {
9834                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9835                   srel->size += sizeof (Elf64_External_Rela);
9836                 }
9837             }
9838         }
9839       else
9840         ent->got.offset = (bfd_vma) -1;
9841     }
9842
9843   /* We now have determined the sizes of the various dynamic sections.
9844      Allocate memory for them.  */
9845   relocs = FALSE;
9846   for (s = dynobj->sections; s != NULL; s = s->next)
9847     {
9848       if ((s->flags & SEC_LINKER_CREATED) == 0)
9849         continue;
9850
9851       if (s == htab->brlt || s == htab->relbrlt)
9852         /* These haven't been allocated yet;  don't strip.  */
9853         continue;
9854       else if (s == htab->elf.sgot
9855                || s == htab->elf.splt
9856                || s == htab->elf.iplt
9857                || s == htab->glink
9858                || s == htab->dynbss)
9859         {
9860           /* Strip this section if we don't need it; see the
9861              comment below.  */
9862         }
9863       else if (s == htab->glink_eh_frame)
9864         {
9865           if (!bfd_is_abs_section (s->output_section))
9866             /* Not sized yet.  */
9867             continue;
9868         }
9869       else if (CONST_STRNEQ (s->name, ".rela"))
9870         {
9871           if (s->size != 0)
9872             {
9873               if (s != htab->elf.srelplt)
9874                 relocs = TRUE;
9875
9876               /* We use the reloc_count field as a counter if we need
9877                  to copy relocs into the output file.  */
9878               s->reloc_count = 0;
9879             }
9880         }
9881       else
9882         {
9883           /* It's not one of our sections, so don't allocate space.  */
9884           continue;
9885         }
9886
9887       if (s->size == 0)
9888         {
9889           /* If we don't need this section, strip it from the
9890              output file.  This is mostly to handle .rela.bss and
9891              .rela.plt.  We must create both sections in
9892              create_dynamic_sections, because they must be created
9893              before the linker maps input sections to output
9894              sections.  The linker does that before
9895              adjust_dynamic_symbol is called, and it is that
9896              function which decides whether anything needs to go
9897              into these sections.  */
9898           s->flags |= SEC_EXCLUDE;
9899           continue;
9900         }
9901
9902       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9903         continue;
9904
9905       /* Allocate memory for the section contents.  We use bfd_zalloc
9906          here in case unused entries are not reclaimed before the
9907          section's contents are written out.  This should not happen,
9908          but this way if it does we get a R_PPC64_NONE reloc in .rela
9909          sections instead of garbage.
9910          We also rely on the section contents being zero when writing
9911          the GOT.  */
9912       s->contents = bfd_zalloc (dynobj, s->size);
9913       if (s->contents == NULL)
9914         return FALSE;
9915     }
9916
9917   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9918     {
9919       if (!is_ppc64_elf (ibfd))
9920         continue;
9921
9922       s = ppc64_elf_tdata (ibfd)->got;
9923       if (s != NULL && s != htab->elf.sgot)
9924         {
9925           if (s->size == 0)
9926             s->flags |= SEC_EXCLUDE;
9927           else
9928             {
9929               s->contents = bfd_zalloc (ibfd, s->size);
9930               if (s->contents == NULL)
9931                 return FALSE;
9932             }
9933         }
9934       s = ppc64_elf_tdata (ibfd)->relgot;
9935       if (s != NULL)
9936         {
9937           if (s->size == 0)
9938             s->flags |= SEC_EXCLUDE;
9939           else
9940             {
9941               s->contents = bfd_zalloc (ibfd, s->size);
9942               if (s->contents == NULL)
9943                 return FALSE;
9944               relocs = TRUE;
9945               s->reloc_count = 0;
9946             }
9947         }
9948     }
9949
9950   if (htab->elf.dynamic_sections_created)
9951     {
9952       bfd_boolean tls_opt;
9953
9954       /* Add some entries to the .dynamic section.  We fill in the
9955          values later, in ppc64_elf_finish_dynamic_sections, but we
9956          must add the entries now so that we get the correct size for
9957          the .dynamic section.  The DT_DEBUG entry is filled in by the
9958          dynamic linker and used by the debugger.  */
9959 #define add_dynamic_entry(TAG, VAL) \
9960   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9961
9962       if (info->executable)
9963         {
9964           if (!add_dynamic_entry (DT_DEBUG, 0))
9965             return FALSE;
9966         }
9967
9968       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9969         {
9970           if (!add_dynamic_entry (DT_PLTGOT, 0)
9971               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9972               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9973               || !add_dynamic_entry (DT_JMPREL, 0)
9974               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9975             return FALSE;
9976         }
9977
9978       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9979         {
9980           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9981               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9982             return FALSE;
9983         }
9984
9985       tls_opt = (!htab->params->no_tls_get_addr_opt
9986                  && htab->tls_get_addr_fd != NULL
9987                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9988       if (tls_opt || !htab->opd_abi)
9989         {
9990           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9991             return FALSE;
9992         }
9993
9994       if (relocs)
9995         {
9996           if (!add_dynamic_entry (DT_RELA, 0)
9997               || !add_dynamic_entry (DT_RELASZ, 0)
9998               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9999             return FALSE;
10000
10001           /* If any dynamic relocs apply to a read-only section,
10002              then we need a DT_TEXTREL entry.  */
10003           if ((info->flags & DF_TEXTREL) == 0)
10004             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10005
10006           if ((info->flags & DF_TEXTREL) != 0)
10007             {
10008               if (!add_dynamic_entry (DT_TEXTREL, 0))
10009                 return FALSE;
10010             }
10011         }
10012     }
10013 #undef add_dynamic_entry
10014
10015   return TRUE;
10016 }
10017
10018 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10019
10020 static bfd_boolean
10021 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10022 {
10023   if (h->plt.plist != NULL
10024       && !h->def_regular
10025       && !h->pointer_equality_needed)
10026     return FALSE;
10027
10028   return _bfd_elf_hash_symbol (h);
10029 }
10030
10031 /* Determine the type of stub needed, if any, for a call.  */
10032
10033 static inline enum ppc_stub_type
10034 ppc_type_of_stub (asection *input_sec,
10035                   const Elf_Internal_Rela *rel,
10036                   struct ppc_link_hash_entry **hash,
10037                   struct plt_entry **plt_ent,
10038                   bfd_vma destination,
10039                   unsigned long local_off)
10040 {
10041   struct ppc_link_hash_entry *h = *hash;
10042   bfd_vma location;
10043   bfd_vma branch_offset;
10044   bfd_vma max_branch_offset;
10045   enum elf_ppc64_reloc_type r_type;
10046
10047   if (h != NULL)
10048     {
10049       struct plt_entry *ent;
10050       struct ppc_link_hash_entry *fdh = h;
10051       if (h->oh != NULL
10052           && h->oh->is_func_descriptor)
10053         {
10054           fdh = ppc_follow_link (h->oh);
10055           *hash = fdh;
10056         }
10057
10058       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10059         if (ent->addend == rel->r_addend
10060             && ent->plt.offset != (bfd_vma) -1)
10061           {
10062             *plt_ent = ent;
10063             return ppc_stub_plt_call;
10064           }
10065
10066       /* Here, we know we don't have a plt entry.  If we don't have a
10067          either a defined function descriptor or a defined entry symbol
10068          in a regular object file, then it is pointless trying to make
10069          any other type of stub.  */
10070       if (!is_static_defined (&fdh->elf)
10071           && !is_static_defined (&h->elf))
10072         return ppc_stub_none;
10073     }
10074   else if (elf_local_got_ents (input_sec->owner) != NULL)
10075     {
10076       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10077       struct plt_entry **local_plt = (struct plt_entry **)
10078         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10079       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10080
10081       if (local_plt[r_symndx] != NULL)
10082         {
10083           struct plt_entry *ent;
10084
10085           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10086             if (ent->addend == rel->r_addend
10087                 && ent->plt.offset != (bfd_vma) -1)
10088               {
10089                 *plt_ent = ent;
10090                 return ppc_stub_plt_call;
10091               }
10092         }
10093     }
10094
10095   /* Determine where the call point is.  */
10096   location = (input_sec->output_offset
10097               + input_sec->output_section->vma
10098               + rel->r_offset);
10099
10100   branch_offset = destination - location;
10101   r_type = ELF64_R_TYPE (rel->r_info);
10102
10103   /* Determine if a long branch stub is needed.  */
10104   max_branch_offset = 1 << 25;
10105   if (r_type != R_PPC64_REL24)
10106     max_branch_offset = 1 << 15;
10107
10108   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10109     /* We need a stub.  Figure out whether a long_branch or plt_branch
10110        is needed later.  */
10111     return ppc_stub_long_branch;
10112
10113   return ppc_stub_none;
10114 }
10115
10116 /* With power7 weakly ordered memory model, it is possible for ld.so
10117    to update a plt entry in one thread and have another thread see a
10118    stale zero toc entry.  To avoid this we need some sort of acquire
10119    barrier in the call stub.  One solution is to make the load of the
10120    toc word seem to appear to depend on the load of the function entry
10121    word.  Another solution is to test for r2 being zero, and branch to
10122    the appropriate glink entry if so.
10123
10124    .    fake dep barrier        compare
10125    .    ld 12,xxx(2)            ld 12,xxx(2)
10126    .    mtctr 12                mtctr 12
10127    .    xor 11,12,12            ld 2,xxx+8(2)
10128    .    add 2,2,11              cmpldi 2,0
10129    .    ld 2,xxx+8(2)           bnectr+
10130    .    bctr                    b <glink_entry>
10131
10132    The solution involving the compare turns out to be faster, so
10133    that's what we use unless the branch won't reach.  */
10134
10135 #define ALWAYS_USE_FAKE_DEP 0
10136 #define ALWAYS_EMIT_R2SAVE 0
10137
10138 #define PPC_LO(v) ((v) & 0xffff)
10139 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10140 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10141
10142 static inline unsigned int
10143 plt_stub_size (struct ppc_link_hash_table *htab,
10144                struct ppc_stub_hash_entry *stub_entry,
10145                bfd_vma off)
10146 {
10147   unsigned size = 12;
10148
10149   if (ALWAYS_EMIT_R2SAVE
10150       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10151     size += 4;
10152   if (PPC_HA (off) != 0)
10153     size += 4;
10154   if (htab->opd_abi)
10155     {
10156       size += 4;
10157       if (htab->params->plt_static_chain)
10158         size += 4;
10159       if (htab->params->plt_thread_safe)
10160         size += 8;
10161       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10162         size += 4;
10163     }
10164   if (stub_entry->h != NULL
10165       && (stub_entry->h == htab->tls_get_addr_fd
10166           || stub_entry->h == htab->tls_get_addr)
10167       && !htab->params->no_tls_get_addr_opt)
10168     size += 13 * 4;
10169   return size;
10170 }
10171
10172 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10173    then return the padding needed to do so.  */
10174 static inline unsigned int
10175 plt_stub_pad (struct ppc_link_hash_table *htab,
10176               struct ppc_stub_hash_entry *stub_entry,
10177               bfd_vma plt_off)
10178 {
10179   int stub_align = 1 << htab->params->plt_stub_align;
10180   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10181   bfd_vma stub_off = stub_entry->stub_sec->size;
10182
10183   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10184       > (stub_size & -stub_align))
10185     return stub_align - (stub_off & (stub_align - 1));
10186   return 0;
10187 }
10188
10189 /* Build a .plt call stub.  */
10190
10191 static inline bfd_byte *
10192 build_plt_stub (struct ppc_link_hash_table *htab,
10193                 struct ppc_stub_hash_entry *stub_entry,
10194                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10195 {
10196   bfd *obfd = htab->params->stub_bfd;
10197   bfd_boolean plt_load_toc = htab->opd_abi;
10198   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10199   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10200   bfd_boolean use_fake_dep = plt_thread_safe;
10201   bfd_vma cmp_branch_off = 0;
10202
10203   if (!ALWAYS_USE_FAKE_DEP
10204       && plt_load_toc
10205       && plt_thread_safe
10206       && !(stub_entry->h != NULL
10207            && (stub_entry->h == htab->tls_get_addr_fd
10208                || stub_entry->h == htab->tls_get_addr)
10209            && !htab->params->no_tls_get_addr_opt))
10210     {
10211       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10212       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10213                           / PLT_ENTRY_SIZE (htab));
10214       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10215       bfd_vma to, from;
10216
10217       if (pltindex > 32768)
10218         glinkoff += (pltindex - 32768) * 4;
10219       to = (glinkoff
10220             + htab->glink->output_offset
10221             + htab->glink->output_section->vma);
10222       from = (p - stub_entry->stub_sec->contents
10223               + 4 * (ALWAYS_EMIT_R2SAVE
10224                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10225               + 4 * (PPC_HA (offset) != 0)
10226               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10227                      != PPC_HA (offset))
10228               + 4 * (plt_static_chain != 0)
10229               + 20
10230               + stub_entry->stub_sec->output_offset
10231               + stub_entry->stub_sec->output_section->vma);
10232       cmp_branch_off = to - from;
10233       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10234     }
10235
10236   if (PPC_HA (offset) != 0)
10237     {
10238       if (r != NULL)
10239         {
10240           if (ALWAYS_EMIT_R2SAVE
10241               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10242             r[0].r_offset += 4;
10243           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10244           r[1].r_offset = r[0].r_offset + 4;
10245           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10246           r[1].r_addend = r[0].r_addend;
10247           if (plt_load_toc)
10248             {
10249               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10250                 {
10251                   r[2].r_offset = r[1].r_offset + 4;
10252                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10253                   r[2].r_addend = r[0].r_addend;
10254                 }
10255               else
10256                 {
10257                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10258                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10259                   r[2].r_addend = r[0].r_addend + 8;
10260                   if (plt_static_chain)
10261                     {
10262                       r[3].r_offset = r[2].r_offset + 4;
10263                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10264                       r[3].r_addend = r[0].r_addend + 16;
10265                     }
10266                 }
10267             }
10268         }
10269       if (ALWAYS_EMIT_R2SAVE
10270           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10271         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10272       if (plt_load_toc)
10273         {
10274           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10275           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10276         }
10277       else
10278         {
10279           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10280           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10281         }
10282       if (plt_load_toc
10283           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10284         {
10285           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10286           offset = 0;
10287         }
10288       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10289       if (plt_load_toc)
10290         {
10291           if (use_fake_dep)
10292             {
10293               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10294               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10295             }
10296           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10297           if (plt_static_chain)
10298             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10299         }
10300     }
10301   else
10302     {
10303       if (r != NULL)
10304         {
10305           if (ALWAYS_EMIT_R2SAVE
10306               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10307             r[0].r_offset += 4;
10308           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10309           if (plt_load_toc)
10310             {
10311               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10312                 {
10313                   r[1].r_offset = r[0].r_offset + 4;
10314                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10315                   r[1].r_addend = r[0].r_addend;
10316                 }
10317               else
10318                 {
10319                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10320                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10321                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10322                   if (plt_static_chain)
10323                     {
10324                       r[2].r_offset = r[1].r_offset + 4;
10325                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10326                       r[2].r_addend = r[0].r_addend + 8;
10327                     }
10328                 }
10329             }
10330         }
10331       if (ALWAYS_EMIT_R2SAVE
10332           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10333         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10334       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10335       if (plt_load_toc
10336           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10337         {
10338           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10339           offset = 0;
10340         }
10341       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10342       if (plt_load_toc)
10343         {
10344           if (use_fake_dep)
10345             {
10346               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10347               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10348             }
10349           if (plt_static_chain)
10350             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10351           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10352         }
10353     }
10354   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10355     {
10356       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10357       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10358       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10359     }
10360   else
10361     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10362   return p;
10363 }
10364
10365 /* Build a special .plt call stub for __tls_get_addr.  */
10366
10367 #define LD_R11_0R3      0xe9630000
10368 #define LD_R12_0R3      0xe9830000
10369 #define MR_R0_R3        0x7c601b78
10370 #define CMPDI_R11_0     0x2c2b0000
10371 #define ADD_R3_R12_R13  0x7c6c6a14
10372 #define BEQLR           0x4d820020
10373 #define MR_R3_R0        0x7c030378
10374 #define STD_R11_0R1     0xf9610000
10375 #define BCTRL           0x4e800421
10376 #define LD_R11_0R1      0xe9610000
10377 #define MTLR_R11        0x7d6803a6
10378
10379 static inline bfd_byte *
10380 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10381                          struct ppc_stub_hash_entry *stub_entry,
10382                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10383 {
10384   bfd *obfd = htab->params->stub_bfd;
10385
10386   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10387   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10388   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10389   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10390   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10391   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10392   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10393   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10394   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10395
10396   if (r != NULL)
10397     r[0].r_offset += 9 * 4;
10398   p = build_plt_stub (htab, stub_entry, p, offset, r);
10399   bfd_put_32 (obfd, BCTRL, p - 4);
10400
10401   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10402   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10403   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10404   bfd_put_32 (obfd, BLR, p),                    p += 4;
10405
10406   return p;
10407 }
10408
10409 static Elf_Internal_Rela *
10410 get_relocs (asection *sec, int count)
10411 {
10412   Elf_Internal_Rela *relocs;
10413   struct bfd_elf_section_data *elfsec_data;
10414
10415   elfsec_data = elf_section_data (sec);
10416   relocs = elfsec_data->relocs;
10417   if (relocs == NULL)
10418     {
10419       bfd_size_type relsize;
10420       relsize = sec->reloc_count * sizeof (*relocs);
10421       relocs = bfd_alloc (sec->owner, relsize);
10422       if (relocs == NULL)
10423         return NULL;
10424       elfsec_data->relocs = relocs;
10425       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10426                                           sizeof (Elf_Internal_Shdr));
10427       if (elfsec_data->rela.hdr == NULL)
10428         return NULL;
10429       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10430                                         * sizeof (Elf64_External_Rela));
10431       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10432       sec->reloc_count = 0;
10433     }
10434   relocs += sec->reloc_count;
10435   sec->reloc_count += count;
10436   return relocs;
10437 }
10438
10439 static bfd_vma
10440 get_r2off (struct bfd_link_info *info,
10441            struct ppc_stub_hash_entry *stub_entry)
10442 {
10443   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10444   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10445
10446   if (r2off == 0)
10447     {
10448       /* Support linking -R objects.  Get the toc pointer from the
10449          opd entry.  */
10450       char buf[8];
10451       if (!htab->opd_abi)
10452         return r2off;
10453       asection *opd = stub_entry->h->elf.root.u.def.section;
10454       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10455
10456       if (strcmp (opd->name, ".opd") != 0
10457           || opd->reloc_count != 0)
10458         {
10459           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10460                                   stub_entry->h->elf.root.root.string);
10461           bfd_set_error (bfd_error_bad_value);
10462           return 0;
10463         }
10464       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10465         return 0;
10466       r2off = bfd_get_64 (opd->owner, buf);
10467       r2off -= elf_gp (info->output_bfd);
10468     }
10469   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10470   return r2off;
10471 }
10472
10473 static bfd_boolean
10474 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10475 {
10476   struct ppc_stub_hash_entry *stub_entry;
10477   struct ppc_branch_hash_entry *br_entry;
10478   struct bfd_link_info *info;
10479   struct ppc_link_hash_table *htab;
10480   bfd_byte *loc;
10481   bfd_byte *p;
10482   bfd_vma dest, off;
10483   int size;
10484   Elf_Internal_Rela *r;
10485   asection *plt;
10486
10487   /* Massage our args to the form they really have.  */
10488   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10489   info = in_arg;
10490
10491   htab = ppc_hash_table (info);
10492   if (htab == NULL)
10493     return FALSE;
10494
10495   /* Make a note of the offset within the stubs for this entry.  */
10496   stub_entry->stub_offset = stub_entry->stub_sec->size;
10497   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10498
10499   htab->stub_count[stub_entry->stub_type - 1] += 1;
10500   switch (stub_entry->stub_type)
10501     {
10502     case ppc_stub_long_branch:
10503     case ppc_stub_long_branch_r2off:
10504       /* Branches are relative.  This is where we are going to.  */
10505       dest = (stub_entry->target_value
10506               + stub_entry->target_section->output_offset
10507               + stub_entry->target_section->output_section->vma);
10508       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10509       off = dest;
10510
10511       /* And this is where we are coming from.  */
10512       off -= (stub_entry->stub_offset
10513               + stub_entry->stub_sec->output_offset
10514               + stub_entry->stub_sec->output_section->vma);
10515
10516       size = 4;
10517       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10518         {
10519           bfd_vma r2off = get_r2off (info, stub_entry);
10520
10521           if (r2off == 0)
10522             {
10523               htab->stub_error = TRUE;
10524               return FALSE;
10525             }
10526           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10527           loc += 4;
10528           size = 12;
10529           if (PPC_HA (r2off) != 0)
10530             {
10531               size = 16;
10532               bfd_put_32 (htab->params->stub_bfd,
10533                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10534               loc += 4;
10535             }
10536           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10537           loc += 4;
10538           off -= size - 4;
10539         }
10540       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10541
10542       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10543         {
10544           info->callbacks->einfo
10545             (_("%P: long branch stub `%s' offset overflow\n"),
10546              stub_entry->root.string);
10547           htab->stub_error = TRUE;
10548           return FALSE;
10549         }
10550
10551       if (info->emitrelocations)
10552         {
10553           r = get_relocs (stub_entry->stub_sec, 1);
10554           if (r == NULL)
10555             return FALSE;
10556           r->r_offset = loc - stub_entry->stub_sec->contents;
10557           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10558           r->r_addend = dest;
10559           if (stub_entry->h != NULL)
10560             {
10561               struct elf_link_hash_entry **hashes;
10562               unsigned long symndx;
10563               struct ppc_link_hash_entry *h;
10564
10565               hashes = elf_sym_hashes (htab->params->stub_bfd);
10566               if (hashes == NULL)
10567                 {
10568                   bfd_size_type hsize;
10569
10570                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10571                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10572                   if (hashes == NULL)
10573                     return FALSE;
10574                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10575                   htab->stub_globals = 1;
10576                 }
10577               symndx = htab->stub_globals++;
10578               h = stub_entry->h;
10579               hashes[symndx] = &h->elf;
10580               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10581               if (h->oh != NULL && h->oh->is_func)
10582                 h = ppc_follow_link (h->oh);
10583               if (h->elf.root.u.def.section != stub_entry->target_section)
10584                 /* H is an opd symbol.  The addend must be zero.  */
10585                 r->r_addend = 0;
10586               else
10587                 {
10588                   off = (h->elf.root.u.def.value
10589                          + h->elf.root.u.def.section->output_offset
10590                          + h->elf.root.u.def.section->output_section->vma);
10591                   r->r_addend -= off;
10592                 }
10593             }
10594         }
10595       break;
10596
10597     case ppc_stub_plt_branch:
10598     case ppc_stub_plt_branch_r2off:
10599       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10600                                          stub_entry->root.string + 9,
10601                                          FALSE, FALSE);
10602       if (br_entry == NULL)
10603         {
10604           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10605                                   stub_entry->root.string);
10606           htab->stub_error = TRUE;
10607           return FALSE;
10608         }
10609
10610       dest = (stub_entry->target_value
10611               + stub_entry->target_section->output_offset
10612               + stub_entry->target_section->output_section->vma);
10613       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10614         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10615
10616       bfd_put_64 (htab->brlt->owner, dest,
10617                   htab->brlt->contents + br_entry->offset);
10618
10619       if (br_entry->iter == htab->stub_iteration)
10620         {
10621           br_entry->iter = 0;
10622
10623           if (htab->relbrlt != NULL)
10624             {
10625               /* Create a reloc for the branch lookup table entry.  */
10626               Elf_Internal_Rela rela;
10627               bfd_byte *rl;
10628
10629               rela.r_offset = (br_entry->offset
10630                                + htab->brlt->output_offset
10631                                + htab->brlt->output_section->vma);
10632               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10633               rela.r_addend = dest;
10634
10635               rl = htab->relbrlt->contents;
10636               rl += (htab->relbrlt->reloc_count++
10637                      * sizeof (Elf64_External_Rela));
10638               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10639             }
10640           else if (info->emitrelocations)
10641             {
10642               r = get_relocs (htab->brlt, 1);
10643               if (r == NULL)
10644                 return FALSE;
10645               /* brlt, being SEC_LINKER_CREATED does not go through the
10646                  normal reloc processing.  Symbols and offsets are not
10647                  translated from input file to output file form, so
10648                  set up the offset per the output file.  */
10649               r->r_offset = (br_entry->offset
10650                              + htab->brlt->output_offset
10651                              + htab->brlt->output_section->vma);
10652               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10653               r->r_addend = dest;
10654             }
10655         }
10656
10657       dest = (br_entry->offset
10658               + htab->brlt->output_offset
10659               + htab->brlt->output_section->vma);
10660
10661       off = (dest
10662              - elf_gp (htab->brlt->output_section->owner)
10663              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10664
10665       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10666         {
10667           info->callbacks->einfo
10668             (_("%P: linkage table error against `%T'\n"),
10669              stub_entry->root.string);
10670           bfd_set_error (bfd_error_bad_value);
10671           htab->stub_error = TRUE;
10672           return FALSE;
10673         }
10674
10675       if (info->emitrelocations)
10676         {
10677           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10678           if (r == NULL)
10679             return FALSE;
10680           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10681           if (bfd_big_endian (info->output_bfd))
10682             r[0].r_offset += 2;
10683           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10684             r[0].r_offset += 4;
10685           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10686           r[0].r_addend = dest;
10687           if (PPC_HA (off) != 0)
10688             {
10689               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10690               r[1].r_offset = r[0].r_offset + 4;
10691               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10692               r[1].r_addend = r[0].r_addend;
10693             }
10694         }
10695
10696       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10697         {
10698           if (PPC_HA (off) != 0)
10699             {
10700               size = 16;
10701               bfd_put_32 (htab->params->stub_bfd,
10702                           ADDIS_R12_R2 | PPC_HA (off), loc);
10703               loc += 4;
10704               bfd_put_32 (htab->params->stub_bfd,
10705                           LD_R12_0R12 | PPC_LO (off), loc);
10706             }
10707           else
10708             {
10709               size = 12;
10710               bfd_put_32 (htab->params->stub_bfd,
10711                           LD_R12_0R2 | PPC_LO (off), loc);
10712             }
10713         }
10714       else
10715         {
10716           bfd_vma r2off = get_r2off (info, stub_entry);
10717
10718           if (r2off == 0 && htab->opd_abi)
10719             {
10720               htab->stub_error = TRUE;
10721               return FALSE;
10722             }
10723
10724           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10725           loc += 4;
10726           size = 16;
10727           if (PPC_HA (off) != 0)
10728             {
10729               size += 4;
10730               bfd_put_32 (htab->params->stub_bfd,
10731                           ADDIS_R12_R2 | PPC_HA (off), loc);
10732               loc += 4;
10733               bfd_put_32 (htab->params->stub_bfd,
10734                           LD_R12_0R12 | PPC_LO (off), loc);
10735             }
10736           else
10737             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10738
10739           if (PPC_HA (r2off) != 0)
10740             {
10741               size += 4;
10742               loc += 4;
10743               bfd_put_32 (htab->params->stub_bfd,
10744                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10745             }
10746           if (PPC_LO (r2off) != 0)
10747             {
10748               size += 4;
10749               loc += 4;
10750               bfd_put_32 (htab->params->stub_bfd,
10751                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10752             }
10753         }
10754       loc += 4;
10755       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10756       loc += 4;
10757       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10758       break;
10759
10760     case ppc_stub_plt_call:
10761     case ppc_stub_plt_call_r2save:
10762       if (stub_entry->h != NULL
10763           && stub_entry->h->is_func_descriptor
10764           && stub_entry->h->oh != NULL)
10765         {
10766           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10767
10768           /* If the old-ABI "dot-symbol" is undefined make it weak so
10769              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10770              FIXME: We used to define the symbol on one of the call
10771              stubs instead, which is why we test symbol section id
10772              against htab->top_id in various places.  Likely all
10773              these checks could now disappear.  */
10774           if (fh->elf.root.type == bfd_link_hash_undefined)
10775             fh->elf.root.type = bfd_link_hash_undefweak;
10776           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10777           fh->was_undefined = 0;
10778         }
10779
10780       /* Now build the stub.  */
10781       dest = stub_entry->plt_ent->plt.offset & ~1;
10782       if (dest >= (bfd_vma) -2)
10783         abort ();
10784
10785       plt = htab->elf.splt;
10786       if (!htab->elf.dynamic_sections_created
10787           || stub_entry->h == NULL
10788           || stub_entry->h->elf.dynindx == -1)
10789         plt = htab->elf.iplt;
10790
10791       dest += plt->output_offset + plt->output_section->vma;
10792
10793       if (stub_entry->h == NULL
10794           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10795         {
10796           Elf_Internal_Rela rela;
10797           bfd_byte *rl;
10798
10799           rela.r_offset = dest;
10800           if (htab->opd_abi)
10801             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10802           else
10803             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10804           rela.r_addend = (stub_entry->target_value
10805                            + stub_entry->target_section->output_offset
10806                            + stub_entry->target_section->output_section->vma);
10807
10808           rl = (htab->elf.irelplt->contents
10809                 + (htab->elf.irelplt->reloc_count++
10810                    * sizeof (Elf64_External_Rela)));
10811           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10812           stub_entry->plt_ent->plt.offset |= 1;
10813         }
10814
10815       off = (dest
10816              - elf_gp (plt->output_section->owner)
10817              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10818
10819       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10820         {
10821           info->callbacks->einfo
10822             (_("%P: linkage table error against `%T'\n"),
10823              stub_entry->h != NULL
10824              ? stub_entry->h->elf.root.root.string
10825              : "<local sym>");
10826           bfd_set_error (bfd_error_bad_value);
10827           htab->stub_error = TRUE;
10828           return FALSE;
10829         }
10830
10831       if (htab->params->plt_stub_align != 0)
10832         {
10833           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10834
10835           stub_entry->stub_sec->size += pad;
10836           stub_entry->stub_offset = stub_entry->stub_sec->size;
10837           loc += pad;
10838         }
10839
10840       r = NULL;
10841       if (info->emitrelocations)
10842         {
10843           r = get_relocs (stub_entry->stub_sec,
10844                           ((PPC_HA (off) != 0)
10845                            + (htab->opd_abi
10846                               ? 2 + (htab->params->plt_static_chain
10847                                      && PPC_HA (off + 16) == PPC_HA (off))
10848                               : 1)));
10849           if (r == NULL)
10850             return FALSE;
10851           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10852           if (bfd_big_endian (info->output_bfd))
10853             r[0].r_offset += 2;
10854           r[0].r_addend = dest;
10855         }
10856       if (stub_entry->h != NULL
10857           && (stub_entry->h == htab->tls_get_addr_fd
10858               || stub_entry->h == htab->tls_get_addr)
10859           && !htab->params->no_tls_get_addr_opt)
10860         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10861       else
10862         p = build_plt_stub (htab, stub_entry, loc, off, r);
10863       size = p - loc;
10864       break;
10865
10866     default:
10867       BFD_FAIL ();
10868       return FALSE;
10869     }
10870
10871   stub_entry->stub_sec->size += size;
10872
10873   if (htab->params->emit_stub_syms)
10874     {
10875       struct elf_link_hash_entry *h;
10876       size_t len1, len2;
10877       char *name;
10878       const char *const stub_str[] = { "long_branch",
10879                                        "long_branch_r2off",
10880                                        "plt_branch",
10881                                        "plt_branch_r2off",
10882                                        "plt_call",
10883                                        "plt_call" };
10884
10885       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10886       len2 = strlen (stub_entry->root.string);
10887       name = bfd_malloc (len1 + len2 + 2);
10888       if (name == NULL)
10889         return FALSE;
10890       memcpy (name, stub_entry->root.string, 9);
10891       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10892       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10893       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10894       if (h == NULL)
10895         return FALSE;
10896       if (h->root.type == bfd_link_hash_new)
10897         {
10898           h->root.type = bfd_link_hash_defined;
10899           h->root.u.def.section = stub_entry->stub_sec;
10900           h->root.u.def.value = stub_entry->stub_offset;
10901           h->ref_regular = 1;
10902           h->def_regular = 1;
10903           h->ref_regular_nonweak = 1;
10904           h->forced_local = 1;
10905           h->non_elf = 0;
10906         }
10907     }
10908
10909   return TRUE;
10910 }
10911
10912 /* As above, but don't actually build the stub.  Just bump offset so
10913    we know stub section sizes, and select plt_branch stubs where
10914    long_branch stubs won't do.  */
10915
10916 static bfd_boolean
10917 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10918 {
10919   struct ppc_stub_hash_entry *stub_entry;
10920   struct bfd_link_info *info;
10921   struct ppc_link_hash_table *htab;
10922   bfd_vma off;
10923   int size;
10924
10925   /* Massage our args to the form they really have.  */
10926   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10927   info = in_arg;
10928
10929   htab = ppc_hash_table (info);
10930   if (htab == NULL)
10931     return FALSE;
10932
10933   if (stub_entry->stub_type == ppc_stub_plt_call
10934       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10935     {
10936       asection *plt;
10937       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10938       if (off >= (bfd_vma) -2)
10939         abort ();
10940       plt = htab->elf.splt;
10941       if (!htab->elf.dynamic_sections_created
10942           || stub_entry->h == NULL
10943           || stub_entry->h->elf.dynindx == -1)
10944         plt = htab->elf.iplt;
10945       off += (plt->output_offset
10946               + plt->output_section->vma
10947               - elf_gp (plt->output_section->owner)
10948               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10949
10950       size = plt_stub_size (htab, stub_entry, off);
10951       if (htab->params->plt_stub_align)
10952         size += plt_stub_pad (htab, stub_entry, off);
10953       if (info->emitrelocations)
10954         {
10955           stub_entry->stub_sec->reloc_count
10956             += ((PPC_HA (off) != 0)
10957                 + (htab->opd_abi
10958                    ? 2 + (htab->params->plt_static_chain
10959                           && PPC_HA (off + 16) == PPC_HA (off))
10960                    : 1));
10961           stub_entry->stub_sec->flags |= SEC_RELOC;
10962         }
10963     }
10964   else
10965     {
10966       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10967          variants.  */
10968       bfd_vma r2off = 0;
10969       bfd_vma local_off = 0;
10970
10971       off = (stub_entry->target_value
10972              + stub_entry->target_section->output_offset
10973              + stub_entry->target_section->output_section->vma);
10974       off -= (stub_entry->stub_sec->size
10975               + stub_entry->stub_sec->output_offset
10976               + stub_entry->stub_sec->output_section->vma);
10977
10978       /* Reset the stub type from the plt variant in case we now
10979          can reach with a shorter stub.  */
10980       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10981         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10982
10983       size = 4;
10984       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10985         {
10986           r2off = get_r2off (info, stub_entry);
10987           if (r2off == 0 && htab->opd_abi)
10988             {
10989               htab->stub_error = TRUE;
10990               return FALSE;
10991             }
10992           size = 12;
10993           if (PPC_HA (r2off) != 0)
10994             size = 16;
10995           off -= size - 4;
10996         }
10997
10998       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10999
11000       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11001          Do the same for -R objects without function descriptors.  */
11002       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11003           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11004               && r2off == 0))
11005         {
11006           struct ppc_branch_hash_entry *br_entry;
11007
11008           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11009                                              stub_entry->root.string + 9,
11010                                              TRUE, FALSE);
11011           if (br_entry == NULL)
11012             {
11013               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11014                                       stub_entry->root.string);
11015               htab->stub_error = TRUE;
11016               return FALSE;
11017             }
11018
11019           if (br_entry->iter != htab->stub_iteration)
11020             {
11021               br_entry->iter = htab->stub_iteration;
11022               br_entry->offset = htab->brlt->size;
11023               htab->brlt->size += 8;
11024
11025               if (htab->relbrlt != NULL)
11026                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11027               else if (info->emitrelocations)
11028                 {
11029                   htab->brlt->reloc_count += 1;
11030                   htab->brlt->flags |= SEC_RELOC;
11031                 }
11032             }
11033
11034           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11035           off = (br_entry->offset
11036                  + htab->brlt->output_offset
11037                  + htab->brlt->output_section->vma
11038                  - elf_gp (htab->brlt->output_section->owner)
11039                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11040
11041           if (info->emitrelocations)
11042             {
11043               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11044               stub_entry->stub_sec->flags |= SEC_RELOC;
11045             }
11046
11047           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11048             {
11049               size = 12;
11050               if (PPC_HA (off) != 0)
11051                 size = 16;
11052             }
11053           else
11054             {
11055               size = 16;
11056               if (PPC_HA (off) != 0)
11057                 size += 4;
11058
11059               if (PPC_HA (r2off) != 0)
11060                 size += 4;
11061               if (PPC_LO (r2off) != 0)
11062                 size += 4;
11063             }
11064         }
11065       else if (info->emitrelocations)
11066         {
11067           stub_entry->stub_sec->reloc_count += 1;
11068           stub_entry->stub_sec->flags |= SEC_RELOC;
11069         }
11070     }
11071
11072   stub_entry->stub_sec->size += size;
11073   return TRUE;
11074 }
11075
11076 /* Set up various things so that we can make a list of input sections
11077    for each output section included in the link.  Returns -1 on error,
11078    0 when no stubs will be needed, and 1 on success.  */
11079
11080 int
11081 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11082 {
11083   bfd *input_bfd;
11084   int top_id, top_index, id;
11085   asection *section;
11086   asection **input_list;
11087   bfd_size_type amt;
11088   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11089
11090   if (htab == NULL)
11091     return -1;
11092
11093   /* Find the top input section id.  */
11094   for (input_bfd = info->input_bfds, top_id = 3;
11095        input_bfd != NULL;
11096        input_bfd = input_bfd->link.next)
11097     {
11098       for (section = input_bfd->sections;
11099            section != NULL;
11100            section = section->next)
11101         {
11102           if (top_id < section->id)
11103             top_id = section->id;
11104         }
11105     }
11106
11107   htab->top_id = top_id;
11108   amt = sizeof (struct map_stub) * (top_id + 1);
11109   htab->stub_group = bfd_zmalloc (amt);
11110   if (htab->stub_group == NULL)
11111     return -1;
11112
11113   /* Set toc_off for com, und, abs and ind sections.  */
11114   for (id = 0; id < 3; id++)
11115     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11116
11117   /* We can't use output_bfd->section_count here to find the top output
11118      section index as some sections may have been removed, and
11119      strip_excluded_output_sections doesn't renumber the indices.  */
11120   for (section = info->output_bfd->sections, top_index = 0;
11121        section != NULL;
11122        section = section->next)
11123     {
11124       if (top_index < section->index)
11125         top_index = section->index;
11126     }
11127
11128   htab->top_index = top_index;
11129   amt = sizeof (asection *) * (top_index + 1);
11130   input_list = bfd_zmalloc (amt);
11131   htab->input_list = input_list;
11132   if (input_list == NULL)
11133     return -1;
11134
11135   return 1;
11136 }
11137
11138 /* Set up for first pass at multitoc partitioning.  */
11139
11140 void
11141 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11142 {
11143   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11144
11145   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11146   htab->toc_bfd = NULL;
11147   htab->toc_first_sec = NULL;
11148 }
11149
11150 /* The linker repeatedly calls this function for each TOC input section
11151    and linker generated GOT section.  Group input bfds such that the toc
11152    within a group is less than 64k in size.  */
11153
11154 bfd_boolean
11155 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11156 {
11157   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11158   bfd_vma addr, off, limit;
11159
11160   if (htab == NULL)
11161     return FALSE;
11162
11163   if (!htab->second_toc_pass)
11164     {
11165       /* Keep track of the first .toc or .got section for this input bfd.  */
11166       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11167
11168       if (new_bfd)
11169         {
11170           htab->toc_bfd = isec->owner;
11171           htab->toc_first_sec = isec;
11172         }
11173
11174       addr = isec->output_offset + isec->output_section->vma;
11175       off = addr - htab->toc_curr;
11176       limit = 0x80008000;
11177       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11178         limit = 0x10000;
11179       if (off + isec->size > limit)
11180         {
11181           addr = (htab->toc_first_sec->output_offset
11182                   + htab->toc_first_sec->output_section->vma);
11183           htab->toc_curr = addr;
11184         }
11185
11186       /* toc_curr is the base address of this toc group.  Set elf_gp
11187          for the input section to be the offset relative to the
11188          output toc base plus 0x8000.  Making the input elf_gp an
11189          offset allows us to move the toc as a whole without
11190          recalculating input elf_gp.  */
11191       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11192       off += TOC_BASE_OFF;
11193
11194       /* Die if someone uses a linker script that doesn't keep input
11195          file .toc and .got together.  */
11196       if (new_bfd
11197           && elf_gp (isec->owner) != 0
11198           && elf_gp (isec->owner) != off)
11199         return FALSE;
11200
11201       elf_gp (isec->owner) = off;
11202       return TRUE;
11203     }
11204
11205   /* During the second pass toc_first_sec points to the start of
11206      a toc group, and toc_curr is used to track the old elf_gp.
11207      We use toc_bfd to ensure we only look at each bfd once.  */
11208   if (htab->toc_bfd == isec->owner)
11209     return TRUE;
11210   htab->toc_bfd = isec->owner;
11211
11212   if (htab->toc_first_sec == NULL
11213       || htab->toc_curr != elf_gp (isec->owner))
11214     {
11215       htab->toc_curr = elf_gp (isec->owner);
11216       htab->toc_first_sec = isec;
11217     }
11218   addr = (htab->toc_first_sec->output_offset
11219           + htab->toc_first_sec->output_section->vma);
11220   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11221   elf_gp (isec->owner) = off;
11222
11223   return TRUE;
11224 }
11225
11226 /* Called via elf_link_hash_traverse to merge GOT entries for global
11227    symbol H.  */
11228
11229 static bfd_boolean
11230 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11231 {
11232   if (h->root.type == bfd_link_hash_indirect)
11233     return TRUE;
11234
11235   merge_got_entries (&h->got.glist);
11236
11237   return TRUE;
11238 }
11239
11240 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11241    symbol H.  */
11242
11243 static bfd_boolean
11244 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11245 {
11246   struct got_entry *gent;
11247
11248   if (h->root.type == bfd_link_hash_indirect)
11249     return TRUE;
11250
11251   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11252     if (!gent->is_indirect)
11253       allocate_got (h, (struct bfd_link_info *) inf, gent);
11254   return TRUE;
11255 }
11256
11257 /* Called on the first multitoc pass after the last call to
11258    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11259    entries.  */
11260
11261 bfd_boolean
11262 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11263 {
11264   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11265   struct bfd *ibfd, *ibfd2;
11266   bfd_boolean done_something;
11267
11268   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11269
11270   if (!htab->do_multi_toc)
11271     return FALSE;
11272
11273   /* Merge global sym got entries within a toc group.  */
11274   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11275
11276   /* And tlsld_got.  */
11277   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11278     {
11279       struct got_entry *ent, *ent2;
11280
11281       if (!is_ppc64_elf (ibfd))
11282         continue;
11283
11284       ent = ppc64_tlsld_got (ibfd);
11285       if (!ent->is_indirect
11286           && ent->got.offset != (bfd_vma) -1)
11287         {
11288           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11289             {
11290               if (!is_ppc64_elf (ibfd2))
11291                 continue;
11292
11293               ent2 = ppc64_tlsld_got (ibfd2);
11294               if (!ent2->is_indirect
11295                   && ent2->got.offset != (bfd_vma) -1
11296                   && elf_gp (ibfd2) == elf_gp (ibfd))
11297                 {
11298                   ent2->is_indirect = TRUE;
11299                   ent2->got.ent = ent;
11300                 }
11301             }
11302         }
11303     }
11304
11305   /* Zap sizes of got sections.  */
11306   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11307   htab->elf.irelplt->size -= htab->got_reli_size;
11308   htab->got_reli_size = 0;
11309
11310   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11311     {
11312       asection *got, *relgot;
11313
11314       if (!is_ppc64_elf (ibfd))
11315         continue;
11316
11317       got = ppc64_elf_tdata (ibfd)->got;
11318       if (got != NULL)
11319         {
11320           got->rawsize = got->size;
11321           got->size = 0;
11322           relgot = ppc64_elf_tdata (ibfd)->relgot;
11323           relgot->rawsize = relgot->size;
11324           relgot->size = 0;
11325         }
11326     }
11327
11328   /* Now reallocate the got, local syms first.  We don't need to
11329      allocate section contents again since we never increase size.  */
11330   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11331     {
11332       struct got_entry **lgot_ents;
11333       struct got_entry **end_lgot_ents;
11334       struct plt_entry **local_plt;
11335       struct plt_entry **end_local_plt;
11336       unsigned char *lgot_masks;
11337       bfd_size_type locsymcount;
11338       Elf_Internal_Shdr *symtab_hdr;
11339       asection *s;
11340
11341       if (!is_ppc64_elf (ibfd))
11342         continue;
11343
11344       lgot_ents = elf_local_got_ents (ibfd);
11345       if (!lgot_ents)
11346         continue;
11347
11348       symtab_hdr = &elf_symtab_hdr (ibfd);
11349       locsymcount = symtab_hdr->sh_info;
11350       end_lgot_ents = lgot_ents + locsymcount;
11351       local_plt = (struct plt_entry **) end_lgot_ents;
11352       end_local_plt = local_plt + locsymcount;
11353       lgot_masks = (unsigned char *) end_local_plt;
11354       s = ppc64_elf_tdata (ibfd)->got;
11355       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11356         {
11357           struct got_entry *ent;
11358
11359           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11360             {
11361               unsigned int ent_size = 8;
11362               unsigned int rel_size = sizeof (Elf64_External_Rela);
11363
11364               ent->got.offset = s->size;
11365               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11366                 {
11367                   ent_size *= 2;
11368                   rel_size *= 2;
11369                 }
11370               s->size += ent_size;
11371               if ((*lgot_masks & PLT_IFUNC) != 0)
11372                 {
11373                   htab->elf.irelplt->size += rel_size;
11374                   htab->got_reli_size += rel_size;
11375                 }
11376               else if (info->shared)
11377                 {
11378                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11379                   srel->size += rel_size;
11380                 }
11381             }
11382         }
11383     }
11384
11385   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11386
11387   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11388     {
11389       struct got_entry *ent;
11390
11391       if (!is_ppc64_elf (ibfd))
11392         continue;
11393
11394       ent = ppc64_tlsld_got (ibfd);
11395       if (!ent->is_indirect
11396           && ent->got.offset != (bfd_vma) -1)
11397         {
11398           asection *s = ppc64_elf_tdata (ibfd)->got;
11399           ent->got.offset = s->size;
11400           s->size += 16;
11401           if (info->shared)
11402             {
11403               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11404               srel->size += sizeof (Elf64_External_Rela);
11405             }
11406         }
11407     }
11408
11409   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11410   if (!done_something)
11411     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11412       {
11413         asection *got;
11414
11415         if (!is_ppc64_elf (ibfd))
11416           continue;
11417
11418         got = ppc64_elf_tdata (ibfd)->got;
11419         if (got != NULL)
11420           {
11421             done_something = got->rawsize != got->size;
11422             if (done_something)
11423               break;
11424           }
11425       }
11426
11427   if (done_something)
11428     (*htab->params->layout_sections_again) ();
11429
11430   /* Set up for second pass over toc sections to recalculate elf_gp
11431      on input sections.  */
11432   htab->toc_bfd = NULL;
11433   htab->toc_first_sec = NULL;
11434   htab->second_toc_pass = TRUE;
11435   return done_something;
11436 }
11437
11438 /* Called after second pass of multitoc partitioning.  */
11439
11440 void
11441 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11442 {
11443   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11444
11445   /* After the second pass, toc_curr tracks the TOC offset used
11446      for code sections below in ppc64_elf_next_input_section.  */
11447   htab->toc_curr = TOC_BASE_OFF;
11448 }
11449
11450 /* No toc references were found in ISEC.  If the code in ISEC makes no
11451    calls, then there's no need to use toc adjusting stubs when branching
11452    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11453    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11454    needed, and 2 if a cyclical call-graph was found but no other reason
11455    for a stub was detected.  If called from the top level, a return of
11456    2 means the same as a return of 0.  */
11457
11458 static int
11459 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11460 {
11461   int ret;
11462
11463   /* Mark this section as checked.  */
11464   isec->call_check_done = 1;
11465
11466   /* We know none of our code bearing sections will need toc stubs.  */
11467   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11468     return 0;
11469
11470   if (isec->size == 0)
11471     return 0;
11472
11473   if (isec->output_section == NULL)
11474     return 0;
11475
11476   ret = 0;
11477   if (isec->reloc_count != 0)
11478     {
11479       Elf_Internal_Rela *relstart, *rel;
11480       Elf_Internal_Sym *local_syms;
11481       struct ppc_link_hash_table *htab;
11482
11483       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11484                                             info->keep_memory);
11485       if (relstart == NULL)
11486         return -1;
11487
11488       /* Look for branches to outside of this section.  */
11489       local_syms = NULL;
11490       htab = ppc_hash_table (info);
11491       if (htab == NULL)
11492         return -1;
11493
11494       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11495         {
11496           enum elf_ppc64_reloc_type r_type;
11497           unsigned long r_symndx;
11498           struct elf_link_hash_entry *h;
11499           struct ppc_link_hash_entry *eh;
11500           Elf_Internal_Sym *sym;
11501           asection *sym_sec;
11502           struct _opd_sec_data *opd;
11503           bfd_vma sym_value;
11504           bfd_vma dest;
11505
11506           r_type = ELF64_R_TYPE (rel->r_info);
11507           if (r_type != R_PPC64_REL24
11508               && r_type != R_PPC64_REL14
11509               && r_type != R_PPC64_REL14_BRTAKEN
11510               && r_type != R_PPC64_REL14_BRNTAKEN)
11511             continue;
11512
11513           r_symndx = ELF64_R_SYM (rel->r_info);
11514           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11515                           isec->owner))
11516             {
11517               ret = -1;
11518               break;
11519             }
11520
11521           /* Calls to dynamic lib functions go through a plt call stub
11522              that uses r2.  */
11523           eh = (struct ppc_link_hash_entry *) h;
11524           if (eh != NULL
11525               && (eh->elf.plt.plist != NULL
11526                   || (eh->oh != NULL
11527                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11528             {
11529               ret = 1;
11530               break;
11531             }
11532
11533           if (sym_sec == NULL)
11534             /* Ignore other undefined symbols.  */
11535             continue;
11536
11537           /* Assume branches to other sections not included in the
11538              link need stubs too, to cover -R and absolute syms.  */
11539           if (sym_sec->output_section == NULL)
11540             {
11541               ret = 1;
11542               break;
11543             }
11544
11545           if (h == NULL)
11546             sym_value = sym->st_value;
11547           else
11548             {
11549               if (h->root.type != bfd_link_hash_defined
11550                   && h->root.type != bfd_link_hash_defweak)
11551                 abort ();
11552               sym_value = h->root.u.def.value;
11553             }
11554           sym_value += rel->r_addend;
11555
11556           /* If this branch reloc uses an opd sym, find the code section.  */
11557           opd = get_opd_info (sym_sec);
11558           if (opd != NULL)
11559             {
11560               if (h == NULL && opd->adjust != NULL)
11561                 {
11562                   long adjust;
11563
11564                   adjust = opd->adjust[sym->st_value / 8];
11565                   if (adjust == -1)
11566                     /* Assume deleted functions won't ever be called.  */
11567                     continue;
11568                   sym_value += adjust;
11569                 }
11570
11571               dest = opd_entry_value (sym_sec, sym_value,
11572                                       &sym_sec, NULL, FALSE);
11573               if (dest == (bfd_vma) -1)
11574                 continue;
11575             }
11576           else
11577             dest = (sym_value
11578                     + sym_sec->output_offset
11579                     + sym_sec->output_section->vma);
11580
11581           /* Ignore branch to self.  */
11582           if (sym_sec == isec)
11583             continue;
11584
11585           /* If the called function uses the toc, we need a stub.  */
11586           if (sym_sec->has_toc_reloc
11587               || sym_sec->makes_toc_func_call)
11588             {
11589               ret = 1;
11590               break;
11591             }
11592
11593           /* Assume any branch that needs a long branch stub might in fact
11594              need a plt_branch stub.  A plt_branch stub uses r2.  */
11595           else if (dest - (isec->output_offset
11596                            + isec->output_section->vma
11597                            + rel->r_offset) + (1 << 25)
11598                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11599                                                              ? h->other
11600                                                              : sym->st_other))
11601             {
11602               ret = 1;
11603               break;
11604             }
11605
11606           /* If calling back to a section in the process of being
11607              tested, we can't say for sure that no toc adjusting stubs
11608              are needed, so don't return zero.  */
11609           else if (sym_sec->call_check_in_progress)
11610             ret = 2;
11611
11612           /* Branches to another section that itself doesn't have any TOC
11613              references are OK.  Recursively call ourselves to check.  */
11614           else if (!sym_sec->call_check_done)
11615             {
11616               int recur;
11617
11618               /* Mark current section as indeterminate, so that other
11619                  sections that call back to current won't be marked as
11620                  known.  */
11621               isec->call_check_in_progress = 1;
11622               recur = toc_adjusting_stub_needed (info, sym_sec);
11623               isec->call_check_in_progress = 0;
11624
11625               if (recur != 0)
11626                 {
11627                   ret = recur;
11628                   if (recur != 2)
11629                     break;
11630                 }
11631             }
11632         }
11633
11634       if (local_syms != NULL
11635           && (elf_symtab_hdr (isec->owner).contents
11636               != (unsigned char *) local_syms))
11637         free (local_syms);
11638       if (elf_section_data (isec)->relocs != relstart)
11639         free (relstart);
11640     }
11641
11642   if ((ret & 1) == 0
11643       && isec->map_head.s != NULL
11644       && (strcmp (isec->output_section->name, ".init") == 0
11645           || strcmp (isec->output_section->name, ".fini") == 0))
11646     {
11647       if (isec->map_head.s->has_toc_reloc
11648           || isec->map_head.s->makes_toc_func_call)
11649         ret = 1;
11650       else if (!isec->map_head.s->call_check_done)
11651         {
11652           int recur;
11653           isec->call_check_in_progress = 1;
11654           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11655           isec->call_check_in_progress = 0;
11656           if (recur != 0)
11657             ret = recur;
11658         }
11659     }
11660
11661   if (ret == 1)
11662     isec->makes_toc_func_call = 1;
11663
11664   return ret;
11665 }
11666
11667 /* The linker repeatedly calls this function for each input section,
11668    in the order that input sections are linked into output sections.
11669    Build lists of input sections to determine groupings between which
11670    we may insert linker stubs.  */
11671
11672 bfd_boolean
11673 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11674 {
11675   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11676
11677   if (htab == NULL)
11678     return FALSE;
11679
11680   if ((isec->output_section->flags & SEC_CODE) != 0
11681       && isec->output_section->index <= htab->top_index)
11682     {
11683       asection **list = htab->input_list + isec->output_section->index;
11684       /* Steal the link_sec pointer for our list.  */
11685 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11686       /* This happens to make the list in reverse order,
11687          which is what we want.  */
11688       PREV_SEC (isec) = *list;
11689       *list = isec;
11690     }
11691
11692   if (htab->multi_toc_needed)
11693     {
11694       /* Analyse sections that aren't already flagged as needing a
11695          valid toc pointer.  Exclude .fixup for the linux kernel.
11696          .fixup contains branches, but only back to the function that
11697          hit an exception.  */
11698       if (!(isec->has_toc_reloc
11699             || (isec->flags & SEC_CODE) == 0
11700             || strcmp (isec->name, ".fixup") == 0
11701             || isec->call_check_done))
11702         {
11703           if (toc_adjusting_stub_needed (info, isec) < 0)
11704             return FALSE;
11705         }
11706       /* Make all sections use the TOC assigned for this object file.
11707          This will be wrong for pasted sections;  We fix that in
11708          check_pasted_section().  */
11709       if (elf_gp (isec->owner) != 0)
11710         htab->toc_curr = elf_gp (isec->owner);
11711     }
11712
11713   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11714   return TRUE;
11715 }
11716
11717 /* Check that all .init and .fini sections use the same toc, if they
11718    have toc relocs.  */
11719
11720 static bfd_boolean
11721 check_pasted_section (struct bfd_link_info *info, const char *name)
11722 {
11723   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11724
11725   if (o != NULL)
11726     {
11727       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11728       bfd_vma toc_off = 0;
11729       asection *i;
11730
11731       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11732         if (i->has_toc_reloc)
11733           {
11734             if (toc_off == 0)
11735               toc_off = htab->stub_group[i->id].toc_off;
11736             else if (toc_off != htab->stub_group[i->id].toc_off)
11737               return FALSE;
11738           }
11739
11740       if (toc_off == 0)
11741         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11742           if (i->makes_toc_func_call)
11743             {
11744               toc_off = htab->stub_group[i->id].toc_off;
11745               break;
11746             }
11747
11748       /* Make sure the whole pasted function uses the same toc offset.  */
11749       if (toc_off != 0)
11750         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11751           htab->stub_group[i->id].toc_off = toc_off;
11752     }
11753   return TRUE;
11754 }
11755
11756 bfd_boolean
11757 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11758 {
11759   return (check_pasted_section (info, ".init")
11760           & check_pasted_section (info, ".fini"));
11761 }
11762
11763 /* See whether we can group stub sections together.  Grouping stub
11764    sections may result in fewer stubs.  More importantly, we need to
11765    put all .init* and .fini* stubs at the beginning of the .init or
11766    .fini output sections respectively, because glibc splits the
11767    _init and _fini functions into multiple parts.  Putting a stub in
11768    the middle of a function is not a good idea.  */
11769
11770 static void
11771 group_sections (struct ppc_link_hash_table *htab,
11772                 bfd_size_type stub_group_size,
11773                 bfd_boolean stubs_always_before_branch)
11774 {
11775   asection **list;
11776   bfd_size_type stub14_group_size;
11777   bfd_boolean suppress_size_errors;
11778
11779   suppress_size_errors = FALSE;
11780   stub14_group_size = stub_group_size;
11781   if (stub_group_size == 1)
11782     {
11783       /* Default values.  */
11784       if (stubs_always_before_branch)
11785         {
11786           stub_group_size = 0x1e00000;
11787           stub14_group_size = 0x7800;
11788         }
11789       else
11790         {
11791           stub_group_size = 0x1c00000;
11792           stub14_group_size = 0x7000;
11793         }
11794       suppress_size_errors = TRUE;
11795     }
11796
11797   list = htab->input_list + htab->top_index;
11798   do
11799     {
11800       asection *tail = *list;
11801       while (tail != NULL)
11802         {
11803           asection *curr;
11804           asection *prev;
11805           bfd_size_type total;
11806           bfd_boolean big_sec;
11807           bfd_vma curr_toc;
11808
11809           curr = tail;
11810           total = tail->size;
11811           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11812                              && ppc64_elf_section_data (tail)->has_14bit_branch
11813                              ? stub14_group_size : stub_group_size);
11814           if (big_sec && !suppress_size_errors)
11815             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11816                                      tail->owner, tail);
11817           curr_toc = htab->stub_group[tail->id].toc_off;
11818
11819           while ((prev = PREV_SEC (curr)) != NULL
11820                  && ((total += curr->output_offset - prev->output_offset)
11821                      < (ppc64_elf_section_data (prev) != NULL
11822                         && ppc64_elf_section_data (prev)->has_14bit_branch
11823                         ? stub14_group_size : stub_group_size))
11824                  && htab->stub_group[prev->id].toc_off == curr_toc)
11825             curr = prev;
11826
11827           /* OK, the size from the start of CURR to the end is less
11828              than stub_group_size and thus can be handled by one stub
11829              section.  (or the tail section is itself larger than
11830              stub_group_size, in which case we may be toast.)  We
11831              should really be keeping track of the total size of stubs
11832              added here, as stubs contribute to the final output
11833              section size.  That's a little tricky, and this way will
11834              only break if stubs added make the total size more than
11835              2^25, ie. for the default stub_group_size, if stubs total
11836              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11837           do
11838             {
11839               prev = PREV_SEC (tail);
11840               /* Set up this stub group.  */
11841               htab->stub_group[tail->id].link_sec = curr;
11842             }
11843           while (tail != curr && (tail = prev) != NULL);
11844
11845           /* But wait, there's more!  Input sections up to stub_group_size
11846              bytes before the stub section can be handled by it too.
11847              Don't do this if we have a really large section after the
11848              stubs, as adding more stubs increases the chance that
11849              branches may not reach into the stub section.  */
11850           if (!stubs_always_before_branch && !big_sec)
11851             {
11852               total = 0;
11853               while (prev != NULL
11854                      && ((total += tail->output_offset - prev->output_offset)
11855                          < (ppc64_elf_section_data (prev) != NULL
11856                             && ppc64_elf_section_data (prev)->has_14bit_branch
11857                             ? stub14_group_size : stub_group_size))
11858                      && htab->stub_group[prev->id].toc_off == curr_toc)
11859                 {
11860                   tail = prev;
11861                   prev = PREV_SEC (tail);
11862                   htab->stub_group[tail->id].link_sec = curr;
11863                 }
11864             }
11865           tail = prev;
11866         }
11867     }
11868   while (list-- != htab->input_list);
11869   free (htab->input_list);
11870 #undef PREV_SEC
11871 }
11872
11873 static const unsigned char glink_eh_frame_cie[] =
11874 {
11875   0, 0, 0, 16,                          /* length.  */
11876   0, 0, 0, 0,                           /* id.  */
11877   1,                                    /* CIE version.  */
11878   'z', 'R', 0,                          /* Augmentation string.  */
11879   4,                                    /* Code alignment.  */
11880   0x78,                                 /* Data alignment.  */
11881   65,                                   /* RA reg.  */
11882   1,                                    /* Augmentation size.  */
11883   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11884   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11885 };
11886
11887 /* Stripping output sections is normally done before dynamic section
11888    symbols have been allocated.  This function is called later, and
11889    handles cases like htab->brlt which is mapped to its own output
11890    section.  */
11891
11892 static void
11893 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11894 {
11895   if (isec->size == 0
11896       && isec->output_section->size == 0
11897       && !(isec->output_section->flags & SEC_KEEP)
11898       && !bfd_section_removed_from_list (info->output_bfd,
11899                                          isec->output_section)
11900       && elf_section_data (isec->output_section)->dynindx == 0)
11901     {
11902       isec->output_section->flags |= SEC_EXCLUDE;
11903       bfd_section_list_remove (info->output_bfd, isec->output_section);
11904       info->output_bfd->section_count--;
11905     }
11906 }
11907
11908 /* Determine and set the size of the stub section for a final link.
11909
11910    The basic idea here is to examine all the relocations looking for
11911    PC-relative calls to a target that is unreachable with a "bl"
11912    instruction.  */
11913
11914 bfd_boolean
11915 ppc64_elf_size_stubs (struct bfd_link_info *info)
11916 {
11917   bfd_size_type stub_group_size;
11918   bfd_boolean stubs_always_before_branch;
11919   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11920
11921   if (htab == NULL)
11922     return FALSE;
11923
11924   if (htab->params->plt_thread_safe == -1 && !info->executable)
11925     htab->params->plt_thread_safe = 1;
11926   if (!htab->opd_abi)
11927     htab->params->plt_thread_safe = 0;
11928   else if (htab->params->plt_thread_safe == -1)
11929     {
11930       static const char *const thread_starter[] =
11931         {
11932           "pthread_create",
11933           /* libstdc++ */
11934           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11935           /* librt */
11936           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11937           "mq_notify", "create_timer",
11938           /* libanl */
11939           "getaddrinfo_a",
11940           /* libgomp */
11941           "GOMP_parallel_start",
11942           "GOMP_parallel_loop_static_start",
11943           "GOMP_parallel_loop_dynamic_start",
11944           "GOMP_parallel_loop_guided_start",
11945           "GOMP_parallel_loop_runtime_start",
11946           "GOMP_parallel_sections_start",
11947         };
11948       unsigned i;
11949
11950       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11951         {
11952           struct elf_link_hash_entry *h;
11953           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11954                                     FALSE, FALSE, TRUE);
11955           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11956           if (htab->params->plt_thread_safe)
11957             break;
11958         }
11959     }
11960   stubs_always_before_branch = htab->params->group_size < 0;
11961   if (htab->params->group_size < 0)
11962     stub_group_size = -htab->params->group_size;
11963   else
11964     stub_group_size = htab->params->group_size;
11965
11966   group_sections (htab, stub_group_size, stubs_always_before_branch);
11967
11968   while (1)
11969     {
11970       bfd *input_bfd;
11971       unsigned int bfd_indx;
11972       asection *stub_sec;
11973
11974       htab->stub_iteration += 1;
11975
11976       for (input_bfd = info->input_bfds, bfd_indx = 0;
11977            input_bfd != NULL;
11978            input_bfd = input_bfd->link.next, bfd_indx++)
11979         {
11980           Elf_Internal_Shdr *symtab_hdr;
11981           asection *section;
11982           Elf_Internal_Sym *local_syms = NULL;
11983
11984           if (!is_ppc64_elf (input_bfd))
11985             continue;
11986
11987           /* We'll need the symbol table in a second.  */
11988           symtab_hdr = &elf_symtab_hdr (input_bfd);
11989           if (symtab_hdr->sh_info == 0)
11990             continue;
11991
11992           /* Walk over each section attached to the input bfd.  */
11993           for (section = input_bfd->sections;
11994                section != NULL;
11995                section = section->next)
11996             {
11997               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11998
11999               /* If there aren't any relocs, then there's nothing more
12000                  to do.  */
12001               if ((section->flags & SEC_RELOC) == 0
12002                   || (section->flags & SEC_ALLOC) == 0
12003                   || (section->flags & SEC_LOAD) == 0
12004                   || (section->flags & SEC_CODE) == 0
12005                   || section->reloc_count == 0)
12006                 continue;
12007
12008               /* If this section is a link-once section that will be
12009                  discarded, then don't create any stubs.  */
12010               if (section->output_section == NULL
12011                   || section->output_section->owner != info->output_bfd)
12012                 continue;
12013
12014               /* Get the relocs.  */
12015               internal_relocs
12016                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12017                                              info->keep_memory);
12018               if (internal_relocs == NULL)
12019                 goto error_ret_free_local;
12020
12021               /* Now examine each relocation.  */
12022               irela = internal_relocs;
12023               irelaend = irela + section->reloc_count;
12024               for (; irela < irelaend; irela++)
12025                 {
12026                   enum elf_ppc64_reloc_type r_type;
12027                   unsigned int r_indx;
12028                   enum ppc_stub_type stub_type;
12029                   struct ppc_stub_hash_entry *stub_entry;
12030                   asection *sym_sec, *code_sec;
12031                   bfd_vma sym_value, code_value;
12032                   bfd_vma destination;
12033                   unsigned long local_off;
12034                   bfd_boolean ok_dest;
12035                   struct ppc_link_hash_entry *hash;
12036                   struct ppc_link_hash_entry *fdh;
12037                   struct elf_link_hash_entry *h;
12038                   Elf_Internal_Sym *sym;
12039                   char *stub_name;
12040                   const asection *id_sec;
12041                   struct _opd_sec_data *opd;
12042                   struct plt_entry *plt_ent;
12043
12044                   r_type = ELF64_R_TYPE (irela->r_info);
12045                   r_indx = ELF64_R_SYM (irela->r_info);
12046
12047                   if (r_type >= R_PPC64_max)
12048                     {
12049                       bfd_set_error (bfd_error_bad_value);
12050                       goto error_ret_free_internal;
12051                     }
12052
12053                   /* Only look for stubs on branch instructions.  */
12054                   if (r_type != R_PPC64_REL24
12055                       && r_type != R_PPC64_REL14
12056                       && r_type != R_PPC64_REL14_BRTAKEN
12057                       && r_type != R_PPC64_REL14_BRNTAKEN)
12058                     continue;
12059
12060                   /* Now determine the call target, its name, value,
12061                      section.  */
12062                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12063                                   r_indx, input_bfd))
12064                     goto error_ret_free_internal;
12065                   hash = (struct ppc_link_hash_entry *) h;
12066
12067                   ok_dest = FALSE;
12068                   fdh = NULL;
12069                   sym_value = 0;
12070                   if (hash == NULL)
12071                     {
12072                       sym_value = sym->st_value;
12073                       ok_dest = TRUE;
12074                     }
12075                   else if (hash->elf.root.type == bfd_link_hash_defined
12076                            || hash->elf.root.type == bfd_link_hash_defweak)
12077                     {
12078                       sym_value = hash->elf.root.u.def.value;
12079                       if (sym_sec->output_section != NULL)
12080                         ok_dest = TRUE;
12081                     }
12082                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12083                            || hash->elf.root.type == bfd_link_hash_undefined)
12084                     {
12085                       /* Recognise an old ABI func code entry sym, and
12086                          use the func descriptor sym instead if it is
12087                          defined.  */
12088                       if (hash->elf.root.root.string[0] == '.'
12089                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12090                         {
12091                           if (fdh->elf.root.type == bfd_link_hash_defined
12092                               || fdh->elf.root.type == bfd_link_hash_defweak)
12093                             {
12094                               sym_sec = fdh->elf.root.u.def.section;
12095                               sym_value = fdh->elf.root.u.def.value;
12096                               if (sym_sec->output_section != NULL)
12097                                 ok_dest = TRUE;
12098                             }
12099                           else
12100                             fdh = NULL;
12101                         }
12102                     }
12103                   else
12104                     {
12105                       bfd_set_error (bfd_error_bad_value);
12106                       goto error_ret_free_internal;
12107                     }
12108
12109                   destination = 0;
12110                   local_off = 0;
12111                   if (ok_dest)
12112                     {
12113                       sym_value += irela->r_addend;
12114                       destination = (sym_value
12115                                      + sym_sec->output_offset
12116                                      + sym_sec->output_section->vma);
12117                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12118                                                             ? hash->elf.other
12119                                                             : sym->st_other);
12120                     }
12121
12122                   code_sec = sym_sec;
12123                   code_value = sym_value;
12124                   opd = get_opd_info (sym_sec);
12125                   if (opd != NULL)
12126                     {
12127                       bfd_vma dest;
12128
12129                       if (hash == NULL && opd->adjust != NULL)
12130                         {
12131                           long adjust = opd->adjust[sym_value / 8];
12132                           if (adjust == -1)
12133                             continue;
12134                           code_value += adjust;
12135                           sym_value += adjust;
12136                         }
12137                       dest = opd_entry_value (sym_sec, sym_value,
12138                                               &code_sec, &code_value, FALSE);
12139                       if (dest != (bfd_vma) -1)
12140                         {
12141                           destination = dest;
12142                           if (fdh != NULL)
12143                             {
12144                               /* Fixup old ABI sym to point at code
12145                                  entry.  */
12146                               hash->elf.root.type = bfd_link_hash_defweak;
12147                               hash->elf.root.u.def.section = code_sec;
12148                               hash->elf.root.u.def.value = code_value;
12149                             }
12150                         }
12151                     }
12152
12153                   /* Determine what (if any) linker stub is needed.  */
12154                   plt_ent = NULL;
12155                   stub_type = ppc_type_of_stub (section, irela, &hash,
12156                                                 &plt_ent, destination,
12157                                                 local_off);
12158
12159                   if (stub_type != ppc_stub_plt_call)
12160                     {
12161                       /* Check whether we need a TOC adjusting stub.
12162                          Since the linker pastes together pieces from
12163                          different object files when creating the
12164                          _init and _fini functions, it may be that a
12165                          call to what looks like a local sym is in
12166                          fact a call needing a TOC adjustment.  */
12167                       if (code_sec != NULL
12168                           && code_sec->output_section != NULL
12169                           && (htab->stub_group[code_sec->id].toc_off
12170                               != htab->stub_group[section->id].toc_off)
12171                           && (code_sec->has_toc_reloc
12172                               || code_sec->makes_toc_func_call))
12173                         stub_type = ppc_stub_long_branch_r2off;
12174                     }
12175
12176                   if (stub_type == ppc_stub_none)
12177                     continue;
12178
12179                   /* __tls_get_addr calls might be eliminated.  */
12180                   if (stub_type != ppc_stub_plt_call
12181                       && hash != NULL
12182                       && (hash == htab->tls_get_addr
12183                           || hash == htab->tls_get_addr_fd)
12184                       && section->has_tls_reloc
12185                       && irela != internal_relocs)
12186                     {
12187                       /* Get tls info.  */
12188                       unsigned char *tls_mask;
12189
12190                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12191                                          irela - 1, input_bfd))
12192                         goto error_ret_free_internal;
12193                       if (*tls_mask != 0)
12194                         continue;
12195                     }
12196
12197                   if (stub_type == ppc_stub_plt_call
12198                       && irela + 1 < irelaend
12199                       && irela[1].r_offset == irela->r_offset + 4
12200                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12201                     {
12202                       if (!tocsave_find (htab, INSERT,
12203                                          &local_syms, irela + 1, input_bfd))
12204                         goto error_ret_free_internal;
12205                     }
12206                   else if (stub_type == ppc_stub_plt_call)
12207                     stub_type = ppc_stub_plt_call_r2save;
12208
12209                   /* Support for grouping stub sections.  */
12210                   id_sec = htab->stub_group[section->id].link_sec;
12211
12212                   /* Get the name of this stub.  */
12213                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12214                   if (!stub_name)
12215                     goto error_ret_free_internal;
12216
12217                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12218                                                      stub_name, FALSE, FALSE);
12219                   if (stub_entry != NULL)
12220                     {
12221                       /* The proper stub has already been created.  */
12222                       free (stub_name);
12223                       if (stub_type == ppc_stub_plt_call_r2save)
12224                         stub_entry->stub_type = stub_type;
12225                       continue;
12226                     }
12227
12228                   stub_entry = ppc_add_stub (stub_name, section, info);
12229                   if (stub_entry == NULL)
12230                     {
12231                       free (stub_name);
12232                     error_ret_free_internal:
12233                       if (elf_section_data (section)->relocs == NULL)
12234                         free (internal_relocs);
12235                     error_ret_free_local:
12236                       if (local_syms != NULL
12237                           && (symtab_hdr->contents
12238                               != (unsigned char *) local_syms))
12239                         free (local_syms);
12240                       return FALSE;
12241                     }
12242
12243                   stub_entry->stub_type = stub_type;
12244                   if (stub_type != ppc_stub_plt_call
12245                       && stub_type != ppc_stub_plt_call_r2save)
12246                     {
12247                       stub_entry->target_value = code_value;
12248                       stub_entry->target_section = code_sec;
12249                     }
12250                   else
12251                     {
12252                       stub_entry->target_value = sym_value;
12253                       stub_entry->target_section = sym_sec;
12254                     }
12255                   stub_entry->h = hash;
12256                   stub_entry->plt_ent = plt_ent;
12257                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12258
12259                   if (stub_entry->h != NULL)
12260                     htab->stub_globals += 1;
12261                 }
12262
12263               /* We're done with the internal relocs, free them.  */
12264               if (elf_section_data (section)->relocs != internal_relocs)
12265                 free (internal_relocs);
12266             }
12267
12268           if (local_syms != NULL
12269               && symtab_hdr->contents != (unsigned char *) local_syms)
12270             {
12271               if (!info->keep_memory)
12272                 free (local_syms);
12273               else
12274                 symtab_hdr->contents = (unsigned char *) local_syms;
12275             }
12276         }
12277
12278       /* We may have added some stubs.  Find out the new size of the
12279          stub sections.  */
12280       for (stub_sec = htab->params->stub_bfd->sections;
12281            stub_sec != NULL;
12282            stub_sec = stub_sec->next)
12283         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12284           {
12285             stub_sec->rawsize = stub_sec->size;
12286             stub_sec->size = 0;
12287             stub_sec->reloc_count = 0;
12288             stub_sec->flags &= ~SEC_RELOC;
12289           }
12290
12291       htab->brlt->size = 0;
12292       htab->brlt->reloc_count = 0;
12293       htab->brlt->flags &= ~SEC_RELOC;
12294       if (htab->relbrlt != NULL)
12295         htab->relbrlt->size = 0;
12296
12297       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12298
12299       if (info->emitrelocations
12300           && htab->glink != NULL && htab->glink->size != 0)
12301         {
12302           htab->glink->reloc_count = 1;
12303           htab->glink->flags |= SEC_RELOC;
12304         }
12305
12306       if (htab->glink_eh_frame != NULL
12307           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12308           && htab->glink_eh_frame->output_section->size != 0)
12309         {
12310           size_t size = 0, align;
12311
12312           for (stub_sec = htab->params->stub_bfd->sections;
12313                stub_sec != NULL;
12314                stub_sec = stub_sec->next)
12315             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12316               size += 20;
12317           if (htab->glink != NULL && htab->glink->size != 0)
12318             size += 24;
12319           if (size != 0)
12320             size += sizeof (glink_eh_frame_cie);
12321           align = 1;
12322           align <<= htab->glink_eh_frame->output_section->alignment_power;
12323           align -= 1;
12324           size = (size + align) & ~align;
12325           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12326           htab->glink_eh_frame->size = size;
12327         }
12328
12329       if (htab->params->plt_stub_align != 0)
12330         for (stub_sec = htab->params->stub_bfd->sections;
12331              stub_sec != NULL;
12332              stub_sec = stub_sec->next)
12333           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12334             stub_sec->size = ((stub_sec->size
12335                                + (1 << htab->params->plt_stub_align) - 1)
12336                               & (-1 << htab->params->plt_stub_align));
12337
12338       for (stub_sec = htab->params->stub_bfd->sections;
12339            stub_sec != NULL;
12340            stub_sec = stub_sec->next)
12341         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12342             && stub_sec->rawsize != stub_sec->size)
12343           break;
12344
12345       /* Exit from this loop when no stubs have been added, and no stubs
12346          have changed size.  */
12347       if (stub_sec == NULL
12348           && (htab->glink_eh_frame == NULL
12349               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12350         break;
12351
12352       /* Ask the linker to do its stuff.  */
12353       (*htab->params->layout_sections_again) ();
12354     }
12355
12356   maybe_strip_output (info, htab->brlt);
12357   if (htab->glink_eh_frame != NULL)
12358     maybe_strip_output (info, htab->glink_eh_frame);
12359
12360   return TRUE;
12361 }
12362
12363 /* Called after we have determined section placement.  If sections
12364    move, we'll be called again.  Provide a value for TOCstart.  */
12365
12366 bfd_vma
12367 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12368 {
12369   asection *s;
12370   bfd_vma TOCstart;
12371
12372   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12373      order.  The TOC starts where the first of these sections starts.  */
12374   s = bfd_get_section_by_name (obfd, ".got");
12375   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12376     s = bfd_get_section_by_name (obfd, ".toc");
12377   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12378     s = bfd_get_section_by_name (obfd, ".tocbss");
12379   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12380     s = bfd_get_section_by_name (obfd, ".plt");
12381   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12382     {
12383       /* This may happen for
12384          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12385          .toc directive
12386          o  bad linker script
12387          o --gc-sections and empty TOC sections
12388
12389          FIXME: Warn user?  */
12390
12391       /* Look for a likely section.  We probably won't even be
12392          using TOCstart.  */
12393       for (s = obfd->sections; s != NULL; s = s->next)
12394         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12395                          | SEC_EXCLUDE))
12396             == (SEC_ALLOC | SEC_SMALL_DATA))
12397           break;
12398       if (s == NULL)
12399         for (s = obfd->sections; s != NULL; s = s->next)
12400           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12401               == (SEC_ALLOC | SEC_SMALL_DATA))
12402             break;
12403       if (s == NULL)
12404         for (s = obfd->sections; s != NULL; s = s->next)
12405           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12406               == SEC_ALLOC)
12407             break;
12408       if (s == NULL)
12409         for (s = obfd->sections; s != NULL; s = s->next)
12410           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12411             break;
12412     }
12413
12414   TOCstart = 0;
12415   if (s != NULL)
12416     TOCstart = s->output_section->vma + s->output_offset;
12417
12418   _bfd_set_gp_value (obfd, TOCstart);
12419
12420   if (info != NULL && s != NULL)
12421     {
12422       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12423
12424       if (htab != NULL)
12425         {
12426           if (htab->elf.hgot != NULL)
12427             {
12428               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12429               htab->elf.hgot->root.u.def.section = s;
12430             }
12431         }
12432       else
12433         {
12434           struct bfd_link_hash_entry *bh = NULL;
12435           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12436                                             s, TOC_BASE_OFF, NULL, FALSE,
12437                                             FALSE, &bh);
12438         }
12439     }
12440   return TOCstart;
12441 }
12442
12443 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12444    write out any global entry stubs.  */
12445
12446 static bfd_boolean
12447 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12448 {
12449   struct bfd_link_info *info;
12450   struct ppc_link_hash_table *htab;
12451   struct plt_entry *pent;
12452   asection *s;
12453
12454   if (h->root.type == bfd_link_hash_indirect)
12455     return TRUE;
12456
12457   if (!h->pointer_equality_needed)
12458     return TRUE;
12459
12460   if (h->def_regular)
12461     return TRUE;
12462
12463   info = inf;
12464   htab = ppc_hash_table (info);
12465   if (htab == NULL)
12466     return FALSE;
12467
12468   s = htab->glink;
12469   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12470     if (pent->plt.offset != (bfd_vma) -1
12471         && pent->addend == 0)
12472       {
12473         bfd_byte *p;
12474         asection *plt;
12475         bfd_vma off;
12476
12477         p = s->contents + h->root.u.def.value;
12478         plt = htab->elf.splt;
12479         if (!htab->elf.dynamic_sections_created
12480             || h->dynindx == -1)
12481           plt = htab->elf.iplt;
12482         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12483         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12484
12485         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12486           {
12487             info->callbacks->einfo
12488               (_("%P: linkage table error against `%T'\n"),
12489                h->root.root.string);
12490             bfd_set_error (bfd_error_bad_value);
12491             htab->stub_error = TRUE;
12492           }
12493
12494         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12495         if (htab->params->emit_stub_syms)
12496           {
12497             size_t len = strlen (h->root.root.string);
12498             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12499
12500             if (name == NULL)
12501               return FALSE;
12502
12503             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12504             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12505             if (h == NULL)
12506               return FALSE;
12507             if (h->root.type == bfd_link_hash_new)
12508               {
12509                 h->root.type = bfd_link_hash_defined;
12510                 h->root.u.def.section = s;
12511                 h->root.u.def.value = p - s->contents;
12512                 h->ref_regular = 1;
12513                 h->def_regular = 1;
12514                 h->ref_regular_nonweak = 1;
12515                 h->forced_local = 1;
12516                 h->non_elf = 0;
12517               }
12518           }
12519
12520         if (PPC_HA (off) != 0)
12521           {
12522             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12523             p += 4;
12524           }
12525         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12526         p += 4;
12527         bfd_put_32 (s->owner, MTCTR_R12, p);
12528         p += 4;
12529         bfd_put_32 (s->owner, BCTR, p);
12530         break;
12531       }
12532   return TRUE;
12533 }
12534
12535 /* Build all the stubs associated with the current output file.
12536    The stubs are kept in a hash table attached to the main linker
12537    hash table.  This function is called via gldelf64ppc_finish.  */
12538
12539 bfd_boolean
12540 ppc64_elf_build_stubs (struct bfd_link_info *info,
12541                        char **stats)
12542 {
12543   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12544   asection *stub_sec;
12545   bfd_byte *p;
12546   int stub_sec_count = 0;
12547
12548   if (htab == NULL)
12549     return FALSE;
12550
12551   /* Allocate memory to hold the linker stubs.  */
12552   for (stub_sec = htab->params->stub_bfd->sections;
12553        stub_sec != NULL;
12554        stub_sec = stub_sec->next)
12555     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12556         && stub_sec->size != 0)
12557       {
12558         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12559         if (stub_sec->contents == NULL)
12560           return FALSE;
12561         /* We want to check that built size is the same as calculated
12562            size.  rawsize is a convenient location to use.  */
12563         stub_sec->rawsize = stub_sec->size;
12564         stub_sec->size = 0;
12565       }
12566
12567   if (htab->glink != NULL && htab->glink->size != 0)
12568     {
12569       unsigned int indx;
12570       bfd_vma plt0;
12571
12572       /* Build the .glink plt call stub.  */
12573       if (htab->params->emit_stub_syms)
12574         {
12575           struct elf_link_hash_entry *h;
12576           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12577                                     TRUE, FALSE, FALSE);
12578           if (h == NULL)
12579             return FALSE;
12580           if (h->root.type == bfd_link_hash_new)
12581             {
12582               h->root.type = bfd_link_hash_defined;
12583               h->root.u.def.section = htab->glink;
12584               h->root.u.def.value = 8;
12585               h->ref_regular = 1;
12586               h->def_regular = 1;
12587               h->ref_regular_nonweak = 1;
12588               h->forced_local = 1;
12589               h->non_elf = 0;
12590             }
12591         }
12592       plt0 = (htab->elf.splt->output_section->vma
12593               + htab->elf.splt->output_offset
12594               - 16);
12595       if (info->emitrelocations)
12596         {
12597           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12598           if (r == NULL)
12599             return FALSE;
12600           r->r_offset = (htab->glink->output_offset
12601                          + htab->glink->output_section->vma);
12602           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12603           r->r_addend = plt0;
12604         }
12605       p = htab->glink->contents;
12606       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12607       bfd_put_64 (htab->glink->owner, plt0, p);
12608       p += 8;
12609       if (htab->opd_abi)
12610         {
12611           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12612           p += 4;
12613           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12614           p += 4;
12615           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12616           p += 4;
12617           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12618           p += 4;
12619           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12620           p += 4;
12621           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12622           p += 4;
12623           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12624           p += 4;
12625           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12626           p += 4;
12627           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12628           p += 4;
12629           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12630           p += 4;
12631         }
12632       else
12633         {
12634           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12635           p += 4;
12636           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12637           p += 4;
12638           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12639           p += 4;
12640           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12641           p += 4;
12642           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12643           p += 4;
12644           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12645           p += 4;
12646           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12647           p += 4;
12648           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12649           p += 4;
12650           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12651           p += 4;
12652           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12653           p += 4;
12654           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12655           p += 4;
12656           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12657           p += 4;
12658         }
12659       bfd_put_32 (htab->glink->owner, BCTR, p);
12660       p += 4;
12661       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12662         {
12663           bfd_put_32 (htab->glink->owner, NOP, p);
12664           p += 4;
12665         }
12666
12667       /* Build the .glink lazy link call stubs.  */
12668       indx = 0;
12669       while (p < htab->glink->contents + htab->glink->rawsize)
12670         {
12671           if (htab->opd_abi)
12672             {
12673               if (indx < 0x8000)
12674                 {
12675                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12676                   p += 4;
12677                 }
12678               else
12679                 {
12680                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12681                   p += 4;
12682                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12683                               p);
12684                   p += 4;
12685                 }
12686             }
12687           bfd_put_32 (htab->glink->owner,
12688                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12689           indx++;
12690           p += 4;
12691         }
12692
12693       /* Build .glink global entry stubs.  */
12694       if (htab->glink->size > htab->glink->rawsize)
12695         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12696     }
12697
12698   if (htab->brlt != NULL && htab->brlt->size != 0)
12699     {
12700       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12701                                          htab->brlt->size);
12702       if (htab->brlt->contents == NULL)
12703         return FALSE;
12704     }
12705   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12706     {
12707       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12708                                             htab->relbrlt->size);
12709       if (htab->relbrlt->contents == NULL)
12710         return FALSE;
12711     }
12712
12713   if (htab->glink_eh_frame != NULL
12714       && htab->glink_eh_frame->size != 0)
12715     {
12716       bfd_vma val;
12717       bfd_byte *last_fde;
12718       size_t last_fde_len, size, align, pad;
12719
12720       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12721       if (p == NULL)
12722         return FALSE;
12723       htab->glink_eh_frame->contents = p;
12724       last_fde = p;
12725
12726       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12727
12728       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12729       /* CIE length (rewrite in case little-endian).  */
12730       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12731       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12732       p += sizeof (glink_eh_frame_cie);
12733
12734       for (stub_sec = htab->params->stub_bfd->sections;
12735            stub_sec != NULL;
12736            stub_sec = stub_sec->next)
12737         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12738           {
12739             last_fde = p;
12740             last_fde_len = 16;
12741             /* FDE length.  */
12742             bfd_put_32 (htab->elf.dynobj, 16, p);
12743             p += 4;
12744             /* CIE pointer.  */
12745             val = p - htab->glink_eh_frame->contents;
12746             bfd_put_32 (htab->elf.dynobj, val, p);
12747             p += 4;
12748             /* Offset to stub section.  */
12749             val = (stub_sec->output_section->vma
12750                    + stub_sec->output_offset);
12751             val -= (htab->glink_eh_frame->output_section->vma
12752                     + htab->glink_eh_frame->output_offset);
12753             val -= p - htab->glink_eh_frame->contents;
12754             if (val + 0x80000000 > 0xffffffff)
12755               {
12756                 info->callbacks->einfo
12757                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12758                    stub_sec->name);
12759                 return FALSE;
12760               }
12761             bfd_put_32 (htab->elf.dynobj, val, p);
12762             p += 4;
12763             /* stub section size.  */
12764             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12765             p += 4;
12766             /* Augmentation.  */
12767             p += 1;
12768             /* Pad.  */
12769             p += 3;
12770           }
12771       if (htab->glink != NULL && htab->glink->size != 0)
12772         {
12773           last_fde = p;
12774           last_fde_len = 20;
12775           /* FDE length.  */
12776           bfd_put_32 (htab->elf.dynobj, 20, p);
12777           p += 4;
12778           /* CIE pointer.  */
12779           val = p - htab->glink_eh_frame->contents;
12780           bfd_put_32 (htab->elf.dynobj, val, p);
12781           p += 4;
12782           /* Offset to .glink.  */
12783           val = (htab->glink->output_section->vma
12784                  + htab->glink->output_offset
12785                  + 8);
12786           val -= (htab->glink_eh_frame->output_section->vma
12787                   + htab->glink_eh_frame->output_offset);
12788           val -= p - htab->glink_eh_frame->contents;
12789           if (val + 0x80000000 > 0xffffffff)
12790             {
12791               info->callbacks->einfo
12792                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12793                  htab->glink->name);
12794               return FALSE;
12795             }
12796           bfd_put_32 (htab->elf.dynobj, val, p);
12797           p += 4;
12798           /* .glink size.  */
12799           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12800           p += 4;
12801           /* Augmentation.  */
12802           p += 1;
12803
12804           *p++ = DW_CFA_advance_loc + 1;
12805           *p++ = DW_CFA_register;
12806           *p++ = 65;
12807           *p++ = 12;
12808           *p++ = DW_CFA_advance_loc + 4;
12809           *p++ = DW_CFA_restore_extended;
12810           *p++ = 65;
12811         }
12812       /* Subsume any padding into the last FDE if user .eh_frame
12813          sections are aligned more than glink_eh_frame.  Otherwise any
12814          zero padding will be seen as a terminator.  */
12815       size = p - htab->glink_eh_frame->contents;
12816       align = 1;
12817       align <<= htab->glink_eh_frame->output_section->alignment_power;
12818       align -= 1;
12819       pad = ((size + align) & ~align) - size;
12820       htab->glink_eh_frame->size = size + pad;
12821       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12822     }
12823
12824   /* Build the stubs as directed by the stub hash table.  */
12825   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12826
12827   if (htab->relbrlt != NULL)
12828     htab->relbrlt->reloc_count = 0;
12829
12830   if (htab->params->plt_stub_align != 0)
12831     for (stub_sec = htab->params->stub_bfd->sections;
12832          stub_sec != NULL;
12833          stub_sec = stub_sec->next)
12834       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12835         stub_sec->size = ((stub_sec->size
12836                            + (1 << htab->params->plt_stub_align) - 1)
12837                           & (-1 << htab->params->plt_stub_align));
12838
12839   for (stub_sec = htab->params->stub_bfd->sections;
12840        stub_sec != NULL;
12841        stub_sec = stub_sec->next)
12842     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12843       {
12844         stub_sec_count += 1;
12845         if (stub_sec->rawsize != stub_sec->size)
12846           break;
12847       }
12848
12849   if (stub_sec != NULL
12850       || (htab->glink_eh_frame != NULL
12851           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12852     {
12853       htab->stub_error = TRUE;
12854       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12855     }
12856
12857   if (htab->stub_error)
12858     return FALSE;
12859
12860   if (stats != NULL)
12861     {
12862       *stats = bfd_malloc (500);
12863       if (*stats == NULL)
12864         return FALSE;
12865
12866       sprintf (*stats, _("linker stubs in %u group%s\n"
12867                          "  branch       %lu\n"
12868                          "  toc adjust   %lu\n"
12869                          "  long branch  %lu\n"
12870                          "  long toc adj %lu\n"
12871                          "  plt call     %lu\n"
12872                          "  plt call toc %lu\n"
12873                          "  global entry %lu"),
12874                stub_sec_count,
12875                stub_sec_count == 1 ? "" : "s",
12876                htab->stub_count[ppc_stub_long_branch - 1],
12877                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12878                htab->stub_count[ppc_stub_plt_branch - 1],
12879                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12880                htab->stub_count[ppc_stub_plt_call - 1],
12881                htab->stub_count[ppc_stub_plt_call_r2save - 1],
12882                htab->stub_count[ppc_stub_global_entry - 1]);
12883     }
12884   return TRUE;
12885 }
12886
12887 /* This function undoes the changes made by add_symbol_adjust.  */
12888
12889 static bfd_boolean
12890 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12891 {
12892   struct ppc_link_hash_entry *eh;
12893
12894   if (h->root.type == bfd_link_hash_indirect)
12895     return TRUE;
12896
12897   eh = (struct ppc_link_hash_entry *) h;
12898   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12899     return TRUE;
12900
12901   eh->elf.root.type = bfd_link_hash_undefined;
12902   return TRUE;
12903 }
12904
12905 void
12906 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12907 {
12908   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12909
12910   if (htab != NULL)
12911     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12912 }
12913
12914 /* What to do when ld finds relocations against symbols defined in
12915    discarded sections.  */
12916
12917 static unsigned int
12918 ppc64_elf_action_discarded (asection *sec)
12919 {
12920   if (strcmp (".opd", sec->name) == 0)
12921     return 0;
12922
12923   if (strcmp (".toc", sec->name) == 0)
12924     return 0;
12925
12926   if (strcmp (".toc1", sec->name) == 0)
12927     return 0;
12928
12929   return _bfd_elf_default_action_discarded (sec);
12930 }
12931
12932 /* The RELOCATE_SECTION function is called by the ELF backend linker
12933    to handle the relocations for a section.
12934
12935    The relocs are always passed as Rela structures; if the section
12936    actually uses Rel structures, the r_addend field will always be
12937    zero.
12938
12939    This function is responsible for adjust the section contents as
12940    necessary, and (if using Rela relocs and generating a
12941    relocatable output file) adjusting the reloc addend as
12942    necessary.
12943
12944    This function does not have to worry about setting the reloc
12945    address or the reloc symbol index.
12946
12947    LOCAL_SYMS is a pointer to the swapped in local symbols.
12948
12949    LOCAL_SECTIONS is an array giving the section in the input file
12950    corresponding to the st_shndx field of each local symbol.
12951
12952    The global hash table entry for the global symbols can be found
12953    via elf_sym_hashes (input_bfd).
12954
12955    When generating relocatable output, this function must handle
12956    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12957    going to be the section symbol corresponding to the output
12958    section, which means that the addend must be adjusted
12959    accordingly.  */
12960
12961 static bfd_boolean
12962 ppc64_elf_relocate_section (bfd *output_bfd,
12963                             struct bfd_link_info *info,
12964                             bfd *input_bfd,
12965                             asection *input_section,
12966                             bfd_byte *contents,
12967                             Elf_Internal_Rela *relocs,
12968                             Elf_Internal_Sym *local_syms,
12969                             asection **local_sections)
12970 {
12971   struct ppc_link_hash_table *htab;
12972   Elf_Internal_Shdr *symtab_hdr;
12973   struct elf_link_hash_entry **sym_hashes;
12974   Elf_Internal_Rela *rel;
12975   Elf_Internal_Rela *relend;
12976   Elf_Internal_Rela outrel;
12977   bfd_byte *loc;
12978   struct got_entry **local_got_ents;
12979   bfd_vma TOCstart;
12980   bfd_boolean ret = TRUE;
12981   bfd_boolean is_opd;
12982   /* Assume 'at' branch hints.  */
12983   bfd_boolean is_isa_v2 = TRUE;
12984   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12985
12986   /* Initialize howto table if needed.  */
12987   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12988     ppc_howto_init ();
12989
12990   htab = ppc_hash_table (info);
12991   if (htab == NULL)
12992     return FALSE;
12993
12994   /* Don't relocate stub sections.  */
12995   if (input_section->owner == htab->params->stub_bfd)
12996     return TRUE;
12997
12998   BFD_ASSERT (is_ppc64_elf (input_bfd));
12999
13000   local_got_ents = elf_local_got_ents (input_bfd);
13001   TOCstart = elf_gp (output_bfd);
13002   symtab_hdr = &elf_symtab_hdr (input_bfd);
13003   sym_hashes = elf_sym_hashes (input_bfd);
13004   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13005
13006   rel = relocs;
13007   relend = relocs + input_section->reloc_count;
13008   for (; rel < relend; rel++)
13009     {
13010       enum elf_ppc64_reloc_type r_type;
13011       bfd_vma addend;
13012       bfd_reloc_status_type r;
13013       Elf_Internal_Sym *sym;
13014       asection *sec;
13015       struct elf_link_hash_entry *h_elf;
13016       struct ppc_link_hash_entry *h;
13017       struct ppc_link_hash_entry *fdh;
13018       const char *sym_name;
13019       unsigned long r_symndx, toc_symndx;
13020       bfd_vma toc_addend;
13021       unsigned char tls_mask, tls_gd, tls_type;
13022       unsigned char sym_type;
13023       bfd_vma relocation;
13024       bfd_boolean unresolved_reloc;
13025       bfd_boolean warned;
13026       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13027       unsigned int insn;
13028       unsigned int mask;
13029       struct ppc_stub_hash_entry *stub_entry;
13030       bfd_vma max_br_offset;
13031       bfd_vma from;
13032       const Elf_Internal_Rela orig_rel = *rel;
13033       reloc_howto_type *howto;
13034       struct reloc_howto_struct alt_howto;
13035
13036       r_type = ELF64_R_TYPE (rel->r_info);
13037       r_symndx = ELF64_R_SYM (rel->r_info);
13038
13039       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13040          symbol of the previous ADDR64 reloc.  The symbol gives us the
13041          proper TOC base to use.  */
13042       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13043           && rel != relocs
13044           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
13045           && is_opd)
13046         r_symndx = ELF64_R_SYM (rel[-1].r_info);
13047
13048       sym = NULL;
13049       sec = NULL;
13050       h_elf = NULL;
13051       sym_name = NULL;
13052       unresolved_reloc = FALSE;
13053       warned = FALSE;
13054
13055       if (r_symndx < symtab_hdr->sh_info)
13056         {
13057           /* It's a local symbol.  */
13058           struct _opd_sec_data *opd;
13059
13060           sym = local_syms + r_symndx;
13061           sec = local_sections[r_symndx];
13062           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13063           sym_type = ELF64_ST_TYPE (sym->st_info);
13064           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13065           opd = get_opd_info (sec);
13066           if (opd != NULL && opd->adjust != NULL)
13067             {
13068               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13069               if (adjust == -1)
13070                 relocation = 0;
13071               else
13072                 {
13073                   /* If this is a relocation against the opd section sym
13074                      and we have edited .opd, adjust the reloc addend so
13075                      that ld -r and ld --emit-relocs output is correct.
13076                      If it is a reloc against some other .opd symbol,
13077                      then the symbol value will be adjusted later.  */
13078                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13079                     rel->r_addend += adjust;
13080                   else
13081                     relocation += adjust;
13082                 }
13083             }
13084         }
13085       else
13086         {
13087           bfd_boolean ignored;
13088
13089           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13090                                    r_symndx, symtab_hdr, sym_hashes,
13091                                    h_elf, sec, relocation,
13092                                    unresolved_reloc, warned, ignored);
13093           sym_name = h_elf->root.root.string;
13094           sym_type = h_elf->type;
13095           if (sec != NULL
13096               && sec->owner == output_bfd
13097               && strcmp (sec->name, ".opd") == 0)
13098             {
13099               /* This is a symbol defined in a linker script.  All
13100                  such are defined in output sections, even those
13101                  defined by simple assignment from a symbol defined in
13102                  an input section.  Transfer the symbol to an
13103                  appropriate input .opd section, so that a branch to
13104                  this symbol will be mapped to the location specified
13105                  by the opd entry.  */
13106               struct bfd_link_order *lo;
13107               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13108                 if (lo->type == bfd_indirect_link_order)
13109                   {
13110                     asection *isec = lo->u.indirect.section;
13111                     if (h_elf->root.u.def.value >= isec->output_offset
13112                         && h_elf->root.u.def.value < (isec->output_offset
13113                                                       + isec->size))
13114                       {
13115                         h_elf->root.u.def.value -= isec->output_offset;
13116                         h_elf->root.u.def.section = isec;
13117                         sec = isec;
13118                         break;
13119                       }
13120                   }
13121             }
13122         }
13123       h = (struct ppc_link_hash_entry *) h_elf;
13124
13125       if (sec != NULL && discarded_section (sec))
13126         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13127                                          rel, 1, relend,
13128                                          ppc64_elf_howto_table[r_type], 0,
13129                                          contents);
13130
13131       if (info->relocatable)
13132         continue;
13133
13134       if (h != NULL && &h->elf == htab->elf.hgot)
13135         {
13136           relocation = (TOCstart
13137                         + htab->stub_group[input_section->id].toc_off);
13138           sec = bfd_abs_section_ptr;
13139           unresolved_reloc = FALSE;
13140         }
13141
13142       /* TLS optimizations.  Replace instruction sequences and relocs
13143          based on information we collected in tls_optimize.  We edit
13144          RELOCS so that --emit-relocs will output something sensible
13145          for the final instruction stream.  */
13146       tls_mask = 0;
13147       tls_gd = 0;
13148       toc_symndx = 0;
13149       if (h != NULL)
13150         tls_mask = h->tls_mask;
13151       else if (local_got_ents != NULL)
13152         {
13153           struct plt_entry **local_plt = (struct plt_entry **)
13154             (local_got_ents + symtab_hdr->sh_info);
13155           unsigned char *lgot_masks = (unsigned char *)
13156             (local_plt + symtab_hdr->sh_info);
13157           tls_mask = lgot_masks[r_symndx];
13158         }
13159       if (tls_mask == 0
13160           && (r_type == R_PPC64_TLS
13161               || r_type == R_PPC64_TLSGD
13162               || r_type == R_PPC64_TLSLD))
13163         {
13164           /* Check for toc tls entries.  */
13165           unsigned char *toc_tls;
13166
13167           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13168                              &local_syms, rel, input_bfd))
13169             return FALSE;
13170
13171           if (toc_tls)
13172             tls_mask = *toc_tls;
13173         }
13174
13175       /* Check that tls relocs are used with tls syms, and non-tls
13176          relocs are used with non-tls syms.  */
13177       if (r_symndx != STN_UNDEF
13178           && r_type != R_PPC64_NONE
13179           && (h == NULL
13180               || h->elf.root.type == bfd_link_hash_defined
13181               || h->elf.root.type == bfd_link_hash_defweak)
13182           && (IS_PPC64_TLS_RELOC (r_type)
13183               != (sym_type == STT_TLS
13184                   || (sym_type == STT_SECTION
13185                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13186         {
13187           if (tls_mask != 0
13188               && (r_type == R_PPC64_TLS
13189                   || r_type == R_PPC64_TLSGD
13190                   || r_type == R_PPC64_TLSLD))
13191             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13192             ;
13193           else
13194             info->callbacks->einfo
13195               (!IS_PPC64_TLS_RELOC (r_type)
13196                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13197                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13198                input_bfd, input_section, rel->r_offset,
13199                ppc64_elf_howto_table[r_type]->name,
13200                sym_name);
13201         }
13202
13203       /* Ensure reloc mapping code below stays sane.  */
13204       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13205           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13206           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13207           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13208           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13209           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13210           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13211           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13212           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13213           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13214         abort ();
13215
13216       switch (r_type)
13217         {
13218         default:
13219           break;
13220
13221         case R_PPC64_LO_DS_OPT:
13222           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13223           if ((insn & (0x3f << 26)) != 58u << 26)
13224             abort ();
13225           insn += (14u << 26) - (58u << 26);
13226           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13227           r_type = R_PPC64_TOC16_LO;
13228           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13229           break;
13230
13231         case R_PPC64_TOC16:
13232         case R_PPC64_TOC16_LO:
13233         case R_PPC64_TOC16_DS:
13234         case R_PPC64_TOC16_LO_DS:
13235           {
13236             /* Check for toc tls entries.  */
13237             unsigned char *toc_tls;
13238             int retval;
13239
13240             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13241                                    &local_syms, rel, input_bfd);
13242             if (retval == 0)
13243               return FALSE;
13244
13245             if (toc_tls)
13246               {
13247                 tls_mask = *toc_tls;
13248                 if (r_type == R_PPC64_TOC16_DS
13249                     || r_type == R_PPC64_TOC16_LO_DS)
13250                   {
13251                     if (tls_mask != 0
13252                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13253                       goto toctprel;
13254                   }
13255                 else
13256                   {
13257                     /* If we found a GD reloc pair, then we might be
13258                        doing a GD->IE transition.  */
13259                     if (retval == 2)
13260                       {
13261                         tls_gd = TLS_TPRELGD;
13262                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13263                           goto tls_ldgd_opt;
13264                       }
13265                     else if (retval == 3)
13266                       {
13267                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13268                           goto tls_ldgd_opt;
13269                       }
13270                   }
13271               }
13272           }
13273           break;
13274
13275         case R_PPC64_GOT_TPREL16_HI:
13276         case R_PPC64_GOT_TPREL16_HA:
13277           if (tls_mask != 0
13278               && (tls_mask & TLS_TPREL) == 0)
13279             {
13280               rel->r_offset -= d_offset;
13281               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13282               r_type = R_PPC64_NONE;
13283               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13284             }
13285           break;
13286
13287         case R_PPC64_GOT_TPREL16_DS:
13288         case R_PPC64_GOT_TPREL16_LO_DS:
13289           if (tls_mask != 0
13290               && (tls_mask & TLS_TPREL) == 0)
13291             {
13292             toctprel:
13293               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13294               insn &= 31 << 21;
13295               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13296               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13297               r_type = R_PPC64_TPREL16_HA;
13298               if (toc_symndx != 0)
13299                 {
13300                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13301                   rel->r_addend = toc_addend;
13302                   /* We changed the symbol.  Start over in order to
13303                      get h, sym, sec etc. right.  */
13304                   rel--;
13305                   continue;
13306                 }
13307               else
13308                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13309             }
13310           break;
13311
13312         case R_PPC64_TLS:
13313           if (tls_mask != 0
13314               && (tls_mask & TLS_TPREL) == 0)
13315             {
13316               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13317               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13318               if (insn == 0)
13319                 abort ();
13320               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13321               /* Was PPC64_TLS which sits on insn boundary, now
13322                  PPC64_TPREL16_LO which is at low-order half-word.  */
13323               rel->r_offset += d_offset;
13324               r_type = R_PPC64_TPREL16_LO;
13325               if (toc_symndx != 0)
13326                 {
13327                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13328                   rel->r_addend = toc_addend;
13329                   /* We changed the symbol.  Start over in order to
13330                      get h, sym, sec etc. right.  */
13331                   rel--;
13332                   continue;
13333                 }
13334               else
13335                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13336             }
13337           break;
13338
13339         case R_PPC64_GOT_TLSGD16_HI:
13340         case R_PPC64_GOT_TLSGD16_HA:
13341           tls_gd = TLS_TPRELGD;
13342           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13343             goto tls_gdld_hi;
13344           break;
13345
13346         case R_PPC64_GOT_TLSLD16_HI:
13347         case R_PPC64_GOT_TLSLD16_HA:
13348           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13349             {
13350             tls_gdld_hi:
13351               if ((tls_mask & tls_gd) != 0)
13352                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13353                           + R_PPC64_GOT_TPREL16_DS);
13354               else
13355                 {
13356                   rel->r_offset -= d_offset;
13357                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13358                   r_type = R_PPC64_NONE;
13359                 }
13360               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13361             }
13362           break;
13363
13364         case R_PPC64_GOT_TLSGD16:
13365         case R_PPC64_GOT_TLSGD16_LO:
13366           tls_gd = TLS_TPRELGD;
13367           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13368             goto tls_ldgd_opt;
13369           break;
13370
13371         case R_PPC64_GOT_TLSLD16:
13372         case R_PPC64_GOT_TLSLD16_LO:
13373           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13374             {
13375               unsigned int insn1, insn2, insn3;
13376               bfd_vma offset;
13377
13378             tls_ldgd_opt:
13379               offset = (bfd_vma) -1;
13380               /* If not using the newer R_PPC64_TLSGD/LD to mark
13381                  __tls_get_addr calls, we must trust that the call
13382                  stays with its arg setup insns, ie. that the next
13383                  reloc is the __tls_get_addr call associated with
13384                  the current reloc.  Edit both insns.  */
13385               if (input_section->has_tls_get_addr_call
13386                   && rel + 1 < relend
13387                   && branch_reloc_hash_match (input_bfd, rel + 1,
13388                                               htab->tls_get_addr,
13389                                               htab->tls_get_addr_fd))
13390                 offset = rel[1].r_offset;
13391               if ((tls_mask & tls_gd) != 0)
13392                 {
13393                   /* IE */
13394                   insn1 = bfd_get_32 (output_bfd,
13395                                       contents + rel->r_offset - d_offset);
13396                   insn1 &= (1 << 26) - (1 << 2);
13397                   insn1 |= 58 << 26;    /* ld */
13398                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13399                   if (offset != (bfd_vma) -1)
13400                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13401                   if ((tls_mask & TLS_EXPLICIT) == 0)
13402                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13403                               + R_PPC64_GOT_TPREL16_DS);
13404                   else
13405                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13406                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13407                 }
13408               else
13409                 {
13410                   /* LE */
13411                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13412                   insn2 = 0x38630000;   /* addi 3,3,0 */
13413                   if (tls_gd == 0)
13414                     {
13415                       /* Was an LD reloc.  */
13416                       if (toc_symndx)
13417                         sec = local_sections[toc_symndx];
13418                       for (r_symndx = 0;
13419                            r_symndx < symtab_hdr->sh_info;
13420                            r_symndx++)
13421                         if (local_sections[r_symndx] == sec)
13422                           break;
13423                       if (r_symndx >= symtab_hdr->sh_info)
13424                         r_symndx = STN_UNDEF;
13425                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13426                       if (r_symndx != STN_UNDEF)
13427                         rel->r_addend -= (local_syms[r_symndx].st_value
13428                                           + sec->output_offset
13429                                           + sec->output_section->vma);
13430                     }
13431                   else if (toc_symndx != 0)
13432                     {
13433                       r_symndx = toc_symndx;
13434                       rel->r_addend = toc_addend;
13435                     }
13436                   r_type = R_PPC64_TPREL16_HA;
13437                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13438                   if (offset != (bfd_vma) -1)
13439                     {
13440                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13441                                                     R_PPC64_TPREL16_LO);
13442                       rel[1].r_offset = offset + d_offset;
13443                       rel[1].r_addend = rel->r_addend;
13444                     }
13445                 }
13446               bfd_put_32 (output_bfd, insn1,
13447                           contents + rel->r_offset - d_offset);
13448               if (offset != (bfd_vma) -1)
13449                 {
13450                   insn3 = bfd_get_32 (output_bfd,
13451                                       contents + offset + 4);
13452                   if (insn3 == NOP
13453                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13454                     {
13455                       rel[1].r_offset += 4;
13456                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13457                       insn2 = NOP;
13458                     }
13459                   bfd_put_32 (output_bfd, insn2, contents + offset);
13460                 }
13461               if ((tls_mask & tls_gd) == 0
13462                   && (tls_gd == 0 || toc_symndx != 0))
13463                 {
13464                   /* We changed the symbol.  Start over in order
13465                      to get h, sym, sec etc. right.  */
13466                   rel--;
13467                   continue;
13468                 }
13469             }
13470           break;
13471
13472         case R_PPC64_TLSGD:
13473           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13474             {
13475               unsigned int insn2, insn3;
13476               bfd_vma offset = rel->r_offset;
13477
13478               if ((tls_mask & TLS_TPRELGD) != 0)
13479                 {
13480                   /* IE */
13481                   r_type = R_PPC64_NONE;
13482                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13483                 }
13484               else
13485                 {
13486                   /* LE */
13487                   if (toc_symndx != 0)
13488                     {
13489                       r_symndx = toc_symndx;
13490                       rel->r_addend = toc_addend;
13491                     }
13492                   r_type = R_PPC64_TPREL16_LO;
13493                   rel->r_offset = offset + d_offset;
13494                   insn2 = 0x38630000;   /* addi 3,3,0 */
13495                 }
13496               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13497               /* Zap the reloc on the _tls_get_addr call too.  */
13498               BFD_ASSERT (offset == rel[1].r_offset);
13499               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13500               insn3 = bfd_get_32 (output_bfd,
13501                                   contents + offset + 4);
13502               if (insn3 == NOP
13503                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13504                 {
13505                   rel->r_offset += 4;
13506                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13507                   insn2 = NOP;
13508                 }
13509               bfd_put_32 (output_bfd, insn2, contents + offset);
13510               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13511                 {
13512                   rel--;
13513                   continue;
13514                 }
13515             }
13516           break;
13517
13518         case R_PPC64_TLSLD:
13519           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13520             {
13521               unsigned int insn2, insn3;
13522               bfd_vma offset = rel->r_offset;
13523
13524               if (toc_symndx)
13525                 sec = local_sections[toc_symndx];
13526               for (r_symndx = 0;
13527                    r_symndx < symtab_hdr->sh_info;
13528                    r_symndx++)
13529                 if (local_sections[r_symndx] == sec)
13530                   break;
13531               if (r_symndx >= symtab_hdr->sh_info)
13532                 r_symndx = STN_UNDEF;
13533               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13534               if (r_symndx != STN_UNDEF)
13535                 rel->r_addend -= (local_syms[r_symndx].st_value
13536                                   + sec->output_offset
13537                                   + sec->output_section->vma);
13538
13539               r_type = R_PPC64_TPREL16_LO;
13540               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13541               rel->r_offset = offset + d_offset;
13542               /* Zap the reloc on the _tls_get_addr call too.  */
13543               BFD_ASSERT (offset == rel[1].r_offset);
13544               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13545               insn2 = 0x38630000;       /* addi 3,3,0 */
13546               insn3 = bfd_get_32 (output_bfd,
13547                                   contents + offset + 4);
13548               if (insn3 == NOP
13549                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13550                 {
13551                   rel->r_offset += 4;
13552                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13553                   insn2 = NOP;
13554                 }
13555               bfd_put_32 (output_bfd, insn2, contents + offset);
13556               rel--;
13557               continue;
13558             }
13559           break;
13560
13561         case R_PPC64_DTPMOD64:
13562           if (rel + 1 < relend
13563               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13564               && rel[1].r_offset == rel->r_offset + 8)
13565             {
13566               if ((tls_mask & TLS_GD) == 0)
13567                 {
13568                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13569                   if ((tls_mask & TLS_TPRELGD) != 0)
13570                     r_type = R_PPC64_TPREL64;
13571                   else
13572                     {
13573                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13574                       r_type = R_PPC64_NONE;
13575                     }
13576                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13577                 }
13578             }
13579           else
13580             {
13581               if ((tls_mask & TLS_LD) == 0)
13582                 {
13583                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13584                   r_type = R_PPC64_NONE;
13585                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13586                 }
13587             }
13588           break;
13589
13590         case R_PPC64_TPREL64:
13591           if ((tls_mask & TLS_TPREL) == 0)
13592             {
13593               r_type = R_PPC64_NONE;
13594               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13595             }
13596           break;
13597
13598         case R_PPC64_REL16_HA:
13599           /* If we are generating a non-PIC executable, edit
13600              .  0:      addis 2,12,.TOC.-0b@ha
13601              .          addi 2,2,.TOC.-0b@l
13602              used by ELFv2 global entry points to set up r2, to
13603              .          lis 2,.TOC.@ha
13604              .          addi 2,2,.TOC.@l
13605              if .TOC. is in range.  */
13606           if (!info->shared
13607               && !info->traditional_format
13608               && h != NULL && &h->elf == htab->elf.hgot
13609               && rel + 1 < relend
13610               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13611               && rel[1].r_offset == rel->r_offset + 4
13612               && rel[1].r_addend == rel->r_addend + 4
13613               && relocation + 0x80008000 <= 0xffffffff)
13614             {
13615               unsigned int insn1, insn2;
13616               bfd_vma offset = rel->r_offset - d_offset;
13617               insn1 = bfd_get_32 (output_bfd, contents + offset);
13618               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13619               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13620                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13621                 {
13622                   r_type = R_PPC64_ADDR16_HA;
13623                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13624                   rel->r_addend -= d_offset;
13625                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13626                   rel[1].r_addend -= d_offset + 4;
13627                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13628                 }
13629             }
13630           break;
13631         }
13632
13633       /* Handle other relocations that tweak non-addend part of insn.  */
13634       insn = 0;
13635       max_br_offset = 1 << 25;
13636       addend = rel->r_addend;
13637       reloc_dest = DEST_NORMAL;
13638       switch (r_type)
13639         {
13640         default:
13641           break;
13642
13643         case R_PPC64_TOCSAVE:
13644           if (relocation + addend == (rel->r_offset
13645                                       + input_section->output_offset
13646                                       + input_section->output_section->vma)
13647               && tocsave_find (htab, NO_INSERT,
13648                                &local_syms, rel, input_bfd))
13649             {
13650               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13651               if (insn == NOP
13652                   || insn == CROR_151515 || insn == CROR_313131)
13653                 bfd_put_32 (input_bfd,
13654                             STD_R2_0R1 + STK_TOC (htab),
13655                             contents + rel->r_offset);
13656             }
13657           break;
13658
13659           /* Branch taken prediction relocations.  */
13660         case R_PPC64_ADDR14_BRTAKEN:
13661         case R_PPC64_REL14_BRTAKEN:
13662           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13663           /* Fall thru.  */
13664
13665           /* Branch not taken prediction relocations.  */
13666         case R_PPC64_ADDR14_BRNTAKEN:
13667         case R_PPC64_REL14_BRNTAKEN:
13668           insn |= bfd_get_32 (output_bfd,
13669                               contents + rel->r_offset) & ~(0x01 << 21);
13670           /* Fall thru.  */
13671
13672         case R_PPC64_REL14:
13673           max_br_offset = 1 << 15;
13674           /* Fall thru.  */
13675
13676         case R_PPC64_REL24:
13677           /* Calls to functions with a different TOC, such as calls to
13678              shared objects, need to alter the TOC pointer.  This is
13679              done using a linkage stub.  A REL24 branching to these
13680              linkage stubs needs to be followed by a nop, as the nop
13681              will be replaced with an instruction to restore the TOC
13682              base pointer.  */
13683           fdh = h;
13684           if (h != NULL
13685               && h->oh != NULL
13686               && h->oh->is_func_descriptor)
13687             fdh = ppc_follow_link (h->oh);
13688           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13689                                            htab);
13690           if (stub_entry != NULL
13691               && (stub_entry->stub_type == ppc_stub_plt_call
13692                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13693                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13694                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13695             {
13696               bfd_boolean can_plt_call = FALSE;
13697
13698               /* All of these stubs will modify r2, so there must be a
13699                  branch and link followed by a nop.  The nop is
13700                  replaced by an insn to restore r2.  */
13701               if (rel->r_offset + 8 <= input_section->size)
13702                 {
13703                   unsigned long br;
13704
13705                   br = bfd_get_32 (input_bfd,
13706                                    contents + rel->r_offset);
13707                   if ((br & 1) != 0)
13708                     {
13709                       unsigned long nop;
13710
13711                       nop = bfd_get_32 (input_bfd,
13712                                         contents + rel->r_offset + 4);
13713                       if (nop == NOP
13714                           || nop == CROR_151515 || nop == CROR_313131)
13715                         {
13716                           if (h != NULL
13717                               && (h == htab->tls_get_addr_fd
13718                                   || h == htab->tls_get_addr)
13719                               && !htab->params->no_tls_get_addr_opt)
13720                             {
13721                               /* Special stub used, leave nop alone.  */
13722                             }
13723                           else
13724                             bfd_put_32 (input_bfd,
13725                                         LD_R2_0R1 + STK_TOC (htab),
13726                                         contents + rel->r_offset + 4);
13727                           can_plt_call = TRUE;
13728                         }
13729                     }
13730                 }
13731
13732               if (!can_plt_call && h != NULL)
13733                 {
13734                   const char *name = h->elf.root.root.string;
13735
13736                   if (*name == '.')
13737                     ++name;
13738
13739                   if (strncmp (name, "__libc_start_main", 17) == 0
13740                       && (name[17] == 0 || name[17] == '@'))
13741                     {
13742                       /* Allow crt1 branch to go via a toc adjusting
13743                          stub.  Other calls that never return could do
13744                          the same, if we could detect such.  */
13745                       can_plt_call = TRUE;
13746                     }
13747                 }
13748
13749               if (!can_plt_call)
13750                 {
13751                   /* g++ as of 20130507 emits self-calls without a
13752                      following nop.  This is arguably wrong since we
13753                      have conflicting information.  On the one hand a
13754                      global symbol and on the other a local call
13755                      sequence, but don't error for this special case.
13756                      It isn't possible to cheaply verify we have
13757                      exactly such a call.  Allow all calls to the same
13758                      section.  */
13759                   asection *code_sec = sec;
13760
13761                   if (get_opd_info (sec) != NULL)
13762                     {
13763                       bfd_vma off = (relocation + addend
13764                                      - sec->output_section->vma
13765                                      - sec->output_offset);
13766
13767                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13768                     }
13769                   if (code_sec == input_section)
13770                     can_plt_call = TRUE;
13771                 }
13772
13773               if (!can_plt_call)
13774                 {
13775                   info->callbacks->einfo
13776                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13777                        "recompile with -fPIC\n"),
13778                      input_bfd, input_section, rel->r_offset, sym_name);
13779
13780                   bfd_set_error (bfd_error_bad_value);
13781                   ret = FALSE;
13782                 }
13783
13784               if (can_plt_call
13785                   && (stub_entry->stub_type == ppc_stub_plt_call
13786                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13787                 unresolved_reloc = FALSE;
13788             }
13789
13790           if ((stub_entry == NULL
13791                || stub_entry->stub_type == ppc_stub_long_branch
13792                || stub_entry->stub_type == ppc_stub_plt_branch)
13793               && get_opd_info (sec) != NULL)
13794             {
13795               /* The branch destination is the value of the opd entry. */
13796               bfd_vma off = (relocation + addend
13797                              - sec->output_section->vma
13798                              - sec->output_offset);
13799               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13800               if (dest != (bfd_vma) -1)
13801                 {
13802                   relocation = dest;
13803                   addend = 0;
13804                   reloc_dest = DEST_OPD;
13805                 }
13806             }
13807
13808           /* If the branch is out of reach we ought to have a long
13809              branch stub.  */
13810           from = (rel->r_offset
13811                   + input_section->output_offset
13812                   + input_section->output_section->vma);
13813
13814           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13815                                                   ? fdh->elf.other
13816                                                   : sym->st_other);
13817
13818           if (stub_entry != NULL
13819               && (stub_entry->stub_type == ppc_stub_long_branch
13820                   || stub_entry->stub_type == ppc_stub_plt_branch)
13821               && (r_type == R_PPC64_ADDR14_BRTAKEN
13822                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13823                   || (relocation + addend - from + max_br_offset
13824                       < 2 * max_br_offset)))
13825             /* Don't use the stub if this branch is in range.  */
13826             stub_entry = NULL;
13827
13828           if (stub_entry != NULL)
13829             {
13830               /* Munge up the value and addend so that we call the stub
13831                  rather than the procedure directly.  */
13832               relocation = (stub_entry->stub_offset
13833                             + stub_entry->stub_sec->output_offset
13834                             + stub_entry->stub_sec->output_section->vma);
13835               addend = 0;
13836               reloc_dest = DEST_STUB;
13837
13838               if ((stub_entry->stub_type == ppc_stub_plt_call
13839                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13840                   && (ALWAYS_EMIT_R2SAVE
13841                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13842                   && rel + 1 < relend
13843                   && rel[1].r_offset == rel->r_offset + 4
13844                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13845                 relocation += 4;
13846             }
13847
13848           if (insn != 0)
13849             {
13850               if (is_isa_v2)
13851                 {
13852                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13853                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13854                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13855                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13856                     insn |= 0x02 << 21;
13857                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13858                     insn |= 0x08 << 21;
13859                   else
13860                     break;
13861                 }
13862               else
13863                 {
13864                   /* Invert 'y' bit if not the default.  */
13865                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13866                     insn ^= 0x01 << 21;
13867                 }
13868
13869               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13870             }
13871
13872           /* NOP out calls to undefined weak functions.
13873              We can thus call a weak function without first
13874              checking whether the function is defined.  */
13875           else if (h != NULL
13876                    && h->elf.root.type == bfd_link_hash_undefweak
13877                    && h->elf.dynindx == -1
13878                    && r_type == R_PPC64_REL24
13879                    && relocation == 0
13880                    && addend == 0)
13881             {
13882               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13883               continue;
13884             }
13885           break;
13886         }
13887
13888       /* Set `addend'.  */
13889       tls_type = 0;
13890       switch (r_type)
13891         {
13892         default:
13893           info->callbacks->einfo
13894             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13895              input_bfd, (int) r_type, sym_name);
13896
13897           bfd_set_error (bfd_error_bad_value);
13898           ret = FALSE;
13899           continue;
13900
13901         case R_PPC64_NONE:
13902         case R_PPC64_TLS:
13903         case R_PPC64_TLSGD:
13904         case R_PPC64_TLSLD:
13905         case R_PPC64_TOCSAVE:
13906         case R_PPC64_GNU_VTINHERIT:
13907         case R_PPC64_GNU_VTENTRY:
13908           continue;
13909
13910           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13911              address in the GOT as relocation value instead of the
13912              symbol's value itself.  Also, create a GOT entry for the
13913              symbol and put the symbol value there.  */
13914         case R_PPC64_GOT_TLSGD16:
13915         case R_PPC64_GOT_TLSGD16_LO:
13916         case R_PPC64_GOT_TLSGD16_HI:
13917         case R_PPC64_GOT_TLSGD16_HA:
13918           tls_type = TLS_TLS | TLS_GD;
13919           goto dogot;
13920
13921         case R_PPC64_GOT_TLSLD16:
13922         case R_PPC64_GOT_TLSLD16_LO:
13923         case R_PPC64_GOT_TLSLD16_HI:
13924         case R_PPC64_GOT_TLSLD16_HA:
13925           tls_type = TLS_TLS | TLS_LD;
13926           goto dogot;
13927
13928         case R_PPC64_GOT_TPREL16_DS:
13929         case R_PPC64_GOT_TPREL16_LO_DS:
13930         case R_PPC64_GOT_TPREL16_HI:
13931         case R_PPC64_GOT_TPREL16_HA:
13932           tls_type = TLS_TLS | TLS_TPREL;
13933           goto dogot;
13934
13935         case R_PPC64_GOT_DTPREL16_DS:
13936         case R_PPC64_GOT_DTPREL16_LO_DS:
13937         case R_PPC64_GOT_DTPREL16_HI:
13938         case R_PPC64_GOT_DTPREL16_HA:
13939           tls_type = TLS_TLS | TLS_DTPREL;
13940           goto dogot;
13941
13942         case R_PPC64_GOT16:
13943         case R_PPC64_GOT16_LO:
13944         case R_PPC64_GOT16_HI:
13945         case R_PPC64_GOT16_HA:
13946         case R_PPC64_GOT16_DS:
13947         case R_PPC64_GOT16_LO_DS:
13948         dogot:
13949           {
13950             /* Relocation is to the entry for this symbol in the global
13951                offset table.  */
13952             asection *got;
13953             bfd_vma *offp;
13954             bfd_vma off;
13955             unsigned long indx = 0;
13956             struct got_entry *ent;
13957
13958             if (tls_type == (TLS_TLS | TLS_LD)
13959                 && (h == NULL
13960                     || !h->elf.def_dynamic))
13961               ent = ppc64_tlsld_got (input_bfd);
13962             else
13963               {
13964
13965                 if (h != NULL)
13966                   {
13967                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13968                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13969                                                           &h->elf)
13970                         || (info->shared
13971                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13972                       /* This is actually a static link, or it is a
13973                          -Bsymbolic link and the symbol is defined
13974                          locally, or the symbol was forced to be local
13975                          because of a version file.  */
13976                       ;
13977                     else
13978                       {
13979                         BFD_ASSERT (h->elf.dynindx != -1);
13980                         indx = h->elf.dynindx;
13981                         unresolved_reloc = FALSE;
13982                       }
13983                     ent = h->elf.got.glist;
13984                   }
13985                 else
13986                   {
13987                     if (local_got_ents == NULL)
13988                       abort ();
13989                     ent = local_got_ents[r_symndx];
13990                   }
13991
13992                 for (; ent != NULL; ent = ent->next)
13993                   if (ent->addend == orig_rel.r_addend
13994                       && ent->owner == input_bfd
13995                       && ent->tls_type == tls_type)
13996                     break;
13997               }
13998
13999             if (ent == NULL)
14000               abort ();
14001             if (ent->is_indirect)
14002               ent = ent->got.ent;
14003             offp = &ent->got.offset;
14004             got = ppc64_elf_tdata (ent->owner)->got;
14005             if (got == NULL)
14006               abort ();
14007
14008             /* The offset must always be a multiple of 8.  We use the
14009                least significant bit to record whether we have already
14010                processed this entry.  */
14011             off = *offp;
14012             if ((off & 1) != 0)
14013               off &= ~1;
14014             else
14015               {
14016                 /* Generate relocs for the dynamic linker, except in
14017                    the case of TLSLD where we'll use one entry per
14018                    module.  */
14019                 asection *relgot;
14020                 bfd_boolean ifunc;
14021
14022                 *offp = off | 1;
14023                 relgot = NULL;
14024                 ifunc = (h != NULL
14025                          ? h->elf.type == STT_GNU_IFUNC
14026                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14027                 if (ifunc)
14028                   relgot = htab->elf.irelplt;
14029                 else if ((info->shared || indx != 0)
14030                          && (h == NULL
14031                              || (tls_type == (TLS_TLS | TLS_LD)
14032                                  && !h->elf.def_dynamic)
14033                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14034                              || h->elf.root.type != bfd_link_hash_undefweak))
14035                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14036                 if (relgot != NULL)
14037                   {
14038                     outrel.r_offset = (got->output_section->vma
14039                                        + got->output_offset
14040                                        + off);
14041                     outrel.r_addend = addend;
14042                     if (tls_type & (TLS_LD | TLS_GD))
14043                       {
14044                         outrel.r_addend = 0;
14045                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14046                         if (tls_type == (TLS_TLS | TLS_GD))
14047                           {
14048                             loc = relgot->contents;
14049                             loc += (relgot->reloc_count++
14050                                     * sizeof (Elf64_External_Rela));
14051                             bfd_elf64_swap_reloca_out (output_bfd,
14052                                                        &outrel, loc);
14053                             outrel.r_offset += 8;
14054                             outrel.r_addend = addend;
14055                             outrel.r_info
14056                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14057                           }
14058                       }
14059                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14060                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14061                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14062                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14063                     else if (indx != 0)
14064                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14065                     else
14066                       {
14067                         if (ifunc)
14068                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14069                         else
14070                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14071
14072                         /* Write the .got section contents for the sake
14073                            of prelink.  */
14074                         loc = got->contents + off;
14075                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14076                                     loc);
14077                       }
14078
14079                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14080                       {
14081                         outrel.r_addend += relocation;
14082                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14083                           outrel.r_addend -= htab->elf.tls_sec->vma;
14084                       }
14085                     loc = relgot->contents;
14086                     loc += (relgot->reloc_count++
14087                             * sizeof (Elf64_External_Rela));
14088                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14089                   }
14090
14091                 /* Init the .got section contents here if we're not
14092                    emitting a reloc.  */
14093                 else
14094                   {
14095                     relocation += addend;
14096                     if (tls_type == (TLS_TLS | TLS_LD))
14097                       relocation = 1;
14098                     else if (tls_type != 0)
14099                       {
14100                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14101                         if (tls_type == (TLS_TLS | TLS_TPREL))
14102                           relocation += DTP_OFFSET - TP_OFFSET;
14103
14104                         if (tls_type == (TLS_TLS | TLS_GD))
14105                           {
14106                             bfd_put_64 (output_bfd, relocation,
14107                                         got->contents + off + 8);
14108                             relocation = 1;
14109                           }
14110                       }
14111
14112                     bfd_put_64 (output_bfd, relocation,
14113                                 got->contents + off);
14114                   }
14115               }
14116
14117             if (off >= (bfd_vma) -2)
14118               abort ();
14119
14120             relocation = got->output_section->vma + got->output_offset + off;
14121             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14122           }
14123           break;
14124
14125         case R_PPC64_PLT16_HA:
14126         case R_PPC64_PLT16_HI:
14127         case R_PPC64_PLT16_LO:
14128         case R_PPC64_PLT32:
14129         case R_PPC64_PLT64:
14130           /* Relocation is to the entry for this symbol in the
14131              procedure linkage table.  */
14132
14133           /* Resolve a PLT reloc against a local symbol directly,
14134              without using the procedure linkage table.  */
14135           if (h == NULL)
14136             break;
14137
14138           /* It's possible that we didn't make a PLT entry for this
14139              symbol.  This happens when statically linking PIC code,
14140              or when using -Bsymbolic.  Go find a match if there is a
14141              PLT entry.  */
14142           if (htab->elf.splt != NULL)
14143             {
14144               struct plt_entry *ent;
14145               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14146                 if (ent->plt.offset != (bfd_vma) -1
14147                     && ent->addend == orig_rel.r_addend)
14148                   {
14149                     relocation = (htab->elf.splt->output_section->vma
14150                                   + htab->elf.splt->output_offset
14151                                   + ent->plt.offset);
14152                     unresolved_reloc = FALSE;
14153                     break;
14154                   }
14155             }
14156           break;
14157
14158         case R_PPC64_TOC:
14159           /* Relocation value is TOC base.  */
14160           relocation = TOCstart;
14161           if (r_symndx == STN_UNDEF)
14162             relocation += htab->stub_group[input_section->id].toc_off;
14163           else if (unresolved_reloc)
14164             ;
14165           else if (sec != NULL && sec->id <= htab->top_id)
14166             relocation += htab->stub_group[sec->id].toc_off;
14167           else
14168             unresolved_reloc = TRUE;
14169           goto dodyn;
14170
14171           /* TOC16 relocs.  We want the offset relative to the TOC base,
14172              which is the address of the start of the TOC plus 0x8000.
14173              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14174              in this order.  */
14175         case R_PPC64_TOC16:
14176         case R_PPC64_TOC16_LO:
14177         case R_PPC64_TOC16_HI:
14178         case R_PPC64_TOC16_DS:
14179         case R_PPC64_TOC16_LO_DS:
14180         case R_PPC64_TOC16_HA:
14181           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14182           break;
14183
14184           /* Relocate against the beginning of the section.  */
14185         case R_PPC64_SECTOFF:
14186         case R_PPC64_SECTOFF_LO:
14187         case R_PPC64_SECTOFF_HI:
14188         case R_PPC64_SECTOFF_DS:
14189         case R_PPC64_SECTOFF_LO_DS:
14190         case R_PPC64_SECTOFF_HA:
14191           if (sec != NULL)
14192             addend -= sec->output_section->vma;
14193           break;
14194
14195         case R_PPC64_REL16:
14196         case R_PPC64_REL16_LO:
14197         case R_PPC64_REL16_HI:
14198         case R_PPC64_REL16_HA:
14199           break;
14200
14201         case R_PPC64_REL14:
14202         case R_PPC64_REL14_BRNTAKEN:
14203         case R_PPC64_REL14_BRTAKEN:
14204         case R_PPC64_REL24:
14205           break;
14206
14207         case R_PPC64_TPREL16:
14208         case R_PPC64_TPREL16_LO:
14209         case R_PPC64_TPREL16_HI:
14210         case R_PPC64_TPREL16_HA:
14211         case R_PPC64_TPREL16_DS:
14212         case R_PPC64_TPREL16_LO_DS:
14213         case R_PPC64_TPREL16_HIGH:
14214         case R_PPC64_TPREL16_HIGHA:
14215         case R_PPC64_TPREL16_HIGHER:
14216         case R_PPC64_TPREL16_HIGHERA:
14217         case R_PPC64_TPREL16_HIGHEST:
14218         case R_PPC64_TPREL16_HIGHESTA:
14219           if (h != NULL
14220               && h->elf.root.type == bfd_link_hash_undefweak
14221               && h->elf.dynindx == -1)
14222             {
14223               /* Make this relocation against an undefined weak symbol
14224                  resolve to zero.  This is really just a tweak, since
14225                  code using weak externs ought to check that they are
14226                  defined before using them.  */
14227               bfd_byte *p = contents + rel->r_offset - d_offset;
14228
14229               insn = bfd_get_32 (output_bfd, p);
14230               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14231               if (insn != 0)
14232                 bfd_put_32 (output_bfd, insn, p);
14233               break;
14234             }
14235           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14236           if (info->shared)
14237             /* The TPREL16 relocs shouldn't really be used in shared
14238                libs as they will result in DT_TEXTREL being set, but
14239                support them anyway.  */
14240             goto dodyn;
14241           break;
14242
14243         case R_PPC64_DTPREL16:
14244         case R_PPC64_DTPREL16_LO:
14245         case R_PPC64_DTPREL16_HI:
14246         case R_PPC64_DTPREL16_HA:
14247         case R_PPC64_DTPREL16_DS:
14248         case R_PPC64_DTPREL16_LO_DS:
14249         case R_PPC64_DTPREL16_HIGH:
14250         case R_PPC64_DTPREL16_HIGHA:
14251         case R_PPC64_DTPREL16_HIGHER:
14252         case R_PPC64_DTPREL16_HIGHERA:
14253         case R_PPC64_DTPREL16_HIGHEST:
14254         case R_PPC64_DTPREL16_HIGHESTA:
14255           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14256           break;
14257
14258         case R_PPC64_ADDR64_LOCAL:
14259           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14260                                               ? h->elf.other
14261                                               : sym->st_other);
14262           break;
14263
14264         case R_PPC64_DTPMOD64:
14265           relocation = 1;
14266           addend = 0;
14267           goto dodyn;
14268
14269         case R_PPC64_TPREL64:
14270           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14271           goto dodyn;
14272
14273         case R_PPC64_DTPREL64:
14274           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14275           /* Fall thru */
14276
14277           /* Relocations that may need to be propagated if this is a
14278              dynamic object.  */
14279         case R_PPC64_REL30:
14280         case R_PPC64_REL32:
14281         case R_PPC64_REL64:
14282         case R_PPC64_ADDR14:
14283         case R_PPC64_ADDR14_BRNTAKEN:
14284         case R_PPC64_ADDR14_BRTAKEN:
14285         case R_PPC64_ADDR16:
14286         case R_PPC64_ADDR16_DS:
14287         case R_PPC64_ADDR16_HA:
14288         case R_PPC64_ADDR16_HI:
14289         case R_PPC64_ADDR16_HIGH:
14290         case R_PPC64_ADDR16_HIGHA:
14291         case R_PPC64_ADDR16_HIGHER:
14292         case R_PPC64_ADDR16_HIGHERA:
14293         case R_PPC64_ADDR16_HIGHEST:
14294         case R_PPC64_ADDR16_HIGHESTA:
14295         case R_PPC64_ADDR16_LO:
14296         case R_PPC64_ADDR16_LO_DS:
14297         case R_PPC64_ADDR24:
14298         case R_PPC64_ADDR32:
14299         case R_PPC64_ADDR64:
14300         case R_PPC64_UADDR16:
14301         case R_PPC64_UADDR32:
14302         case R_PPC64_UADDR64:
14303         dodyn:
14304           if ((input_section->flags & SEC_ALLOC) == 0)
14305             break;
14306
14307           if (NO_OPD_RELOCS && is_opd)
14308             break;
14309
14310           if ((info->shared
14311                && (h == NULL
14312                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14313                    || h->elf.root.type != bfd_link_hash_undefweak)
14314                && (must_be_dyn_reloc (info, r_type)
14315                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14316               || (ELIMINATE_COPY_RELOCS
14317                   && !info->shared
14318                   && h != NULL
14319                   && h->elf.dynindx != -1
14320                   && !h->elf.non_got_ref
14321                   && !h->elf.def_regular)
14322               || (!info->shared
14323                   && (h != NULL
14324                       ? h->elf.type == STT_GNU_IFUNC
14325                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14326             {
14327               bfd_boolean skip, relocate;
14328               asection *sreloc;
14329               bfd_vma out_off;
14330
14331               /* When generating a dynamic object, these relocations
14332                  are copied into the output file to be resolved at run
14333                  time.  */
14334
14335               skip = FALSE;
14336               relocate = FALSE;
14337
14338               out_off = _bfd_elf_section_offset (output_bfd, info,
14339                                                  input_section, rel->r_offset);
14340               if (out_off == (bfd_vma) -1)
14341                 skip = TRUE;
14342               else if (out_off == (bfd_vma) -2)
14343                 skip = TRUE, relocate = TRUE;
14344               out_off += (input_section->output_section->vma
14345                           + input_section->output_offset);
14346               outrel.r_offset = out_off;
14347               outrel.r_addend = rel->r_addend;
14348
14349               /* Optimize unaligned reloc use.  */
14350               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14351                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14352                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14353               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14354                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14355                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14356               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14357                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14358                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14359
14360               if (skip)
14361                 memset (&outrel, 0, sizeof outrel);
14362               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14363                        && !is_opd
14364                        && r_type != R_PPC64_TOC)
14365                 {
14366                   BFD_ASSERT (h->elf.dynindx != -1);
14367                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14368                 }
14369               else
14370                 {
14371                   /* This symbol is local, or marked to become local,
14372                      or this is an opd section reloc which must point
14373                      at a local function.  */
14374                   outrel.r_addend += relocation;
14375                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14376                     {
14377                       if (is_opd && h != NULL)
14378                         {
14379                           /* Lie about opd entries.  This case occurs
14380                              when building shared libraries and we
14381                              reference a function in another shared
14382                              lib.  The same thing happens for a weak
14383                              definition in an application that's
14384                              overridden by a strong definition in a
14385                              shared lib.  (I believe this is a generic
14386                              bug in binutils handling of weak syms.)
14387                              In these cases we won't use the opd
14388                              entry in this lib.  */
14389                           unresolved_reloc = FALSE;
14390                         }
14391                       if (!is_opd
14392                           && r_type == R_PPC64_ADDR64
14393                           && (h != NULL
14394                               ? h->elf.type == STT_GNU_IFUNC
14395                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14396                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14397                       else
14398                         {
14399                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14400
14401                           /* We need to relocate .opd contents for ld.so.
14402                              Prelink also wants simple and consistent rules
14403                              for relocs.  This make all RELATIVE relocs have
14404                              *r_offset equal to r_addend.  */
14405                           relocate = TRUE;
14406                         }
14407                     }
14408                   else
14409                     {
14410                       long indx = 0;
14411
14412                       if (h != NULL
14413                           ? h->elf.type == STT_GNU_IFUNC
14414                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14415                         {
14416                           info->callbacks->einfo
14417                             (_("%P: %H: %s for indirect "
14418                                "function `%T' unsupported\n"),
14419                              input_bfd, input_section, rel->r_offset,
14420                              ppc64_elf_howto_table[r_type]->name,
14421                              sym_name);
14422                           ret = FALSE;
14423                         }
14424                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14425                         ;
14426                       else if (sec == NULL || sec->owner == NULL)
14427                         {
14428                           bfd_set_error (bfd_error_bad_value);
14429                           return FALSE;
14430                         }
14431                       else
14432                         {
14433                           asection *osec;
14434
14435                           osec = sec->output_section;
14436                           indx = elf_section_data (osec)->dynindx;
14437
14438                           if (indx == 0)
14439                             {
14440                               if ((osec->flags & SEC_READONLY) == 0
14441                                   && htab->elf.data_index_section != NULL)
14442                                 osec = htab->elf.data_index_section;
14443                               else
14444                                 osec = htab->elf.text_index_section;
14445                               indx = elf_section_data (osec)->dynindx;
14446                             }
14447                           BFD_ASSERT (indx != 0);
14448
14449                           /* We are turning this relocation into one
14450                              against a section symbol, so subtract out
14451                              the output section's address but not the
14452                              offset of the input section in the output
14453                              section.  */
14454                           outrel.r_addend -= osec->vma;
14455                         }
14456
14457                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14458                     }
14459                 }
14460
14461               sreloc = elf_section_data (input_section)->sreloc;
14462               if (h != NULL
14463                   ? h->elf.type == STT_GNU_IFUNC
14464                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14465                 sreloc = htab->elf.irelplt;
14466               if (sreloc == NULL)
14467                 abort ();
14468
14469               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14470                   >= sreloc->size)
14471                 abort ();
14472               loc = sreloc->contents;
14473               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14474               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14475
14476               /* If this reloc is against an external symbol, it will
14477                  be computed at runtime, so there's no need to do
14478                  anything now.  However, for the sake of prelink ensure
14479                  that the section contents are a known value.  */
14480               if (! relocate)
14481                 {
14482                   unresolved_reloc = FALSE;
14483                   /* The value chosen here is quite arbitrary as ld.so
14484                      ignores section contents except for the special
14485                      case of .opd where the contents might be accessed
14486                      before relocation.  Choose zero, as that won't
14487                      cause reloc overflow.  */
14488                   relocation = 0;
14489                   addend = 0;
14490                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14491                      to improve backward compatibility with older
14492                      versions of ld.  */
14493                   if (r_type == R_PPC64_ADDR64)
14494                     addend = outrel.r_addend;
14495                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14496                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14497                     addend = (input_section->output_section->vma
14498                               + input_section->output_offset
14499                               + rel->r_offset);
14500                 }
14501             }
14502           break;
14503
14504         case R_PPC64_COPY:
14505         case R_PPC64_GLOB_DAT:
14506         case R_PPC64_JMP_SLOT:
14507         case R_PPC64_JMP_IREL:
14508         case R_PPC64_RELATIVE:
14509           /* We shouldn't ever see these dynamic relocs in relocatable
14510              files.  */
14511           /* Fall through.  */
14512
14513         case R_PPC64_PLTGOT16:
14514         case R_PPC64_PLTGOT16_DS:
14515         case R_PPC64_PLTGOT16_HA:
14516         case R_PPC64_PLTGOT16_HI:
14517         case R_PPC64_PLTGOT16_LO:
14518         case R_PPC64_PLTGOT16_LO_DS:
14519         case R_PPC64_PLTREL32:
14520         case R_PPC64_PLTREL64:
14521           /* These ones haven't been implemented yet.  */
14522
14523           info->callbacks->einfo
14524             (_("%P: %B: %s is not supported for `%T'\n"),
14525              input_bfd,
14526              ppc64_elf_howto_table[r_type]->name, sym_name);
14527
14528           bfd_set_error (bfd_error_invalid_operation);
14529           ret = FALSE;
14530           continue;
14531         }
14532
14533       /* Multi-instruction sequences that access the TOC can be
14534          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14535          to             nop;           addi rb,r2,x;  */
14536       switch (r_type)
14537         {
14538         default:
14539           break;
14540
14541         case R_PPC64_GOT_TLSLD16_HI:
14542         case R_PPC64_GOT_TLSGD16_HI:
14543         case R_PPC64_GOT_TPREL16_HI:
14544         case R_PPC64_GOT_DTPREL16_HI:
14545         case R_PPC64_GOT16_HI:
14546         case R_PPC64_TOC16_HI:
14547           /* These relocs would only be useful if building up an
14548              offset to later add to r2, perhaps in an indexed
14549              addressing mode instruction.  Don't try to optimize.
14550              Unfortunately, the possibility of someone building up an
14551              offset like this or even with the HA relocs, means that
14552              we need to check the high insn when optimizing the low
14553              insn.  */
14554           break;
14555
14556         case R_PPC64_GOT_TLSLD16_HA:
14557         case R_PPC64_GOT_TLSGD16_HA:
14558         case R_PPC64_GOT_TPREL16_HA:
14559         case R_PPC64_GOT_DTPREL16_HA:
14560         case R_PPC64_GOT16_HA:
14561         case R_PPC64_TOC16_HA:
14562           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14563               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14564             {
14565               bfd_byte *p = contents + (rel->r_offset & ~3);
14566               bfd_put_32 (input_bfd, NOP, p);
14567             }
14568           break;
14569
14570         case R_PPC64_GOT_TLSLD16_LO:
14571         case R_PPC64_GOT_TLSGD16_LO:
14572         case R_PPC64_GOT_TPREL16_LO_DS:
14573         case R_PPC64_GOT_DTPREL16_LO_DS:
14574         case R_PPC64_GOT16_LO:
14575         case R_PPC64_GOT16_LO_DS:
14576         case R_PPC64_TOC16_LO:
14577         case R_PPC64_TOC16_LO_DS:
14578           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14579               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14580             {
14581               bfd_byte *p = contents + (rel->r_offset & ~3);
14582               insn = bfd_get_32 (input_bfd, p);
14583               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14584                 {
14585                   /* Transform addic to addi when we change reg.  */
14586                   insn &= ~((0x3f << 26) | (0x1f << 16));
14587                   insn |= (14u << 26) | (2 << 16);
14588                 }
14589               else
14590                 {
14591                   insn &= ~(0x1f << 16);
14592                   insn |= 2 << 16;
14593                 }
14594               bfd_put_32 (input_bfd, insn, p);
14595             }
14596           break;
14597         }
14598
14599       /* Do any further special processing.  */
14600       howto = ppc64_elf_howto_table[(int) r_type];
14601       switch (r_type)
14602         {
14603         default:
14604           break;
14605
14606         case R_PPC64_REL16_HA:
14607         case R_PPC64_ADDR16_HA:
14608         case R_PPC64_ADDR16_HIGHA:
14609         case R_PPC64_ADDR16_HIGHERA:
14610         case R_PPC64_ADDR16_HIGHESTA:
14611         case R_PPC64_TOC16_HA:
14612         case R_PPC64_SECTOFF_HA:
14613         case R_PPC64_TPREL16_HA:
14614         case R_PPC64_TPREL16_HIGHA:
14615         case R_PPC64_TPREL16_HIGHERA:
14616         case R_PPC64_TPREL16_HIGHESTA:
14617         case R_PPC64_DTPREL16_HA:
14618         case R_PPC64_DTPREL16_HIGHA:
14619         case R_PPC64_DTPREL16_HIGHERA:
14620         case R_PPC64_DTPREL16_HIGHESTA:
14621           /* It's just possible that this symbol is a weak symbol
14622              that's not actually defined anywhere. In that case,
14623              'sec' would be NULL, and we should leave the symbol
14624              alone (it will be set to zero elsewhere in the link).  */
14625           if (sec == NULL)
14626             break;
14627           /* Fall thru */
14628
14629         case R_PPC64_GOT16_HA:
14630         case R_PPC64_PLTGOT16_HA:
14631         case R_PPC64_PLT16_HA:
14632         case R_PPC64_GOT_TLSGD16_HA:
14633         case R_PPC64_GOT_TLSLD16_HA:
14634         case R_PPC64_GOT_TPREL16_HA:
14635         case R_PPC64_GOT_DTPREL16_HA:
14636           /* Add 0x10000 if sign bit in 0:15 is set.
14637              Bits 0:15 are not used.  */
14638           addend += 0x8000;
14639           break;
14640
14641         case R_PPC64_ADDR16_DS:
14642         case R_PPC64_ADDR16_LO_DS:
14643         case R_PPC64_GOT16_DS:
14644         case R_PPC64_GOT16_LO_DS:
14645         case R_PPC64_PLT16_LO_DS:
14646         case R_PPC64_SECTOFF_DS:
14647         case R_PPC64_SECTOFF_LO_DS:
14648         case R_PPC64_TOC16_DS:
14649         case R_PPC64_TOC16_LO_DS:
14650         case R_PPC64_PLTGOT16_DS:
14651         case R_PPC64_PLTGOT16_LO_DS:
14652         case R_PPC64_GOT_TPREL16_DS:
14653         case R_PPC64_GOT_TPREL16_LO_DS:
14654         case R_PPC64_GOT_DTPREL16_DS:
14655         case R_PPC64_GOT_DTPREL16_LO_DS:
14656         case R_PPC64_TPREL16_DS:
14657         case R_PPC64_TPREL16_LO_DS:
14658         case R_PPC64_DTPREL16_DS:
14659         case R_PPC64_DTPREL16_LO_DS:
14660           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14661           mask = 3;
14662           /* If this reloc is against an lq insn, then the value must be
14663              a multiple of 16.  This is somewhat of a hack, but the
14664              "correct" way to do this by defining _DQ forms of all the
14665              _DS relocs bloats all reloc switches in this file.  It
14666              doesn't seem to make much sense to use any of these relocs
14667              in data, so testing the insn should be safe.  */
14668           if ((insn & (0x3f << 26)) == (56u << 26))
14669             mask = 15;
14670           if (((relocation + addend) & mask) != 0)
14671             {
14672               info->callbacks->einfo
14673                 (_("%P: %H: error: %s not a multiple of %u\n"),
14674                  input_bfd, input_section, rel->r_offset,
14675                  howto->name,
14676                  mask + 1);
14677               bfd_set_error (bfd_error_bad_value);
14678               ret = FALSE;
14679               continue;
14680             }
14681           break;
14682         }
14683
14684       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14685          because such sections are not SEC_ALLOC and thus ld.so will
14686          not process them.  */
14687       if (unresolved_reloc
14688           && !((input_section->flags & SEC_DEBUGGING) != 0
14689                && h->elf.def_dynamic)
14690           && _bfd_elf_section_offset (output_bfd, info, input_section,
14691                                       rel->r_offset) != (bfd_vma) -1)
14692         {
14693           info->callbacks->einfo
14694             (_("%P: %H: unresolvable %s against `%T'\n"),
14695              input_bfd, input_section, rel->r_offset,
14696              howto->name,
14697              h->elf.root.root.string);
14698           ret = FALSE;
14699         }
14700
14701       /* 16-bit fields in insns mostly have signed values, but a
14702          few insns have 16-bit unsigned values.  Really, we should
14703          have different reloc types.  */
14704       if (howto->complain_on_overflow != complain_overflow_dont
14705           && howto->dst_mask == 0xffff
14706           && (input_section->flags & SEC_CODE) != 0)
14707         {
14708           enum complain_overflow complain = complain_overflow_signed;
14709
14710           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14711           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14712             complain = complain_overflow_bitfield;
14713           else if (howto->rightshift == 0
14714                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14715                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14716                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14717                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14718                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14719                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14720             complain = complain_overflow_unsigned;
14721           if (howto->complain_on_overflow != complain)
14722             {
14723               alt_howto = *howto;
14724               alt_howto.complain_on_overflow = complain;
14725               howto = &alt_howto;
14726             }
14727         }
14728
14729       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14730                                     rel->r_offset, relocation, addend);
14731
14732       if (r != bfd_reloc_ok)
14733         {
14734           char *more_info = NULL;
14735           const char *reloc_name = howto->name;
14736
14737           if (reloc_dest != DEST_NORMAL)
14738             {
14739               more_info = bfd_malloc (strlen (reloc_name) + 8);
14740               if (more_info != NULL)
14741                 {
14742                   strcpy (more_info, reloc_name);
14743                   strcat (more_info, (reloc_dest == DEST_OPD
14744                                       ? " (OPD)" : " (stub)"));
14745                   reloc_name = more_info;
14746                 }
14747             }
14748
14749           if (r == bfd_reloc_overflow)
14750             {
14751               if (warned)
14752                 continue;
14753               if (h != NULL
14754                   && h->elf.root.type == bfd_link_hash_undefweak
14755                   && howto->pc_relative)
14756                 {
14757                   /* Assume this is a call protected by other code that
14758                      detects the symbol is undefined.  If this is the case,
14759                      we can safely ignore the overflow.  If not, the
14760                      program is hosed anyway, and a little warning isn't
14761                      going to help.  */
14762
14763                   continue;
14764                 }
14765
14766               if (!((*info->callbacks->reloc_overflow)
14767                     (info, &h->elf.root, sym_name,
14768                      reloc_name, orig_rel.r_addend,
14769                      input_bfd, input_section, rel->r_offset)))
14770                 return FALSE;
14771             }
14772           else
14773             {
14774               info->callbacks->einfo
14775                 (_("%P: %H: %s against `%T': error %d\n"),
14776                  input_bfd, input_section, rel->r_offset,
14777                  reloc_name, sym_name, (int) r);
14778               ret = FALSE;
14779             }
14780           if (more_info != NULL)
14781             free (more_info);
14782         }
14783     }
14784
14785   /* If we're emitting relocations, then shortly after this function
14786      returns, reloc offsets and addends for this section will be
14787      adjusted.  Worse, reloc symbol indices will be for the output
14788      file rather than the input.  Save a copy of the relocs for
14789      opd_entry_value.  */
14790   if (is_opd && (info->emitrelocations || info->relocatable))
14791     {
14792       bfd_size_type amt;
14793       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14794       rel = bfd_alloc (input_bfd, amt);
14795       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14796       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14797       if (rel == NULL)
14798         return FALSE;
14799       memcpy (rel, relocs, amt);
14800     }
14801   return ret;
14802 }
14803
14804 /* Adjust the value of any local symbols in opd sections.  */
14805
14806 static int
14807 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14808                               const char *name ATTRIBUTE_UNUSED,
14809                               Elf_Internal_Sym *elfsym,
14810                               asection *input_sec,
14811                               struct elf_link_hash_entry *h)
14812 {
14813   struct _opd_sec_data *opd;
14814   long adjust;
14815   bfd_vma value;
14816
14817   if (h != NULL)
14818     return 1;
14819
14820   opd = get_opd_info (input_sec);
14821   if (opd == NULL || opd->adjust == NULL)
14822     return 1;
14823
14824   value = elfsym->st_value - input_sec->output_offset;
14825   if (!info->relocatable)
14826     value -= input_sec->output_section->vma;
14827
14828   adjust = opd->adjust[value / 8];
14829   if (adjust == -1)
14830     return 2;
14831
14832   elfsym->st_value += adjust;
14833   return 1;
14834 }
14835
14836 /* Finish up dynamic symbol handling.  We set the contents of various
14837    dynamic sections here.  */
14838
14839 static bfd_boolean
14840 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14841                                  struct bfd_link_info *info,
14842                                  struct elf_link_hash_entry *h,
14843                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14844 {
14845   struct ppc_link_hash_table *htab;
14846   struct plt_entry *ent;
14847   Elf_Internal_Rela rela;
14848   bfd_byte *loc;
14849
14850   htab = ppc_hash_table (info);
14851   if (htab == NULL)
14852     return FALSE;
14853
14854   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14855     if (ent->plt.offset != (bfd_vma) -1)
14856       {
14857         /* This symbol has an entry in the procedure linkage
14858            table.  Set it up.  */
14859         if (!htab->elf.dynamic_sections_created
14860             || h->dynindx == -1)
14861           {
14862             BFD_ASSERT (h->type == STT_GNU_IFUNC
14863                         && h->def_regular
14864                         && (h->root.type == bfd_link_hash_defined
14865                             || h->root.type == bfd_link_hash_defweak));
14866             rela.r_offset = (htab->elf.iplt->output_section->vma
14867                              + htab->elf.iplt->output_offset
14868                              + ent->plt.offset);
14869             if (htab->opd_abi)
14870               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14871             else
14872               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14873             rela.r_addend = (h->root.u.def.value
14874                              + h->root.u.def.section->output_offset
14875                              + h->root.u.def.section->output_section->vma
14876                              + ent->addend);
14877             loc = (htab->elf.irelplt->contents
14878                    + (htab->elf.irelplt->reloc_count++
14879                       * sizeof (Elf64_External_Rela)));
14880           }
14881         else
14882           {
14883             rela.r_offset = (htab->elf.splt->output_section->vma
14884                              + htab->elf.splt->output_offset
14885                              + ent->plt.offset);
14886             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14887             rela.r_addend = ent->addend;
14888             loc = (htab->elf.srelplt->contents
14889                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14890                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14891           }
14892         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14893
14894         if (!htab->opd_abi)
14895           {
14896             if (!h->def_regular)
14897               {
14898                 /* Mark the symbol as undefined, rather than as
14899                    defined in glink.  Leave the value if there were
14900                    any relocations where pointer equality matters
14901                    (this is a clue for the dynamic linker, to make
14902                    function pointer comparisons work between an
14903                    application and shared library), otherwise set it
14904                    to zero.  */
14905                 sym->st_shndx = SHN_UNDEF;
14906                 if (!h->pointer_equality_needed)
14907                   sym->st_value = 0;
14908                 else if (!h->ref_regular_nonweak)
14909                   {
14910                     /* This breaks function pointer comparisons, but
14911                        that is better than breaking tests for a NULL
14912                        function pointer.  */
14913                     sym->st_value = 0;
14914                   }
14915               }
14916           }
14917       }
14918
14919   if (h->needs_copy)
14920     {
14921       /* This symbol needs a copy reloc.  Set it up.  */
14922
14923       if (h->dynindx == -1
14924           || (h->root.type != bfd_link_hash_defined
14925               && h->root.type != bfd_link_hash_defweak)
14926           || htab->relbss == NULL)
14927         abort ();
14928
14929       rela.r_offset = (h->root.u.def.value
14930                        + h->root.u.def.section->output_section->vma
14931                        + h->root.u.def.section->output_offset);
14932       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14933       rela.r_addend = 0;
14934       loc = htab->relbss->contents;
14935       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14936       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14937     }
14938
14939   return TRUE;
14940 }
14941
14942 /* Used to decide how to sort relocs in an optimal manner for the
14943    dynamic linker, before writing them out.  */
14944
14945 static enum elf_reloc_type_class
14946 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14947                             const asection *rel_sec,
14948                             const Elf_Internal_Rela *rela)
14949 {
14950   enum elf_ppc64_reloc_type r_type;
14951   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14952
14953   if (rel_sec == htab->elf.irelplt)
14954     return reloc_class_ifunc;
14955
14956   r_type = ELF64_R_TYPE (rela->r_info);
14957   switch (r_type)
14958     {
14959     case R_PPC64_RELATIVE:
14960       return reloc_class_relative;
14961     case R_PPC64_JMP_SLOT:
14962       return reloc_class_plt;
14963     case R_PPC64_COPY:
14964       return reloc_class_copy;
14965     default:
14966       return reloc_class_normal;
14967     }
14968 }
14969
14970 /* Finish up the dynamic sections.  */
14971
14972 static bfd_boolean
14973 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14974                                    struct bfd_link_info *info)
14975 {
14976   struct ppc_link_hash_table *htab;
14977   bfd *dynobj;
14978   asection *sdyn;
14979
14980   htab = ppc_hash_table (info);
14981   if (htab == NULL)
14982     return FALSE;
14983
14984   dynobj = htab->elf.dynobj;
14985   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14986
14987   if (htab->elf.dynamic_sections_created)
14988     {
14989       Elf64_External_Dyn *dyncon, *dynconend;
14990
14991       if (sdyn == NULL || htab->elf.sgot == NULL)
14992         abort ();
14993
14994       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14995       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14996       for (; dyncon < dynconend; dyncon++)
14997         {
14998           Elf_Internal_Dyn dyn;
14999           asection *s;
15000
15001           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15002
15003           switch (dyn.d_tag)
15004             {
15005             default:
15006               continue;
15007
15008             case DT_PPC64_GLINK:
15009               s = htab->glink;
15010               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15011               /* We stupidly defined DT_PPC64_GLINK to be the start
15012                  of glink rather than the first entry point, which is
15013                  what ld.so needs, and now have a bigger stub to
15014                  support automatic multiple TOCs.  */
15015               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15016               break;
15017
15018             case DT_PPC64_OPD:
15019               s = bfd_get_section_by_name (output_bfd, ".opd");
15020               if (s == NULL)
15021                 continue;
15022               dyn.d_un.d_ptr = s->vma;
15023               break;
15024
15025             case DT_PPC64_OPT:
15026               if (htab->do_multi_toc && htab->multi_toc_needed)
15027                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15028               break;
15029
15030             case DT_PPC64_OPDSZ:
15031               s = bfd_get_section_by_name (output_bfd, ".opd");
15032               if (s == NULL)
15033                 continue;
15034               dyn.d_un.d_val = s->size;
15035               break;
15036
15037             case DT_PLTGOT:
15038               s = htab->elf.splt;
15039               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15040               break;
15041
15042             case DT_JMPREL:
15043               s = htab->elf.srelplt;
15044               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15045               break;
15046
15047             case DT_PLTRELSZ:
15048               dyn.d_un.d_val = htab->elf.srelplt->size;
15049               break;
15050
15051             case DT_RELASZ:
15052               /* Don't count procedure linkage table relocs in the
15053                  overall reloc count.  */
15054               s = htab->elf.srelplt;
15055               if (s == NULL)
15056                 continue;
15057               dyn.d_un.d_val -= s->size;
15058               break;
15059
15060             case DT_RELA:
15061               /* We may not be using the standard ELF linker script.
15062                  If .rela.plt is the first .rela section, we adjust
15063                  DT_RELA to not include it.  */
15064               s = htab->elf.srelplt;
15065               if (s == NULL)
15066                 continue;
15067               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15068                 continue;
15069               dyn.d_un.d_ptr += s->size;
15070               break;
15071             }
15072
15073           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15074         }
15075     }
15076
15077   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15078     {
15079       /* Fill in the first entry in the global offset table.
15080          We use it to hold the link-time TOCbase.  */
15081       bfd_put_64 (output_bfd,
15082                   elf_gp (output_bfd) + TOC_BASE_OFF,
15083                   htab->elf.sgot->contents);
15084
15085       /* Set .got entry size.  */
15086       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15087     }
15088
15089   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15090     {
15091       /* Set .plt entry size.  */
15092       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15093         = PLT_ENTRY_SIZE (htab);
15094     }
15095
15096   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15097      brlt ourselves if emitrelocations.  */
15098   if (htab->brlt != NULL
15099       && htab->brlt->reloc_count != 0
15100       && !_bfd_elf_link_output_relocs (output_bfd,
15101                                        htab->brlt,
15102                                        elf_section_data (htab->brlt)->rela.hdr,
15103                                        elf_section_data (htab->brlt)->relocs,
15104                                        NULL))
15105     return FALSE;
15106
15107   if (htab->glink != NULL
15108       && htab->glink->reloc_count != 0
15109       && !_bfd_elf_link_output_relocs (output_bfd,
15110                                        htab->glink,
15111                                        elf_section_data (htab->glink)->rela.hdr,
15112                                        elf_section_data (htab->glink)->relocs,
15113                                        NULL))
15114     return FALSE;
15115
15116
15117   if (htab->glink_eh_frame != NULL
15118       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15119       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15120                                            htab->glink_eh_frame,
15121                                            htab->glink_eh_frame->contents))
15122     return FALSE;
15123
15124   /* We need to handle writing out multiple GOT sections ourselves,
15125      since we didn't add them to DYNOBJ.  We know dynobj is the first
15126      bfd.  */
15127   while ((dynobj = dynobj->link.next) != NULL)
15128     {
15129       asection *s;
15130
15131       if (!is_ppc64_elf (dynobj))
15132         continue;
15133
15134       s = ppc64_elf_tdata (dynobj)->got;
15135       if (s != NULL
15136           && s->size != 0
15137           && s->output_section != bfd_abs_section_ptr
15138           && !bfd_set_section_contents (output_bfd, s->output_section,
15139                                         s->contents, s->output_offset,
15140                                         s->size))
15141         return FALSE;
15142       s = ppc64_elf_tdata (dynobj)->relgot;
15143       if (s != NULL
15144           && s->size != 0
15145           && s->output_section != bfd_abs_section_ptr
15146           && !bfd_set_section_contents (output_bfd, s->output_section,
15147                                         s->contents, s->output_offset,
15148                                         s->size))
15149         return FALSE;
15150     }
15151
15152   return TRUE;
15153 }
15154
15155 #include "elf64-target.h"
15156
15157 /* FreeBSD support */
15158
15159 #undef  TARGET_LITTLE_SYM
15160 #undef  TARGET_LITTLE_NAME
15161
15162 #undef  TARGET_BIG_SYM
15163 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15164 #undef  TARGET_BIG_NAME
15165 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15166
15167 #undef  ELF_OSABI
15168 #define ELF_OSABI       ELFOSABI_FREEBSD
15169
15170 #undef  elf64_bed
15171 #define elf64_bed       elf64_powerpc_fbsd_bed
15172
15173 #include "elf64-target.h"
15174