bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2015 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176
 177 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 178 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 179 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 180
 181 /* glink call stub instructions.  We enter with the index in R0.  */
 182 #define GLINK_CALL_STUB_SIZE (16*4)
 183                                         /* 0:                           */
 184                                         /*  .quad plt0-1f               */
 185                                         /* __glink:                     */
 186 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 187 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 188                                         /* 1:                           */
 189 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 190                                         /*  ld %2,(0b-1b)(%11)          */
 191 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 192 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 193                                         /*  ld %12,0(%11)               */
 194                                         /*  ld %2,8(%11)                */
 195                                         /*  mtctr %12                   */
 196                                         /*  ld %11,16(%11)              */
 197                                         /*  bctr                        */
 198 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 199 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 200 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 201 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 202 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 203
 204 /* Pad with this.  */
 205 #define NOP             0x60000000
 206
 207 /* Some other nops.  */
 208 #define CROR_151515     0x4def7b82
 209 #define CROR_313131     0x4ffffb82
 210
 211 /* .glink entries for the first 32k functions are two instructions.  */
 212 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 213 #define B_DOT           0x48000000      /* b     .              */
 214
 215 /* After that, we need two instructions to load the index, followed by
 216    a branch.  */
 217 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 218 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 219
 220 /* Instructions used by the save and restore reg functions.  */
 221 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 222 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 223 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 224 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 225 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 226 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 227 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 228 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 229 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 230 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 231 #define BLR             0x4e800020      /* blr                  */
 232
 233 /* Since .opd is an array of descriptors and each entry will end up
 234    with identical R_PPC64_RELATIVE relocs, there is really no need to
 235    propagate .opd relocs;  The dynamic linker should be taught to
 236    relocate .opd without reloc entries.  */
 237 #ifndef NO_OPD_RELOCS
 238 #define NO_OPD_RELOCS 0
 239 #endif
 240
 241 static inline int
 242 abiversion (bfd *abfd)
 243 {
 244   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 245 }
 246
 247 static inline void
 248 set_abiversion (bfd *abfd, int ver)
 249 {
 250   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 251   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 252 }
 253 \f
 254 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 255
 256 /* Relocation HOWTO's.  */
 257 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 258
 259 static reloc_howto_type ppc64_elf_howto_raw[] = {
 260   /* This reloc does nothing.  */
 261   HOWTO (R_PPC64_NONE,          /* type */
 262          0,                     /* rightshift */
 263          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 264          0,                     /* bitsize */
 265          FALSE,                 /* pc_relative */
 266          0,                     /* bitpos */
 267          complain_overflow_dont, /* complain_on_overflow */
 268          bfd_elf_generic_reloc, /* special_function */
 269          "R_PPC64_NONE",        /* name */
 270          FALSE,                 /* partial_inplace */
 271          0,                     /* src_mask */
 272          0,                     /* dst_mask */
 273          FALSE),                /* pcrel_offset */
 274
 275   /* A standard 32 bit relocation.  */
 276   HOWTO (R_PPC64_ADDR32,        /* type */
 277          0,                     /* rightshift */
 278          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          32,                    /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          0,                     /* bitpos */
 282          complain_overflow_bitfield, /* complain_on_overflow */
 283          bfd_elf_generic_reloc, /* special_function */
 284          "R_PPC64_ADDR32",      /* name */
 285          FALSE,                 /* partial_inplace */
 286          0,                     /* src_mask */
 287          0xffffffff,            /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289
 290   /* An absolute 26 bit branch; the lower two bits must be zero.
 291      FIXME: we don't check that, we just clear them.  */
 292   HOWTO (R_PPC64_ADDR24,        /* type */
 293          0,                     /* rightshift */
 294          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          26,                    /* bitsize */
 296          FALSE,                 /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_bitfield, /* complain_on_overflow */
 299          bfd_elf_generic_reloc, /* special_function */
 300          "R_PPC64_ADDR24",      /* name */
 301          FALSE,                 /* partial_inplace */
 302          0,                     /* src_mask */
 303          0x03fffffc,            /* dst_mask */
 304          FALSE),                /* pcrel_offset */
 305
 306   /* A standard 16 bit relocation.  */
 307   HOWTO (R_PPC64_ADDR16,        /* type */
 308          0,                     /* rightshift */
 309          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          16,                    /* bitsize */
 311          FALSE,                 /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_bitfield, /* complain_on_overflow */
 314          bfd_elf_generic_reloc, /* special_function */
 315          "R_PPC64_ADDR16",      /* name */
 316          FALSE,                 /* partial_inplace */
 317          0,                     /* src_mask */
 318          0xffff,                /* dst_mask */
 319          FALSE),                /* pcrel_offset */
 320
 321   /* A 16 bit relocation without overflow.  */
 322   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 323          0,                     /* rightshift */
 324          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          16,                    /* bitsize */
 326          FALSE,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_dont,/* complain_on_overflow */
 329          bfd_elf_generic_reloc, /* special_function */
 330          "R_PPC64_ADDR16_LO",   /* name */
 331          FALSE,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xffff,                /* dst_mask */
 334          FALSE),                /* pcrel_offset */
 335
 336   /* Bits 16-31 of an address.  */
 337   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 338          16,                    /* rightshift */
 339          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 340          16,                    /* bitsize */
 341          FALSE,                 /* pc_relative */
 342          0,                     /* bitpos */
 343          complain_overflow_signed, /* complain_on_overflow */
 344          bfd_elf_generic_reloc, /* special_function */
 345          "R_PPC64_ADDR16_HI",   /* name */
 346          FALSE,                 /* partial_inplace */
 347          0,                     /* src_mask */
 348          0xffff,                /* dst_mask */
 349          FALSE),                /* pcrel_offset */
 350
 351   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 352      bits, treated as a signed number, is negative.  */
 353   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 354          16,                    /* rightshift */
 355          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 356          16,                    /* bitsize */
 357          FALSE,                 /* pc_relative */
 358          0,                     /* bitpos */
 359          complain_overflow_signed, /* complain_on_overflow */
 360          ppc64_elf_ha_reloc,    /* special_function */
 361          "R_PPC64_ADDR16_HA",   /* name */
 362          FALSE,                 /* partial_inplace */
 363          0,                     /* src_mask */
 364          0xffff,                /* dst_mask */
 365          FALSE),                /* pcrel_offset */
 366
 367   /* An absolute 16 bit branch; the lower two bits must be zero.
 368      FIXME: we don't check that, we just clear them.  */
 369   HOWTO (R_PPC64_ADDR14,        /* type */
 370          0,                     /* rightshift */
 371          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 372          16,                    /* bitsize */
 373          FALSE,                 /* pc_relative */
 374          0,                     /* bitpos */
 375          complain_overflow_signed, /* complain_on_overflow */
 376          ppc64_elf_branch_reloc, /* special_function */
 377          "R_PPC64_ADDR14",      /* name */
 378          FALSE,                 /* partial_inplace */
 379          0,                     /* src_mask */
 380          0x0000fffc,            /* dst_mask */
 381          FALSE),                /* pcrel_offset */
 382
 383   /* An absolute 16 bit branch, for which bit 10 should be set to
 384      indicate that the branch is expected to be taken.  The lower two
 385      bits must be zero.  */
 386   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 387          0,                     /* rightshift */
 388          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 389          16,                    /* bitsize */
 390          FALSE,                 /* pc_relative */
 391          0,                     /* bitpos */
 392          complain_overflow_signed, /* complain_on_overflow */
 393          ppc64_elf_brtaken_reloc, /* special_function */
 394          "R_PPC64_ADDR14_BRTAKEN",/* name */
 395          FALSE,                 /* partial_inplace */
 396          0,                     /* src_mask */
 397          0x0000fffc,            /* dst_mask */
 398          FALSE),                /* pcrel_offset */
 399
 400   /* An absolute 16 bit branch, for which bit 10 should be set to
 401      indicate that the branch is not expected to be taken.  The lower
 402      two bits must be zero.  */
 403   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          16,                    /* bitsize */
 407          FALSE,                 /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_brtaken_reloc, /* special_function */
 411          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x0000fffc,            /* dst_mask */
 415          FALSE),                /* pcrel_offset */
 416
 417   /* A relative 26 bit branch; the lower two bits must be zero.  */
 418   HOWTO (R_PPC64_REL24,         /* type */
 419          0,                     /* rightshift */
 420          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 421          26,                    /* bitsize */
 422          TRUE,                  /* pc_relative */
 423          0,                     /* bitpos */
 424          complain_overflow_signed, /* complain_on_overflow */
 425          ppc64_elf_branch_reloc, /* special_function */
 426          "R_PPC64_REL24",       /* name */
 427          FALSE,                 /* partial_inplace */
 428          0,                     /* src_mask */
 429          0x03fffffc,            /* dst_mask */
 430          TRUE),                 /* pcrel_offset */
 431
 432   /* A relative 16 bit branch; the lower two bits must be zero.  */
 433   HOWTO (R_PPC64_REL14,         /* type */
 434          0,                     /* rightshift */
 435          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 436          16,                    /* bitsize */
 437          TRUE,                  /* pc_relative */
 438          0,                     /* bitpos */
 439          complain_overflow_signed, /* complain_on_overflow */
 440          ppc64_elf_branch_reloc, /* special_function */
 441          "R_PPC64_REL14",       /* name */
 442          FALSE,                 /* partial_inplace */
 443          0,                     /* src_mask */
 444          0x0000fffc,            /* dst_mask */
 445          TRUE),                 /* pcrel_offset */
 446
 447   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 448      the branch is expected to be taken.  The lower two bits must be
 449      zero.  */
 450   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 451          0,                     /* rightshift */
 452          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 453          16,                    /* bitsize */
 454          TRUE,                  /* pc_relative */
 455          0,                     /* bitpos */
 456          complain_overflow_signed, /* complain_on_overflow */
 457          ppc64_elf_brtaken_reloc, /* special_function */
 458          "R_PPC64_REL14_BRTAKEN", /* name */
 459          FALSE,                 /* partial_inplace */
 460          0,                     /* src_mask */
 461          0x0000fffc,            /* dst_mask */
 462          TRUE),                 /* pcrel_offset */
 463
 464   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 465      the branch is not expected to be taken.  The lower two bits must
 466      be zero.  */
 467   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 468          0,                     /* rightshift */
 469          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 470          16,                    /* bitsize */
 471          TRUE,                  /* pc_relative */
 472          0,                     /* bitpos */
 473          complain_overflow_signed, /* complain_on_overflow */
 474          ppc64_elf_brtaken_reloc, /* special_function */
 475          "R_PPC64_REL14_BRNTAKEN",/* name */
 476          FALSE,                 /* partial_inplace */
 477          0,                     /* src_mask */
 478          0x0000fffc,            /* dst_mask */
 479          TRUE),                 /* pcrel_offset */
 480
 481   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 482      symbol.  */
 483   HOWTO (R_PPC64_GOT16,         /* type */
 484          0,                     /* rightshift */
 485          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 486          16,                    /* bitsize */
 487          FALSE,                 /* pc_relative */
 488          0,                     /* bitpos */
 489          complain_overflow_signed, /* complain_on_overflow */
 490          ppc64_elf_unhandled_reloc, /* special_function */
 491          "R_PPC64_GOT16",       /* name */
 492          FALSE,                 /* partial_inplace */
 493          0,                     /* src_mask */
 494          0xffff,                /* dst_mask */
 495          FALSE),                /* pcrel_offset */
 496
 497   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 498      the symbol.  */
 499   HOWTO (R_PPC64_GOT16_LO,      /* type */
 500          0,                     /* rightshift */
 501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 502          16,                    /* bitsize */
 503          FALSE,                 /* pc_relative */
 504          0,                     /* bitpos */
 505          complain_overflow_dont, /* complain_on_overflow */
 506          ppc64_elf_unhandled_reloc, /* special_function */
 507          "R_PPC64_GOT16_LO",    /* name */
 508          FALSE,                 /* partial_inplace */
 509          0,                     /* src_mask */
 510          0xffff,                /* dst_mask */
 511          FALSE),                /* pcrel_offset */
 512
 513   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 514      the symbol.  */
 515   HOWTO (R_PPC64_GOT16_HI,      /* type */
 516          16,                    /* rightshift */
 517          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 518          16,                    /* bitsize */
 519          FALSE,                 /* pc_relative */
 520          0,                     /* bitpos */
 521          complain_overflow_signed,/* complain_on_overflow */
 522          ppc64_elf_unhandled_reloc, /* special_function */
 523          "R_PPC64_GOT16_HI",    /* name */
 524          FALSE,                 /* partial_inplace */
 525          0,                     /* src_mask */
 526          0xffff,                /* dst_mask */
 527          FALSE),                /* pcrel_offset */
 528
 529   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 530      the symbol.  */
 531   HOWTO (R_PPC64_GOT16_HA,      /* type */
 532          16,                    /* rightshift */
 533          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 534          16,                    /* bitsize */
 535          FALSE,                 /* pc_relative */
 536          0,                     /* bitpos */
 537          complain_overflow_signed,/* complain_on_overflow */
 538          ppc64_elf_unhandled_reloc, /* special_function */
 539          "R_PPC64_GOT16_HA",    /* name */
 540          FALSE,                 /* partial_inplace */
 541          0,                     /* src_mask */
 542          0xffff,                /* dst_mask */
 543          FALSE),                /* pcrel_offset */
 544
 545   /* This is used only by the dynamic linker.  The symbol should exist
 546      both in the object being run and in some shared library.  The
 547      dynamic linker copies the data addressed by the symbol from the
 548      shared library into the object, because the object being
 549      run has to have the data at some particular address.  */
 550   HOWTO (R_PPC64_COPY,          /* type */
 551          0,                     /* rightshift */
 552          0,                     /* this one is variable size */
 553          0,                     /* bitsize */
 554          FALSE,                 /* pc_relative */
 555          0,                     /* bitpos */
 556          complain_overflow_dont, /* complain_on_overflow */
 557          ppc64_elf_unhandled_reloc, /* special_function */
 558          "R_PPC64_COPY",        /* name */
 559          FALSE,                 /* partial_inplace */
 560          0,                     /* src_mask */
 561          0,                     /* dst_mask */
 562          FALSE),                /* pcrel_offset */
 563
 564   /* Like R_PPC64_ADDR64, but used when setting global offset table
 565      entries.  */
 566   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 567          0,                     /* rightshift */
 568          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 569          64,                    /* bitsize */
 570          FALSE,                 /* pc_relative */
 571          0,                     /* bitpos */
 572          complain_overflow_dont, /* complain_on_overflow */
 573          ppc64_elf_unhandled_reloc,  /* special_function */
 574          "R_PPC64_GLOB_DAT",    /* name */
 575          FALSE,                 /* partial_inplace */
 576          0,                     /* src_mask */
 577          ONES (64),             /* dst_mask */
 578          FALSE),                /* pcrel_offset */
 579
 580   /* Created by the link editor.  Marks a procedure linkage table
 581      entry for a symbol.  */
 582   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 583          0,                     /* rightshift */
 584          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 585          0,                     /* bitsize */
 586          FALSE,                 /* pc_relative */
 587          0,                     /* bitpos */
 588          complain_overflow_dont, /* complain_on_overflow */
 589          ppc64_elf_unhandled_reloc, /* special_function */
 590          "R_PPC64_JMP_SLOT",    /* name */
 591          FALSE,                 /* partial_inplace */
 592          0,                     /* src_mask */
 593          0,                     /* dst_mask */
 594          FALSE),                /* pcrel_offset */
 595
 596   /* Used only by the dynamic linker.  When the object is run, this
 597      doubleword64 is set to the load address of the object, plus the
 598      addend.  */
 599   HOWTO (R_PPC64_RELATIVE,      /* type */
 600          0,                     /* rightshift */
 601          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 602          64,                    /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_dont, /* complain_on_overflow */
 606          bfd_elf_generic_reloc, /* special_function */
 607          "R_PPC64_RELATIVE",    /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          ONES (64),             /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 614   HOWTO (R_PPC64_UADDR32,       /* type */
 615          0,                     /* rightshift */
 616          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 617          32,                    /* bitsize */
 618          FALSE,                 /* pc_relative */
 619          0,                     /* bitpos */
 620          complain_overflow_bitfield, /* complain_on_overflow */
 621          bfd_elf_generic_reloc, /* special_function */
 622          "R_PPC64_UADDR32",     /* name */
 623          FALSE,                 /* partial_inplace */
 624          0,                     /* src_mask */
 625          0xffffffff,            /* dst_mask */
 626          FALSE),                /* pcrel_offset */
 627
 628   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 629   HOWTO (R_PPC64_UADDR16,       /* type */
 630          0,                     /* rightshift */
 631          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 632          16,                    /* bitsize */
 633          FALSE,                 /* pc_relative */
 634          0,                     /* bitpos */
 635          complain_overflow_bitfield, /* complain_on_overflow */
 636          bfd_elf_generic_reloc, /* special_function */
 637          "R_PPC64_UADDR16",     /* name */
 638          FALSE,                 /* partial_inplace */
 639          0,                     /* src_mask */
 640          0xffff,                /* dst_mask */
 641          FALSE),                /* pcrel_offset */
 642
 643   /* 32-bit PC relative.  */
 644   HOWTO (R_PPC64_REL32,         /* type */
 645          0,                     /* rightshift */
 646          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 647          32,                    /* bitsize */
 648          TRUE,                  /* pc_relative */
 649          0,                     /* bitpos */
 650          complain_overflow_signed, /* complain_on_overflow */
 651          bfd_elf_generic_reloc, /* special_function */
 652          "R_PPC64_REL32",       /* name */
 653          FALSE,                 /* partial_inplace */
 654          0,                     /* src_mask */
 655          0xffffffff,            /* dst_mask */
 656          TRUE),                 /* pcrel_offset */
 657
 658   /* 32-bit relocation to the symbol's procedure linkage table.  */
 659   HOWTO (R_PPC64_PLT32,         /* type */
 660          0,                     /* rightshift */
 661          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 662          32,                    /* bitsize */
 663          FALSE,                 /* pc_relative */
 664          0,                     /* bitpos */
 665          complain_overflow_bitfield, /* complain_on_overflow */
 666          ppc64_elf_unhandled_reloc, /* special_function */
 667          "R_PPC64_PLT32",       /* name */
 668          FALSE,                 /* partial_inplace */
 669          0,                     /* src_mask */
 670          0xffffffff,            /* dst_mask */
 671          FALSE),                /* pcrel_offset */
 672
 673   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 674      FIXME: R_PPC64_PLTREL32 not supported.  */
 675   HOWTO (R_PPC64_PLTREL32,      /* type */
 676          0,                     /* rightshift */
 677          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 678          32,                    /* bitsize */
 679          TRUE,                  /* pc_relative */
 680          0,                     /* bitpos */
 681          complain_overflow_signed, /* complain_on_overflow */
 682          bfd_elf_generic_reloc, /* special_function */
 683          "R_PPC64_PLTREL32",    /* name */
 684          FALSE,                 /* partial_inplace */
 685          0,                     /* src_mask */
 686          0xffffffff,            /* dst_mask */
 687          TRUE),                 /* pcrel_offset */
 688
 689   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 690      the symbol.  */
 691   HOWTO (R_PPC64_PLT16_LO,      /* type */
 692          0,                     /* rightshift */
 693          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 694          16,                    /* bitsize */
 695          FALSE,                 /* pc_relative */
 696          0,                     /* bitpos */
 697          complain_overflow_dont, /* complain_on_overflow */
 698          ppc64_elf_unhandled_reloc, /* special_function */
 699          "R_PPC64_PLT16_LO",    /* name */
 700          FALSE,                 /* partial_inplace */
 701          0,                     /* src_mask */
 702          0xffff,                /* dst_mask */
 703          FALSE),                /* pcrel_offset */
 704
 705   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 706      the symbol.  */
 707   HOWTO (R_PPC64_PLT16_HI,      /* type */
 708          16,                    /* rightshift */
 709          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 710          16,                    /* bitsize */
 711          FALSE,                 /* pc_relative */
 712          0,                     /* bitpos */
 713          complain_overflow_signed, /* complain_on_overflow */
 714          ppc64_elf_unhandled_reloc, /* special_function */
 715          "R_PPC64_PLT16_HI",    /* name */
 716          FALSE,                 /* partial_inplace */
 717          0,                     /* src_mask */
 718          0xffff,                /* dst_mask */
 719          FALSE),                /* pcrel_offset */
 720
 721   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 722      the symbol.  */
 723   HOWTO (R_PPC64_PLT16_HA,      /* type */
 724          16,                    /* rightshift */
 725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          16,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_signed, /* complain_on_overflow */
 730          ppc64_elf_unhandled_reloc, /* special_function */
 731          "R_PPC64_PLT16_HA",    /* name */
 732          FALSE,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffff,                /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* 16-bit section relative relocation.  */
 738   HOWTO (R_PPC64_SECTOFF,       /* type */
 739          0,                     /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_signed, /* complain_on_overflow */
 745          ppc64_elf_sectoff_reloc, /* special_function */
 746          "R_PPC64_SECTOFF",     /* name */
 747          FALSE,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 753   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 754          0,                     /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_dont, /* complain_on_overflow */
 760          ppc64_elf_sectoff_reloc, /* special_function */
 761          "R_PPC64_SECTOFF_LO",  /* name */
 762          FALSE,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* 16-bit upper half section relative relocation.  */
 768   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 769          16,                    /* rightshift */
 770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          16,                    /* bitsize */
 772          FALSE,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_signed, /* complain_on_overflow */
 775          ppc64_elf_sectoff_reloc, /* special_function */
 776          "R_PPC64_SECTOFF_HI",  /* name */
 777          FALSE,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xffff,                /* dst_mask */
 780          FALSE),                /* pcrel_offset */
 781
 782   /* 16-bit upper half adjusted section relative relocation.  */
 783   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 784          16,                    /* rightshift */
 785          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 786          16,                    /* bitsize */
 787          FALSE,                 /* pc_relative */
 788          0,                     /* bitpos */
 789          complain_overflow_signed, /* complain_on_overflow */
 790          ppc64_elf_sectoff_ha_reloc, /* special_function */
 791          "R_PPC64_SECTOFF_HA",  /* name */
 792          FALSE,                 /* partial_inplace */
 793          0,                     /* src_mask */
 794          0xffff,                /* dst_mask */
 795          FALSE),                /* pcrel_offset */
 796
 797   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 798   HOWTO (R_PPC64_REL30,         /* type */
 799          2,                     /* rightshift */
 800          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 801          30,                    /* bitsize */
 802          TRUE,                  /* pc_relative */
 803          0,                     /* bitpos */
 804          complain_overflow_dont, /* complain_on_overflow */
 805          bfd_elf_generic_reloc, /* special_function */
 806          "R_PPC64_REL30",       /* name */
 807          FALSE,                 /* partial_inplace */
 808          0,                     /* src_mask */
 809          0xfffffffc,            /* dst_mask */
 810          TRUE),                 /* pcrel_offset */
 811
 812   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 813
 814   /* A standard 64-bit relocation.  */
 815   HOWTO (R_PPC64_ADDR64,        /* type */
 816          0,                     /* rightshift */
 817          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 818          64,                    /* bitsize */
 819          FALSE,                 /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_PPC64_ADDR64",      /* name */
 824          FALSE,                 /* partial_inplace */
 825          0,                     /* src_mask */
 826          ONES (64),             /* dst_mask */
 827          FALSE),                /* pcrel_offset */
 828
 829   /* The bits 32-47 of an address.  */
 830   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 831          32,                    /* rightshift */
 832          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 833          16,                    /* bitsize */
 834          FALSE,                 /* pc_relative */
 835          0,                     /* bitpos */
 836          complain_overflow_dont, /* complain_on_overflow */
 837          bfd_elf_generic_reloc, /* special_function */
 838          "R_PPC64_ADDR16_HIGHER", /* name */
 839          FALSE,                 /* partial_inplace */
 840          0,                     /* src_mask */
 841          0xffff,                /* dst_mask */
 842          FALSE),                /* pcrel_offset */
 843
 844   /* The bits 32-47 of an address, plus 1 if the contents of the low
 845      16 bits, treated as a signed number, is negative.  */
 846   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 847          32,                    /* rightshift */
 848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          16,                    /* bitsize */
 850          FALSE,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_dont, /* complain_on_overflow */
 853          ppc64_elf_ha_reloc,    /* special_function */
 854          "R_PPC64_ADDR16_HIGHERA", /* name */
 855          FALSE,                 /* partial_inplace */
 856          0,                     /* src_mask */
 857          0xffff,                /* dst_mask */
 858          FALSE),                /* pcrel_offset */
 859
 860   /* The bits 48-63 of an address.  */
 861   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 862          48,                    /* rightshift */
 863          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 864          16,                    /* bitsize */
 865          FALSE,                 /* pc_relative */
 866          0,                     /* bitpos */
 867          complain_overflow_dont, /* complain_on_overflow */
 868          bfd_elf_generic_reloc, /* special_function */
 869          "R_PPC64_ADDR16_HIGHEST", /* name */
 870          FALSE,                 /* partial_inplace */
 871          0,                     /* src_mask */
 872          0xffff,                /* dst_mask */
 873          FALSE),                /* pcrel_offset */
 874
 875   /* The bits 48-63 of an address, plus 1 if the contents of the low
 876      16 bits, treated as a signed number, is negative.  */
 877   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 878          48,                    /* rightshift */
 879          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 880          16,                    /* bitsize */
 881          FALSE,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont, /* complain_on_overflow */
 884          ppc64_elf_ha_reloc,    /* special_function */
 885          "R_PPC64_ADDR16_HIGHESTA", /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          0xffff,                /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* Like ADDR64, but may be unaligned.  */
 892   HOWTO (R_PPC64_UADDR64,       /* type */
 893          0,                     /* rightshift */
 894          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 895          64,                    /* bitsize */
 896          FALSE,                 /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          bfd_elf_generic_reloc, /* special_function */
 900          "R_PPC64_UADDR64",     /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          ONES (64),             /* dst_mask */
 904          FALSE),                /* pcrel_offset */
 905
 906   /* 64-bit relative relocation.  */
 907   HOWTO (R_PPC64_REL64,         /* type */
 908          0,                     /* rightshift */
 909          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 910          64,                    /* bitsize */
 911          TRUE,                  /* pc_relative */
 912          0,                     /* bitpos */
 913          complain_overflow_dont, /* complain_on_overflow */
 914          bfd_elf_generic_reloc, /* special_function */
 915          "R_PPC64_REL64",       /* name */
 916          FALSE,                 /* partial_inplace */
 917          0,                     /* src_mask */
 918          ONES (64),             /* dst_mask */
 919          TRUE),                 /* pcrel_offset */
 920
 921   /* 64-bit relocation to the symbol's procedure linkage table.  */
 922   HOWTO (R_PPC64_PLT64,         /* type */
 923          0,                     /* rightshift */
 924          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 925          64,                    /* bitsize */
 926          FALSE,                 /* pc_relative */
 927          0,                     /* bitpos */
 928          complain_overflow_dont, /* complain_on_overflow */
 929          ppc64_elf_unhandled_reloc, /* special_function */
 930          "R_PPC64_PLT64",       /* name */
 931          FALSE,                 /* partial_inplace */
 932          0,                     /* src_mask */
 933          ONES (64),             /* dst_mask */
 934          FALSE),                /* pcrel_offset */
 935
 936   /* 64-bit PC relative relocation to the symbol's procedure linkage
 937      table.  */
 938   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 939   HOWTO (R_PPC64_PLTREL64,      /* type */
 940          0,                     /* rightshift */
 941          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 942          64,                    /* bitsize */
 943          TRUE,                  /* pc_relative */
 944          0,                     /* bitpos */
 945          complain_overflow_dont, /* complain_on_overflow */
 946          ppc64_elf_unhandled_reloc, /* special_function */
 947          "R_PPC64_PLTREL64",    /* name */
 948          FALSE,                 /* partial_inplace */
 949          0,                     /* src_mask */
 950          ONES (64),             /* dst_mask */
 951          TRUE),                 /* pcrel_offset */
 952
 953   /* 16 bit TOC-relative relocation.  */
 954
 955   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 956   HOWTO (R_PPC64_TOC16,         /* type */
 957          0,                     /* rightshift */
 958          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 959          16,                    /* bitsize */
 960          FALSE,                 /* pc_relative */
 961          0,                     /* bitpos */
 962          complain_overflow_signed, /* complain_on_overflow */
 963          ppc64_elf_toc_reloc,   /* special_function */
 964          "R_PPC64_TOC16",       /* name */
 965          FALSE,                 /* partial_inplace */
 966          0,                     /* src_mask */
 967          0xffff,                /* dst_mask */
 968          FALSE),                /* pcrel_offset */
 969
 970   /* 16 bit TOC-relative relocation without overflow.  */
 971
 972   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 973   HOWTO (R_PPC64_TOC16_LO,      /* type */
 974          0,                     /* rightshift */
 975          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 976          16,                    /* bitsize */
 977          FALSE,                 /* pc_relative */
 978          0,                     /* bitpos */
 979          complain_overflow_dont, /* complain_on_overflow */
 980          ppc64_elf_toc_reloc,   /* special_function */
 981          "R_PPC64_TOC16_LO",    /* name */
 982          FALSE,                 /* partial_inplace */
 983          0,                     /* src_mask */
 984          0xffff,                /* dst_mask */
 985          FALSE),                /* pcrel_offset */
 986
 987   /* 16 bit TOC-relative relocation, high 16 bits.  */
 988
 989   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 990   HOWTO (R_PPC64_TOC16_HI,      /* type */
 991          16,                    /* rightshift */
 992          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 993          16,                    /* bitsize */
 994          FALSE,                 /* pc_relative */
 995          0,                     /* bitpos */
 996          complain_overflow_signed, /* complain_on_overflow */
 997          ppc64_elf_toc_reloc,   /* special_function */
 998          "R_PPC64_TOC16_HI",    /* name */
 999          FALSE,                 /* partial_inplace */
1000          0,                     /* src_mask */
1001          0xffff,                /* dst_mask */
1002          FALSE),                /* pcrel_offset */
1003
1004   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1005      contents of the low 16 bits, treated as a signed number, is
1006      negative.  */
1007
1008   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1009   HOWTO (R_PPC64_TOC16_HA,      /* type */
1010          16,                    /* rightshift */
1011          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1012          16,                    /* bitsize */
1013          FALSE,                 /* pc_relative */
1014          0,                     /* bitpos */
1015          complain_overflow_signed, /* complain_on_overflow */
1016          ppc64_elf_toc_ha_reloc, /* special_function */
1017          "R_PPC64_TOC16_HA",    /* name */
1018          FALSE,                 /* partial_inplace */
1019          0,                     /* src_mask */
1020          0xffff,                /* dst_mask */
1021          FALSE),                /* pcrel_offset */
1022
1023   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1024
1025   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1026   HOWTO (R_PPC64_TOC,           /* type */
1027          0,                     /* rightshift */
1028          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1029          64,                    /* bitsize */
1030          FALSE,                 /* pc_relative */
1031          0,                     /* bitpos */
1032          complain_overflow_dont, /* complain_on_overflow */
1033          ppc64_elf_toc64_reloc, /* special_function */
1034          "R_PPC64_TOC",         /* name */
1035          FALSE,                 /* partial_inplace */
1036          0,                     /* src_mask */
1037          ONES (64),             /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* Like R_PPC64_GOT16, but also informs the link editor that the
1041      value to relocate may (!) refer to a PLT entry which the link
1042      editor (a) may replace with the symbol value.  If the link editor
1043      is unable to fully resolve the symbol, it may (b) create a PLT
1044      entry and store the address to the new PLT entry in the GOT.
1045      This permits lazy resolution of function symbols at run time.
1046      The link editor may also skip all of this and just (c) emit a
1047      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1048   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1049     HOWTO (R_PPC64_PLTGOT16,    /* type */
1050          0,                     /* rightshift */
1051          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1052          16,                    /* bitsize */
1053          FALSE,                 /* pc_relative */
1054          0,                     /* bitpos */
1055          complain_overflow_signed, /* complain_on_overflow */
1056          ppc64_elf_unhandled_reloc, /* special_function */
1057          "R_PPC64_PLTGOT16",    /* name */
1058          FALSE,                 /* partial_inplace */
1059          0,                     /* src_mask */
1060          0xffff,                /* dst_mask */
1061          FALSE),                /* pcrel_offset */
1062
1063   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1064   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1065   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1066          0,                     /* rightshift */
1067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1068          16,                    /* bitsize */
1069          FALSE,                 /* pc_relative */
1070          0,                     /* bitpos */
1071          complain_overflow_dont, /* complain_on_overflow */
1072          ppc64_elf_unhandled_reloc, /* special_function */
1073          "R_PPC64_PLTGOT16_LO", /* name */
1074          FALSE,                 /* partial_inplace */
1075          0,                     /* src_mask */
1076          0xffff,                /* dst_mask */
1077          FALSE),                /* pcrel_offset */
1078
1079   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1080   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1081   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1082          16,                    /* rightshift */
1083          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1084          16,                    /* bitsize */
1085          FALSE,                 /* pc_relative */
1086          0,                     /* bitpos */
1087          complain_overflow_signed, /* complain_on_overflow */
1088          ppc64_elf_unhandled_reloc, /* special_function */
1089          "R_PPC64_PLTGOT16_HI", /* name */
1090          FALSE,                 /* partial_inplace */
1091          0,                     /* src_mask */
1092          0xffff,                /* dst_mask */
1093          FALSE),                /* pcrel_offset */
1094
1095   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1096      1 if the contents of the low 16 bits, treated as a signed number,
1097      is negative.  */
1098   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1099   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1100          16,                    /* rightshift */
1101          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1102          16,                    /* bitsize */
1103          FALSE,                 /* pc_relative */
1104          0,                     /* bitpos */
1105          complain_overflow_signed, /* complain_on_overflow */
1106          ppc64_elf_unhandled_reloc, /* special_function */
1107          "R_PPC64_PLTGOT16_HA", /* name */
1108          FALSE,                 /* partial_inplace */
1109          0,                     /* src_mask */
1110          0xffff,                /* dst_mask */
1111          FALSE),                /* pcrel_offset */
1112
1113   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1114   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1115          0,                     /* rightshift */
1116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1117          16,                    /* bitsize */
1118          FALSE,                 /* pc_relative */
1119          0,                     /* bitpos */
1120          complain_overflow_signed, /* complain_on_overflow */
1121          bfd_elf_generic_reloc, /* special_function */
1122          "R_PPC64_ADDR16_DS",   /* name */
1123          FALSE,                 /* partial_inplace */
1124          0,                     /* src_mask */
1125          0xfffc,                /* dst_mask */
1126          FALSE),                /* pcrel_offset */
1127
1128   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1129   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1130          0,                     /* rightshift */
1131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          16,                    /* bitsize */
1133          FALSE,                 /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_dont,/* complain_on_overflow */
1136          bfd_elf_generic_reloc, /* special_function */
1137          "R_PPC64_ADDR16_LO_DS",/* name */
1138          FALSE,                 /* partial_inplace */
1139          0,                     /* src_mask */
1140          0xfffc,                /* dst_mask */
1141          FALSE),                /* pcrel_offset */
1142
1143   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1144   HOWTO (R_PPC64_GOT16_DS,      /* type */
1145          0,                     /* rightshift */
1146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1147          16,                    /* bitsize */
1148          FALSE,                 /* pc_relative */
1149          0,                     /* bitpos */
1150          complain_overflow_signed, /* complain_on_overflow */
1151          ppc64_elf_unhandled_reloc, /* special_function */
1152          "R_PPC64_GOT16_DS",    /* name */
1153          FALSE,                 /* partial_inplace */
1154          0,                     /* src_mask */
1155          0xfffc,                /* dst_mask */
1156          FALSE),                /* pcrel_offset */
1157
1158   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1159   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1160          0,                     /* rightshift */
1161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          16,                    /* bitsize */
1163          FALSE,                 /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_dont, /* complain_on_overflow */
1166          ppc64_elf_unhandled_reloc, /* special_function */
1167          "R_PPC64_GOT16_LO_DS", /* name */
1168          FALSE,                 /* partial_inplace */
1169          0,                     /* src_mask */
1170          0xfffc,                /* dst_mask */
1171          FALSE),                /* pcrel_offset */
1172
1173   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1174   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1175          0,                     /* rightshift */
1176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1177          16,                    /* bitsize */
1178          FALSE,                 /* pc_relative */
1179          0,                     /* bitpos */
1180          complain_overflow_dont, /* complain_on_overflow */
1181          ppc64_elf_unhandled_reloc, /* special_function */
1182          "R_PPC64_PLT16_LO_DS", /* name */
1183          FALSE,                 /* partial_inplace */
1184          0,                     /* src_mask */
1185          0xfffc,                /* dst_mask */
1186          FALSE),                /* pcrel_offset */
1187
1188   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1189   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          FALSE,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_signed, /* complain_on_overflow */
1196          ppc64_elf_sectoff_reloc, /* special_function */
1197          "R_PPC64_SECTOFF_DS",  /* name */
1198          FALSE,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          FALSE),                /* pcrel_offset */
1202
1203   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1204   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1205          0,                     /* rightshift */
1206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          16,                    /* bitsize */
1208          FALSE,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_dont, /* complain_on_overflow */
1211          ppc64_elf_sectoff_reloc, /* special_function */
1212          "R_PPC64_SECTOFF_LO_DS",/* name */
1213          FALSE,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0xfffc,                /* dst_mask */
1216          FALSE),                /* pcrel_offset */
1217
1218   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1219   HOWTO (R_PPC64_TOC16_DS,      /* type */
1220          0,                     /* rightshift */
1221          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1222          16,                    /* bitsize */
1223          FALSE,                 /* pc_relative */
1224          0,                     /* bitpos */
1225          complain_overflow_signed, /* complain_on_overflow */
1226          ppc64_elf_toc_reloc,   /* special_function */
1227          "R_PPC64_TOC16_DS",    /* name */
1228          FALSE,                 /* partial_inplace */
1229          0,                     /* src_mask */
1230          0xfffc,                /* dst_mask */
1231          FALSE),                /* pcrel_offset */
1232
1233   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1234   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1235          0,                     /* rightshift */
1236          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1237          16,                    /* bitsize */
1238          FALSE,                 /* pc_relative */
1239          0,                     /* bitpos */
1240          complain_overflow_dont, /* complain_on_overflow */
1241          ppc64_elf_toc_reloc,   /* special_function */
1242          "R_PPC64_TOC16_LO_DS", /* name */
1243          FALSE,                 /* partial_inplace */
1244          0,                     /* src_mask */
1245          0xfffc,                /* dst_mask */
1246          FALSE),                /* pcrel_offset */
1247
1248   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1249   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1250   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1251          0,                     /* rightshift */
1252          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1253          16,                    /* bitsize */
1254          FALSE,                 /* pc_relative */
1255          0,                     /* bitpos */
1256          complain_overflow_signed, /* complain_on_overflow */
1257          ppc64_elf_unhandled_reloc, /* special_function */
1258          "R_PPC64_PLTGOT16_DS", /* name */
1259          FALSE,                 /* partial_inplace */
1260          0,                     /* src_mask */
1261          0xfffc,                /* dst_mask */
1262          FALSE),                /* pcrel_offset */
1263
1264   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1265   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1266   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1267          0,                     /* rightshift */
1268          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1269          16,                    /* bitsize */
1270          FALSE,                 /* pc_relative */
1271          0,                     /* bitpos */
1272          complain_overflow_dont, /* complain_on_overflow */
1273          ppc64_elf_unhandled_reloc, /* special_function */
1274          "R_PPC64_PLTGOT16_LO_DS",/* name */
1275          FALSE,                 /* partial_inplace */
1276          0,                     /* src_mask */
1277          0xfffc,                /* dst_mask */
1278          FALSE),                /* pcrel_offset */
1279
1280   /* Marker relocs for TLS.  */
1281   HOWTO (R_PPC64_TLS,
1282          0,                     /* rightshift */
1283          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1284          32,                    /* bitsize */
1285          FALSE,                 /* pc_relative */
1286          0,                     /* bitpos */
1287          complain_overflow_dont, /* complain_on_overflow */
1288          bfd_elf_generic_reloc, /* special_function */
1289          "R_PPC64_TLS",         /* name */
1290          FALSE,                 /* partial_inplace */
1291          0,                     /* src_mask */
1292          0,                     /* dst_mask */
1293          FALSE),                /* pcrel_offset */
1294
1295   HOWTO (R_PPC64_TLSGD,
1296          0,                     /* rightshift */
1297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1298          32,                    /* bitsize */
1299          FALSE,                 /* pc_relative */
1300          0,                     /* bitpos */
1301          complain_overflow_dont, /* complain_on_overflow */
1302          bfd_elf_generic_reloc, /* special_function */
1303          "R_PPC64_TLSGD",       /* name */
1304          FALSE,                 /* partial_inplace */
1305          0,                     /* src_mask */
1306          0,                     /* dst_mask */
1307          FALSE),                /* pcrel_offset */
1308
1309   HOWTO (R_PPC64_TLSLD,
1310          0,                     /* rightshift */
1311          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1312          32,                    /* bitsize */
1313          FALSE,                 /* pc_relative */
1314          0,                     /* bitpos */
1315          complain_overflow_dont, /* complain_on_overflow */
1316          bfd_elf_generic_reloc, /* special_function */
1317          "R_PPC64_TLSLD",       /* name */
1318          FALSE,                 /* partial_inplace */
1319          0,                     /* src_mask */
1320          0,                     /* dst_mask */
1321          FALSE),                /* pcrel_offset */
1322
1323   HOWTO (R_PPC64_TOCSAVE,
1324          0,                     /* rightshift */
1325          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1326          32,                    /* bitsize */
1327          FALSE,                 /* pc_relative */
1328          0,                     /* bitpos */
1329          complain_overflow_dont, /* complain_on_overflow */
1330          bfd_elf_generic_reloc, /* special_function */
1331          "R_PPC64_TOCSAVE",     /* name */
1332          FALSE,                 /* partial_inplace */
1333          0,                     /* src_mask */
1334          0,                     /* dst_mask */
1335          FALSE),                /* pcrel_offset */
1336
1337   /* Computes the load module index of the load module that contains the
1338      definition of its TLS sym.  */
1339   HOWTO (R_PPC64_DTPMOD64,
1340          0,                     /* rightshift */
1341          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1342          64,                    /* bitsize */
1343          FALSE,                 /* pc_relative */
1344          0,                     /* bitpos */
1345          complain_overflow_dont, /* complain_on_overflow */
1346          ppc64_elf_unhandled_reloc, /* special_function */
1347          "R_PPC64_DTPMOD64",    /* name */
1348          FALSE,                 /* partial_inplace */
1349          0,                     /* src_mask */
1350          ONES (64),             /* dst_mask */
1351          FALSE),                /* pcrel_offset */
1352
1353   /* Computes a dtv-relative displacement, the difference between the value
1354      of sym+add and the base address of the thread-local storage block that
1355      contains the definition of sym, minus 0x8000.  */
1356   HOWTO (R_PPC64_DTPREL64,
1357          0,                     /* rightshift */
1358          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1359          64,                    /* bitsize */
1360          FALSE,                 /* pc_relative */
1361          0,                     /* bitpos */
1362          complain_overflow_dont, /* complain_on_overflow */
1363          ppc64_elf_unhandled_reloc, /* special_function */
1364          "R_PPC64_DTPREL64",    /* name */
1365          FALSE,                 /* partial_inplace */
1366          0,                     /* src_mask */
1367          ONES (64),             /* dst_mask */
1368          FALSE),                /* pcrel_offset */
1369
1370   /* A 16 bit dtprel reloc.  */
1371   HOWTO (R_PPC64_DTPREL16,
1372          0,                     /* rightshift */
1373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          16,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_signed, /* complain_on_overflow */
1378          ppc64_elf_unhandled_reloc, /* special_function */
1379          "R_PPC64_DTPREL16",    /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0xffff,                /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Like DTPREL16, but no overflow.  */
1386   HOWTO (R_PPC64_DTPREL16_LO,
1387          0,                     /* rightshift */
1388          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          16,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_dont, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPREL16_LO", /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          0xffff,                /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1401   HOWTO (R_PPC64_DTPREL16_HI,
1402          16,                    /* rightshift */
1403          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          16,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_signed, /* complain_on_overflow */
1408          ppc64_elf_unhandled_reloc, /* special_function */
1409          "R_PPC64_DTPREL16_HI", /* name */
1410          FALSE,                 /* partial_inplace */
1411          0,                     /* src_mask */
1412          0xffff,                /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1416   HOWTO (R_PPC64_DTPREL16_HA,
1417          16,                    /* rightshift */
1418          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          16,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_signed, /* complain_on_overflow */
1423          ppc64_elf_unhandled_reloc, /* special_function */
1424          "R_PPC64_DTPREL16_HA", /* name */
1425          FALSE,                 /* partial_inplace */
1426          0,                     /* src_mask */
1427          0xffff,                /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1431   HOWTO (R_PPC64_DTPREL16_HIGHER,
1432          32,                    /* rightshift */
1433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_dont, /* complain_on_overflow */
1438          ppc64_elf_unhandled_reloc, /* special_function */
1439          "R_PPC64_DTPREL16_HIGHER", /* name */
1440          FALSE,                 /* partial_inplace */
1441          0,                     /* src_mask */
1442          0xffff,                /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1446   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1447          32,                    /* rightshift */
1448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          16,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_dont, /* complain_on_overflow */
1453          ppc64_elf_unhandled_reloc, /* special_function */
1454          "R_PPC64_DTPREL16_HIGHERA", /* name */
1455          FALSE,                 /* partial_inplace */
1456          0,                     /* src_mask */
1457          0xffff,                /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1461   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1462          48,                    /* rightshift */
1463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1464          16,                    /* bitsize */
1465          FALSE,                 /* pc_relative */
1466          0,                     /* bitpos */
1467          complain_overflow_dont, /* complain_on_overflow */
1468          ppc64_elf_unhandled_reloc, /* special_function */
1469          "R_PPC64_DTPREL16_HIGHEST", /* name */
1470          FALSE,                 /* partial_inplace */
1471          0,                     /* src_mask */
1472          0xffff,                /* dst_mask */
1473          FALSE),                /* pcrel_offset */
1474
1475   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1476   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1477          48,                    /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          16,                    /* bitsize */
1480          FALSE,                 /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_dont, /* complain_on_overflow */
1483          ppc64_elf_unhandled_reloc, /* special_function */
1484          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1485          FALSE,                 /* partial_inplace */
1486          0,                     /* src_mask */
1487          0xffff,                /* dst_mask */
1488          FALSE),                /* pcrel_offset */
1489
1490   /* Like DTPREL16, but for insns with a DS field.  */
1491   HOWTO (R_PPC64_DTPREL16_DS,
1492          0,                     /* rightshift */
1493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1494          16,                    /* bitsize */
1495          FALSE,                 /* pc_relative */
1496          0,                     /* bitpos */
1497          complain_overflow_signed, /* complain_on_overflow */
1498          ppc64_elf_unhandled_reloc, /* special_function */
1499          "R_PPC64_DTPREL16_DS", /* name */
1500          FALSE,                 /* partial_inplace */
1501          0,                     /* src_mask */
1502          0xfffc,                /* dst_mask */
1503          FALSE),                /* pcrel_offset */
1504
1505   /* Like DTPREL16_DS, but no overflow.  */
1506   HOWTO (R_PPC64_DTPREL16_LO_DS,
1507          0,                     /* rightshift */
1508          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1509          16,                    /* bitsize */
1510          FALSE,                 /* pc_relative */
1511          0,                     /* bitpos */
1512          complain_overflow_dont, /* complain_on_overflow */
1513          ppc64_elf_unhandled_reloc, /* special_function */
1514          "R_PPC64_DTPREL16_LO_DS", /* name */
1515          FALSE,                 /* partial_inplace */
1516          0,                     /* src_mask */
1517          0xfffc,                /* dst_mask */
1518          FALSE),                /* pcrel_offset */
1519
1520   /* Computes a tp-relative displacement, the difference between the value of
1521      sym+add and the value of the thread pointer (r13).  */
1522   HOWTO (R_PPC64_TPREL64,
1523          0,                     /* rightshift */
1524          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          64,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_dont, /* complain_on_overflow */
1529          ppc64_elf_unhandled_reloc, /* special_function */
1530          "R_PPC64_TPREL64",     /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          ONES (64),             /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* A 16 bit tprel reloc.  */
1537   HOWTO (R_PPC64_TPREL16,
1538          0,                     /* rightshift */
1539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          16,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_signed, /* complain_on_overflow */
1544          ppc64_elf_unhandled_reloc, /* special_function */
1545          "R_PPC64_TPREL16",     /* name */
1546          FALSE,                 /* partial_inplace */
1547          0,                     /* src_mask */
1548          0xffff,                /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   /* Like TPREL16, but no overflow.  */
1552   HOWTO (R_PPC64_TPREL16_LO,
1553          0,                     /* rightshift */
1554          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1555          16,                    /* bitsize */
1556          FALSE,                 /* pc_relative */
1557          0,                     /* bitpos */
1558          complain_overflow_dont, /* complain_on_overflow */
1559          ppc64_elf_unhandled_reloc, /* special_function */
1560          "R_PPC64_TPREL16_LO",  /* name */
1561          FALSE,                 /* partial_inplace */
1562          0,                     /* src_mask */
1563          0xffff,                /* dst_mask */
1564          FALSE),                /* pcrel_offset */
1565
1566   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1567   HOWTO (R_PPC64_TPREL16_HI,
1568          16,                    /* rightshift */
1569          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1570          16,                    /* bitsize */
1571          FALSE,                 /* pc_relative */
1572          0,                     /* bitpos */
1573          complain_overflow_signed, /* complain_on_overflow */
1574          ppc64_elf_unhandled_reloc, /* special_function */
1575          "R_PPC64_TPREL16_HI",  /* name */
1576          FALSE,                 /* partial_inplace */
1577          0,                     /* src_mask */
1578          0xffff,                /* dst_mask */
1579          FALSE),                /* pcrel_offset */
1580
1581   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1582   HOWTO (R_PPC64_TPREL16_HA,
1583          16,                    /* rightshift */
1584          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1585          16,                    /* bitsize */
1586          FALSE,                 /* pc_relative */
1587          0,                     /* bitpos */
1588          complain_overflow_signed, /* complain_on_overflow */
1589          ppc64_elf_unhandled_reloc, /* special_function */
1590          "R_PPC64_TPREL16_HA",  /* name */
1591          FALSE,                 /* partial_inplace */
1592          0,                     /* src_mask */
1593          0xffff,                /* dst_mask */
1594          FALSE),                /* pcrel_offset */
1595
1596   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1597   HOWTO (R_PPC64_TPREL16_HIGHER,
1598          32,                    /* rightshift */
1599          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1600          16,                    /* bitsize */
1601          FALSE,                 /* pc_relative */
1602          0,                     /* bitpos */
1603          complain_overflow_dont, /* complain_on_overflow */
1604          ppc64_elf_unhandled_reloc, /* special_function */
1605          "R_PPC64_TPREL16_HIGHER",      /* name */
1606          FALSE,                 /* partial_inplace */
1607          0,                     /* src_mask */
1608          0xffff,                /* dst_mask */
1609          FALSE),                /* pcrel_offset */
1610
1611   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1612   HOWTO (R_PPC64_TPREL16_HIGHERA,
1613          32,                    /* rightshift */
1614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          16,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont, /* complain_on_overflow */
1619          ppc64_elf_unhandled_reloc, /* special_function */
1620          "R_PPC64_TPREL16_HIGHERA", /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0xffff,                /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1627   HOWTO (R_PPC64_TPREL16_HIGHEST,
1628          48,                    /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          16,                    /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_dont, /* complain_on_overflow */
1634          ppc64_elf_unhandled_reloc, /* special_function */
1635          "R_PPC64_TPREL16_HIGHEST", /* name */
1636          FALSE,                 /* partial_inplace */
1637          0,                     /* src_mask */
1638          0xffff,                /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640
1641   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1642   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1643          48,                    /* rightshift */
1644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          16,                    /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_dont, /* complain_on_overflow */
1649          ppc64_elf_unhandled_reloc, /* special_function */
1650          "R_PPC64_TPREL16_HIGHESTA", /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0xffff,                /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   /* Like TPREL16, but for insns with a DS field.  */
1657   HOWTO (R_PPC64_TPREL16_DS,
1658          0,                     /* rightshift */
1659          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1660          16,                    /* bitsize */
1661          FALSE,                 /* pc_relative */
1662          0,                     /* bitpos */
1663          complain_overflow_signed, /* complain_on_overflow */
1664          ppc64_elf_unhandled_reloc, /* special_function */
1665          "R_PPC64_TPREL16_DS",  /* name */
1666          FALSE,                 /* partial_inplace */
1667          0,                     /* src_mask */
1668          0xfffc,                /* dst_mask */
1669          FALSE),                /* pcrel_offset */
1670
1671   /* Like TPREL16_DS, but no overflow.  */
1672   HOWTO (R_PPC64_TPREL16_LO_DS,
1673          0,                     /* rightshift */
1674          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1675          16,                    /* bitsize */
1676          FALSE,                 /* pc_relative */
1677          0,                     /* bitpos */
1678          complain_overflow_dont, /* complain_on_overflow */
1679          ppc64_elf_unhandled_reloc, /* special_function */
1680          "R_PPC64_TPREL16_LO_DS", /* name */
1681          FALSE,                 /* partial_inplace */
1682          0,                     /* src_mask */
1683          0xfffc,                /* dst_mask */
1684          FALSE),                /* pcrel_offset */
1685
1686   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1687      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1688      to the first entry relative to the TOC base (r2).  */
1689   HOWTO (R_PPC64_GOT_TLSGD16,
1690          0,                     /* rightshift */
1691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1692          16,                    /* bitsize */
1693          FALSE,                 /* pc_relative */
1694          0,                     /* bitpos */
1695          complain_overflow_signed, /* complain_on_overflow */
1696          ppc64_elf_unhandled_reloc, /* special_function */
1697          "R_PPC64_GOT_TLSGD16", /* name */
1698          FALSE,                 /* partial_inplace */
1699          0,                     /* src_mask */
1700          0xffff,                /* dst_mask */
1701          FALSE),                /* pcrel_offset */
1702
1703   /* Like GOT_TLSGD16, but no overflow.  */
1704   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1705          0,                     /* rightshift */
1706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1707          16,                    /* bitsize */
1708          FALSE,                 /* pc_relative */
1709          0,                     /* bitpos */
1710          complain_overflow_dont, /* complain_on_overflow */
1711          ppc64_elf_unhandled_reloc, /* special_function */
1712          "R_PPC64_GOT_TLSGD16_LO", /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xffff,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1719   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1720          16,                    /* rightshift */
1721          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1722          16,                    /* bitsize */
1723          FALSE,                 /* pc_relative */
1724          0,                     /* bitpos */
1725          complain_overflow_signed, /* complain_on_overflow */
1726          ppc64_elf_unhandled_reloc, /* special_function */
1727          "R_PPC64_GOT_TLSGD16_HI", /* name */
1728          FALSE,                 /* partial_inplace */
1729          0,                     /* src_mask */
1730          0xffff,                /* dst_mask */
1731          FALSE),                /* pcrel_offset */
1732
1733   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1734   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1735          16,                    /* rightshift */
1736          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1737          16,                    /* bitsize */
1738          FALSE,                 /* pc_relative */
1739          0,                     /* bitpos */
1740          complain_overflow_signed, /* complain_on_overflow */
1741          ppc64_elf_unhandled_reloc, /* special_function */
1742          "R_PPC64_GOT_TLSGD16_HA", /* name */
1743          FALSE,                 /* partial_inplace */
1744          0,                     /* src_mask */
1745          0xffff,                /* dst_mask */
1746          FALSE),                /* pcrel_offset */
1747
1748   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1749      with values (sym+add)@dtpmod and zero, and computes the offset to the
1750      first entry relative to the TOC base (r2).  */
1751   HOWTO (R_PPC64_GOT_TLSLD16,
1752          0,                     /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_signed, /* complain_on_overflow */
1758          ppc64_elf_unhandled_reloc, /* special_function */
1759          "R_PPC64_GOT_TLSLD16", /* name */
1760          FALSE,                 /* partial_inplace */
1761          0,                     /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Like GOT_TLSLD16, but no overflow.  */
1766   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1767          0,                     /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_dont, /* complain_on_overflow */
1773          ppc64_elf_unhandled_reloc, /* special_function */
1774          "R_PPC64_GOT_TLSLD16_LO", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1781   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1782          16,                    /* rightshift */
1783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1784          16,                    /* bitsize */
1785          FALSE,                 /* pc_relative */
1786          0,                     /* bitpos */
1787          complain_overflow_signed, /* complain_on_overflow */
1788          ppc64_elf_unhandled_reloc, /* special_function */
1789          "R_PPC64_GOT_TLSLD16_HI", /* name */
1790          FALSE,                 /* partial_inplace */
1791          0,                     /* src_mask */
1792          0xffff,                /* dst_mask */
1793          FALSE),                /* pcrel_offset */
1794
1795   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1796   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1797          16,                    /* rightshift */
1798          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1799          16,                    /* bitsize */
1800          FALSE,                 /* pc_relative */
1801          0,                     /* bitpos */
1802          complain_overflow_signed, /* complain_on_overflow */
1803          ppc64_elf_unhandled_reloc, /* special_function */
1804          "R_PPC64_GOT_TLSLD16_HA", /* name */
1805          FALSE,                 /* partial_inplace */
1806          0,                     /* src_mask */
1807          0xffff,                /* dst_mask */
1808          FALSE),                /* pcrel_offset */
1809
1810   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1811      the offset to the entry relative to the TOC base (r2).  */
1812   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1813          0,                     /* rightshift */
1814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1815          16,                    /* bitsize */
1816          FALSE,                 /* pc_relative */
1817          0,                     /* bitpos */
1818          complain_overflow_signed, /* complain_on_overflow */
1819          ppc64_elf_unhandled_reloc, /* special_function */
1820          "R_PPC64_GOT_DTPREL16_DS", /* name */
1821          FALSE,                 /* partial_inplace */
1822          0,                     /* src_mask */
1823          0xfffc,                /* dst_mask */
1824          FALSE),                /* pcrel_offset */
1825
1826   /* Like GOT_DTPREL16_DS, but no overflow.  */
1827   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1828          0,                     /* rightshift */
1829          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1830          16,                    /* bitsize */
1831          FALSE,                 /* pc_relative */
1832          0,                     /* bitpos */
1833          complain_overflow_dont, /* complain_on_overflow */
1834          ppc64_elf_unhandled_reloc, /* special_function */
1835          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1836          FALSE,                 /* partial_inplace */
1837          0,                     /* src_mask */
1838          0xfffc,                /* dst_mask */
1839          FALSE),                /* pcrel_offset */
1840
1841   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1842   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1843          16,                    /* rightshift */
1844          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1845          16,                    /* bitsize */
1846          FALSE,                 /* pc_relative */
1847          0,                     /* bitpos */
1848          complain_overflow_signed, /* complain_on_overflow */
1849          ppc64_elf_unhandled_reloc, /* special_function */
1850          "R_PPC64_GOT_DTPREL16_HI", /* name */
1851          FALSE,                 /* partial_inplace */
1852          0,                     /* src_mask */
1853          0xffff,                /* dst_mask */
1854          FALSE),                /* pcrel_offset */
1855
1856   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1857   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1858          16,                    /* rightshift */
1859          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1860          16,                    /* bitsize */
1861          FALSE,                 /* pc_relative */
1862          0,                     /* bitpos */
1863          complain_overflow_signed, /* complain_on_overflow */
1864          ppc64_elf_unhandled_reloc, /* special_function */
1865          "R_PPC64_GOT_DTPREL16_HA", /* name */
1866          FALSE,                 /* partial_inplace */
1867          0,                     /* src_mask */
1868          0xffff,                /* dst_mask */
1869          FALSE),                /* pcrel_offset */
1870
1871   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1872      offset to the entry relative to the TOC base (r2).  */
1873   HOWTO (R_PPC64_GOT_TPREL16_DS,
1874          0,                     /* rightshift */
1875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1876          16,                    /* bitsize */
1877          FALSE,                 /* pc_relative */
1878          0,                     /* bitpos */
1879          complain_overflow_signed, /* complain_on_overflow */
1880          ppc64_elf_unhandled_reloc, /* special_function */
1881          "R_PPC64_GOT_TPREL16_DS", /* name */
1882          FALSE,                 /* partial_inplace */
1883          0,                     /* src_mask */
1884          0xfffc,                /* dst_mask */
1885          FALSE),                /* pcrel_offset */
1886
1887   /* Like GOT_TPREL16_DS, but no overflow.  */
1888   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1889          0,                     /* rightshift */
1890          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1891          16,                    /* bitsize */
1892          FALSE,                 /* pc_relative */
1893          0,                     /* bitpos */
1894          complain_overflow_dont, /* complain_on_overflow */
1895          ppc64_elf_unhandled_reloc, /* special_function */
1896          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1897          FALSE,                 /* partial_inplace */
1898          0,                     /* src_mask */
1899          0xfffc,                /* dst_mask */
1900          FALSE),                /* pcrel_offset */
1901
1902   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1903   HOWTO (R_PPC64_GOT_TPREL16_HI,
1904          16,                    /* rightshift */
1905          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1906          16,                    /* bitsize */
1907          FALSE,                 /* pc_relative */
1908          0,                     /* bitpos */
1909          complain_overflow_signed, /* complain_on_overflow */
1910          ppc64_elf_unhandled_reloc, /* special_function */
1911          "R_PPC64_GOT_TPREL16_HI", /* name */
1912          FALSE,                 /* partial_inplace */
1913          0,                     /* src_mask */
1914          0xffff,                /* dst_mask */
1915          FALSE),                /* pcrel_offset */
1916
1917   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1918   HOWTO (R_PPC64_GOT_TPREL16_HA,
1919          16,                    /* rightshift */
1920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1921          16,                    /* bitsize */
1922          FALSE,                 /* pc_relative */
1923          0,                     /* bitpos */
1924          complain_overflow_signed, /* complain_on_overflow */
1925          ppc64_elf_unhandled_reloc, /* special_function */
1926          "R_PPC64_GOT_TPREL16_HA", /* name */
1927          FALSE,                 /* partial_inplace */
1928          0,                     /* src_mask */
1929          0xffff,                /* dst_mask */
1930          FALSE),                /* pcrel_offset */
1931
1932   HOWTO (R_PPC64_JMP_IREL,      /* type */
1933          0,                     /* rightshift */
1934          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1935          0,                     /* bitsize */
1936          FALSE,                 /* pc_relative */
1937          0,                     /* bitpos */
1938          complain_overflow_dont, /* complain_on_overflow */
1939          ppc64_elf_unhandled_reloc, /* special_function */
1940          "R_PPC64_JMP_IREL",    /* name */
1941          FALSE,                 /* partial_inplace */
1942          0,                     /* src_mask */
1943          0,                     /* dst_mask */
1944          FALSE),                /* pcrel_offset */
1945
1946   HOWTO (R_PPC64_IRELATIVE,     /* type */
1947          0,                     /* rightshift */
1948          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1949          64,                    /* bitsize */
1950          FALSE,                 /* pc_relative */
1951          0,                     /* bitpos */
1952          complain_overflow_dont, /* complain_on_overflow */
1953          bfd_elf_generic_reloc, /* special_function */
1954          "R_PPC64_IRELATIVE",   /* name */
1955          FALSE,                 /* partial_inplace */
1956          0,                     /* src_mask */
1957          ONES (64),             /* dst_mask */
1958          FALSE),                /* pcrel_offset */
1959
1960   /* A 16 bit relative relocation.  */
1961   HOWTO (R_PPC64_REL16,         /* type */
1962          0,                     /* rightshift */
1963          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1964          16,                    /* bitsize */
1965          TRUE,                  /* pc_relative */
1966          0,                     /* bitpos */
1967          complain_overflow_signed, /* complain_on_overflow */
1968          bfd_elf_generic_reloc, /* special_function */
1969          "R_PPC64_REL16",       /* name */
1970          FALSE,                 /* partial_inplace */
1971          0,                     /* src_mask */
1972          0xffff,                /* dst_mask */
1973          TRUE),                 /* pcrel_offset */
1974
1975   /* A 16 bit relative relocation without overflow.  */
1976   HOWTO (R_PPC64_REL16_LO,      /* type */
1977          0,                     /* rightshift */
1978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1979          16,                    /* bitsize */
1980          TRUE,                  /* pc_relative */
1981          0,                     /* bitpos */
1982          complain_overflow_dont,/* complain_on_overflow */
1983          bfd_elf_generic_reloc, /* special_function */
1984          "R_PPC64_REL16_LO",    /* name */
1985          FALSE,                 /* partial_inplace */
1986          0,                     /* src_mask */
1987          0xffff,                /* dst_mask */
1988          TRUE),                 /* pcrel_offset */
1989
1990   /* The high order 16 bits of a relative address.  */
1991   HOWTO (R_PPC64_REL16_HI,      /* type */
1992          16,                    /* rightshift */
1993          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1994          16,                    /* bitsize */
1995          TRUE,                  /* pc_relative */
1996          0,                     /* bitpos */
1997          complain_overflow_signed, /* complain_on_overflow */
1998          bfd_elf_generic_reloc, /* special_function */
1999          "R_PPC64_REL16_HI",    /* name */
2000          FALSE,                 /* partial_inplace */
2001          0,                     /* src_mask */
2002          0xffff,                /* dst_mask */
2003          TRUE),                 /* pcrel_offset */
2004
2005   /* The high order 16 bits of a relative address, plus 1 if the contents of
2006      the low 16 bits, treated as a signed number, is negative.  */
2007   HOWTO (R_PPC64_REL16_HA,      /* type */
2008          16,                    /* rightshift */
2009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          16,                    /* bitsize */
2011          TRUE,                  /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_signed, /* complain_on_overflow */
2014          ppc64_elf_ha_reloc,    /* special_function */
2015          "R_PPC64_REL16_HA",    /* name */
2016          FALSE,                 /* partial_inplace */
2017          0,                     /* src_mask */
2018          0xffff,                /* dst_mask */
2019          TRUE),                 /* pcrel_offset */
2020
2021   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2022   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2023          16,                    /* rightshift */
2024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2025          16,                    /* bitsize */
2026          FALSE,                 /* pc_relative */
2027          0,                     /* bitpos */
2028          complain_overflow_dont, /* complain_on_overflow */
2029          bfd_elf_generic_reloc, /* special_function */
2030          "R_PPC64_ADDR16_HIGH", /* name */
2031          FALSE,                 /* partial_inplace */
2032          0,                     /* src_mask */
2033          0xffff,                /* dst_mask */
2034          FALSE),                /* pcrel_offset */
2035
2036   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2037   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2038          16,                    /* rightshift */
2039          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2040          16,                    /* bitsize */
2041          FALSE,                 /* pc_relative */
2042          0,                     /* bitpos */
2043          complain_overflow_dont, /* complain_on_overflow */
2044          ppc64_elf_ha_reloc,    /* special_function */
2045          "R_PPC64_ADDR16_HIGHA",        /* name */
2046          FALSE,                 /* partial_inplace */
2047          0,                     /* src_mask */
2048          0xffff,                /* dst_mask */
2049          FALSE),                /* pcrel_offset */
2050
2051   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2052   HOWTO (R_PPC64_DTPREL16_HIGH,
2053          16,                    /* rightshift */
2054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2055          16,                    /* bitsize */
2056          FALSE,                 /* pc_relative */
2057          0,                     /* bitpos */
2058          complain_overflow_dont, /* complain_on_overflow */
2059          ppc64_elf_unhandled_reloc, /* special_function */
2060          "R_PPC64_DTPREL16_HIGH", /* name */
2061          FALSE,                 /* partial_inplace */
2062          0,                     /* src_mask */
2063          0xffff,                /* dst_mask */
2064          FALSE),                /* pcrel_offset */
2065
2066   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2067   HOWTO (R_PPC64_DTPREL16_HIGHA,
2068          16,                    /* rightshift */
2069          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2070          16,                    /* bitsize */
2071          FALSE,                 /* pc_relative */
2072          0,                     /* bitpos */
2073          complain_overflow_dont, /* complain_on_overflow */
2074          ppc64_elf_unhandled_reloc, /* special_function */
2075          "R_PPC64_DTPREL16_HIGHA", /* name */
2076          FALSE,                 /* partial_inplace */
2077          0,                     /* src_mask */
2078          0xffff,                /* dst_mask */
2079          FALSE),                /* pcrel_offset */
2080
2081   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2082   HOWTO (R_PPC64_TPREL16_HIGH,
2083          16,                    /* rightshift */
2084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2085          16,                    /* bitsize */
2086          FALSE,                 /* pc_relative */
2087          0,                     /* bitpos */
2088          complain_overflow_dont, /* complain_on_overflow */
2089          ppc64_elf_unhandled_reloc, /* special_function */
2090          "R_PPC64_TPREL16_HIGH",        /* name */
2091          FALSE,                 /* partial_inplace */
2092          0,                     /* src_mask */
2093          0xffff,                /* dst_mask */
2094          FALSE),                /* pcrel_offset */
2095
2096   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2097   HOWTO (R_PPC64_TPREL16_HIGHA,
2098          16,                    /* rightshift */
2099          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2100          16,                    /* bitsize */
2101          FALSE,                 /* pc_relative */
2102          0,                     /* bitpos */
2103          complain_overflow_dont, /* complain_on_overflow */
2104          ppc64_elf_unhandled_reloc, /* special_function */
2105          "R_PPC64_TPREL16_HIGHA",       /* name */
2106          FALSE,                 /* partial_inplace */
2107          0,                     /* src_mask */
2108          0xffff,                /* dst_mask */
2109          FALSE),                /* pcrel_offset */
2110
2111   /* Like ADDR64, but use local entry point of function.  */
2112   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2113          0,                     /* rightshift */
2114          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2115          64,                    /* bitsize */
2116          FALSE,                 /* pc_relative */
2117          0,                     /* bitpos */
2118          complain_overflow_dont, /* complain_on_overflow */
2119          bfd_elf_generic_reloc, /* special_function */
2120          "R_PPC64_ADDR64_LOCAL", /* name */
2121          FALSE,                 /* partial_inplace */
2122          0,                     /* src_mask */
2123          ONES (64),             /* dst_mask */
2124          FALSE),                /* pcrel_offset */
2125
2126   /* GNU extension to record C++ vtable hierarchy.  */
2127   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2128          0,                     /* rightshift */
2129          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2130          0,                     /* bitsize */
2131          FALSE,                 /* pc_relative */
2132          0,                     /* bitpos */
2133          complain_overflow_dont, /* complain_on_overflow */
2134          NULL,                  /* special_function */
2135          "R_PPC64_GNU_VTINHERIT", /* name */
2136          FALSE,                 /* partial_inplace */
2137          0,                     /* src_mask */
2138          0,                     /* dst_mask */
2139          FALSE),                /* pcrel_offset */
2140
2141   /* GNU extension to record C++ vtable member usage.  */
2142   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2143          0,                     /* rightshift */
2144          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2145          0,                     /* bitsize */
2146          FALSE,                 /* pc_relative */
2147          0,                     /* bitpos */
2148          complain_overflow_dont, /* complain_on_overflow */
2149          NULL,                  /* special_function */
2150          "R_PPC64_GNU_VTENTRY", /* name */
2151          FALSE,                 /* partial_inplace */
2152          0,                     /* src_mask */
2153          0,                     /* dst_mask */
2154          FALSE),                /* pcrel_offset */
2155 };
2156
2157 \f
2158 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2159    be done.  */
2160
2161 static void
2162 ppc_howto_init (void)
2163 {
2164   unsigned int i, type;
2165
2166   for (i = 0;
2167        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2168        i++)
2169     {
2170       type = ppc64_elf_howto_raw[i].type;
2171       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2172                           / sizeof (ppc64_elf_howto_table[0])));
2173       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2174     }
2175 }
2176
2177 static reloc_howto_type *
2178 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2179                              bfd_reloc_code_real_type code)
2180 {
2181   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2182
2183   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2184     /* Initialize howto table if needed.  */
2185     ppc_howto_init ();
2186
2187   switch (code)
2188     {
2189     default:
2190       return NULL;
2191
2192     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2193       break;
2194     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2195       break;
2196     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2197       break;
2198     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2199       break;
2200     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2201       break;
2202     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2203       break;
2204     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2205       break;
2206     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2207       break;
2208     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2209       break;
2210     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2211       break;
2212     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2213       break;
2214     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2215       break;
2216     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2217       break;
2218     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2219       break;
2220     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2221       break;
2222     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2223       break;
2224     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2225       break;
2226     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2227       break;
2228     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2229       break;
2230     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2231       break;
2232     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2233       break;
2234     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2235       break;
2236     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2237       break;
2238     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2239       break;
2240     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2241       break;
2242     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2243       break;
2244     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2245       break;
2246     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2247       break;
2248     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2249       break;
2250     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2251       break;
2252     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2253       break;
2254     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2255       break;
2256     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2257       break;
2258     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2259       break;
2260     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2261       break;
2262     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2263       break;
2264     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2265       break;
2266     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2267       break;
2268     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2269       break;
2270     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2271       break;
2272     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2273       break;
2274     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2275       break;
2276     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2279       break;
2280     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2281       break;
2282     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2285       break;
2286     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2287       break;
2288     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2289       break;
2290     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2291       break;
2292     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2293       break;
2294     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2295       break;
2296     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2297       break;
2298     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2299       break;
2300     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2301       break;
2302     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2303       break;
2304     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2305       break;
2306     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2307       break;
2308     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2309       break;
2310     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2311       break;
2312     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2313       break;
2314     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2315       break;
2316     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2317       break;
2318     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2319       break;
2320     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2321       break;
2322     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2323       break;
2324     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2325       break;
2326     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2327       break;
2328     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2329       break;
2330     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2331       break;
2332     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2333       break;
2334     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2335       break;
2336     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2337       break;
2338     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2339       break;
2340     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2341       break;
2342     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2343       break;
2344     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2345       break;
2346     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2347       break;
2348     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2349       break;
2350     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2351       break;
2352     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2353       break;
2354     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2355       break;
2356     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2357       break;
2358     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2359       break;
2360     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2361       break;
2362     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2363       break;
2364     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2365       break;
2366     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2367       break;
2368     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2369       break;
2370     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2371       break;
2372     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2373       break;
2374     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2375       break;
2376     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2377       break;
2378     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2379       break;
2380     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2381       break;
2382     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2383       break;
2384     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2385       break;
2386     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2387       break;
2388     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2389       break;
2390     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2391       break;
2392     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2393       break;
2394     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2395       break;
2396     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2397       break;
2398     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2399       break;
2400     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2401       break;
2402     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2403       break;
2404     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2405       break;
2406     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2407       break;
2408     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2409       break;
2410     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2411       break;
2412     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2413       break;
2414     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2415       break;
2416     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2417       break;
2418     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2419       break;
2420     }
2421
2422   return ppc64_elf_howto_table[r];
2423 };
2424
2425 static reloc_howto_type *
2426 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2427                              const char *r_name)
2428 {
2429   unsigned int i;
2430
2431   for (i = 0;
2432        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2433        i++)
2434     if (ppc64_elf_howto_raw[i].name != NULL
2435         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2436       return &ppc64_elf_howto_raw[i];
2437
2438   return NULL;
2439 }
2440
2441 /* Set the howto pointer for a PowerPC ELF reloc.  */
2442
2443 static void
2444 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2445                          Elf_Internal_Rela *dst)
2446 {
2447   unsigned int type;
2448
2449   /* Initialize howto table if needed.  */
2450   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2451     ppc_howto_init ();
2452
2453   type = ELF64_R_TYPE (dst->r_info);
2454   if (type >= (sizeof (ppc64_elf_howto_table)
2455                / sizeof (ppc64_elf_howto_table[0])))
2456     {
2457       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2458                              abfd, (int) type);
2459       type = R_PPC64_NONE;
2460     }
2461   cache_ptr->howto = ppc64_elf_howto_table[type];
2462 }
2463
2464 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2465
2466 static bfd_reloc_status_type
2467 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2468                     void *data, asection *input_section,
2469                     bfd *output_bfd, char **error_message)
2470 {
2471   /* If this is a relocatable link (output_bfd test tells us), just
2472      call the generic function.  Any adjustment will be done at final
2473      link time.  */
2474   if (output_bfd != NULL)
2475     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2476                                   input_section, output_bfd, error_message);
2477
2478   /* Adjust the addend for sign extension of the low 16 bits.
2479      We won't actually be using the low 16 bits, so trashing them
2480      doesn't matter.  */
2481   reloc_entry->addend += 0x8000;
2482   return bfd_reloc_continue;
2483 }
2484
2485 static bfd_reloc_status_type
2486 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2487                         void *data, asection *input_section,
2488                         bfd *output_bfd, char **error_message)
2489 {
2490   if (output_bfd != NULL)
2491     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2492                                   input_section, output_bfd, error_message);
2493
2494   if (strcmp (symbol->section->name, ".opd") == 0
2495       && (symbol->section->owner->flags & DYNAMIC) == 0)
2496     {
2497       bfd_vma dest = opd_entry_value (symbol->section,
2498                                       symbol->value + reloc_entry->addend,
2499                                       NULL, NULL, FALSE);
2500       if (dest != (bfd_vma) -1)
2501         reloc_entry->addend = dest - (symbol->value
2502                                       + symbol->section->output_section->vma
2503                                       + symbol->section->output_offset);
2504     }
2505   else
2506     {
2507       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2508
2509       if (symbol->section->owner != abfd
2510           && abiversion (symbol->section->owner) >= 2)
2511         {
2512           unsigned int i;
2513
2514           for (i = 0; i < symbol->section->owner->symcount; ++i)
2515             {
2516               asymbol *symdef = symbol->section->owner->outsymbols[i];
2517
2518               if (strcmp (symdef->name, symbol->name) == 0)
2519                 {
2520                   elfsym = (elf_symbol_type *) symdef;
2521                   break;
2522                 }
2523             }
2524         }
2525       reloc_entry->addend
2526         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2527     }
2528   return bfd_reloc_continue;
2529 }
2530
2531 static bfd_reloc_status_type
2532 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2533                          void *data, asection *input_section,
2534                          bfd *output_bfd, char **error_message)
2535 {
2536   long insn;
2537   enum elf_ppc64_reloc_type r_type;
2538   bfd_size_type octets;
2539   /* Assume 'at' branch hints.  */
2540   bfd_boolean is_isa_v2 = TRUE;
2541
2542   /* If this is a relocatable link (output_bfd test tells us), just
2543      call the generic function.  Any adjustment will be done at final
2544      link time.  */
2545   if (output_bfd != NULL)
2546     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2547                                   input_section, output_bfd, error_message);
2548
2549   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2550   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2551   insn &= ~(0x01 << 21);
2552   r_type = reloc_entry->howto->type;
2553   if (r_type == R_PPC64_ADDR14_BRTAKEN
2554       || r_type == R_PPC64_REL14_BRTAKEN)
2555     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2556
2557   if (is_isa_v2)
2558     {
2559       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2560          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2561          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2562       if ((insn & (0x14 << 21)) == (0x04 << 21))
2563         insn |= 0x02 << 21;
2564       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2565         insn |= 0x08 << 21;
2566       else
2567         goto out;
2568     }
2569   else
2570     {
2571       bfd_vma target = 0;
2572       bfd_vma from;
2573
2574       if (!bfd_is_com_section (symbol->section))
2575         target = symbol->value;
2576       target += symbol->section->output_section->vma;
2577       target += symbol->section->output_offset;
2578       target += reloc_entry->addend;
2579
2580       from = (reloc_entry->address
2581               + input_section->output_offset
2582               + input_section->output_section->vma);
2583
2584       /* Invert 'y' bit if not the default.  */
2585       if ((bfd_signed_vma) (target - from) < 0)
2586         insn ^= 0x01 << 21;
2587     }
2588   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2589  out:
2590   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2591                                  input_section, output_bfd, error_message);
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596                          void *data, asection *input_section,
2597                          bfd *output_bfd, char **error_message)
2598 {
2599   /* If this is a relocatable link (output_bfd test tells us), just
2600      call the generic function.  Any adjustment will be done at final
2601      link time.  */
2602   if (output_bfd != NULL)
2603     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2604                                   input_section, output_bfd, error_message);
2605
2606   /* Subtract the symbol section base address.  */
2607   reloc_entry->addend -= symbol->section->output_section->vma;
2608   return bfd_reloc_continue;
2609 }
2610
2611 static bfd_reloc_status_type
2612 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2613                             void *data, asection *input_section,
2614                             bfd *output_bfd, char **error_message)
2615 {
2616   /* If this is a relocatable link (output_bfd test tells us), just
2617      call the generic function.  Any adjustment will be done at final
2618      link time.  */
2619   if (output_bfd != NULL)
2620     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2621                                   input_section, output_bfd, error_message);
2622
2623   /* Subtract the symbol section base address.  */
2624   reloc_entry->addend -= symbol->section->output_section->vma;
2625
2626   /* Adjust the addend for sign extension of the low 16 bits.  */
2627   reloc_entry->addend += 0x8000;
2628   return bfd_reloc_continue;
2629 }
2630
2631 static bfd_reloc_status_type
2632 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2633                      void *data, asection *input_section,
2634                      bfd *output_bfd, char **error_message)
2635 {
2636   bfd_vma TOCstart;
2637
2638   /* If this is a relocatable link (output_bfd test tells us), just
2639      call the generic function.  Any adjustment will be done at final
2640      link time.  */
2641   if (output_bfd != NULL)
2642     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2643                                   input_section, output_bfd, error_message);
2644
2645   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2646   if (TOCstart == 0)
2647     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2648
2649   /* Subtract the TOC base address.  */
2650   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2651   return bfd_reloc_continue;
2652 }
2653
2654 static bfd_reloc_status_type
2655 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2656                         void *data, asection *input_section,
2657                         bfd *output_bfd, char **error_message)
2658 {
2659   bfd_vma TOCstart;
2660
2661   /* If this is a relocatable link (output_bfd test tells us), just
2662      call the generic function.  Any adjustment will be done at final
2663      link time.  */
2664   if (output_bfd != NULL)
2665     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2666                                   input_section, output_bfd, error_message);
2667
2668   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2669   if (TOCstart == 0)
2670     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2671
2672   /* Subtract the TOC base address.  */
2673   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2674
2675   /* Adjust the addend for sign extension of the low 16 bits.  */
2676   reloc_entry->addend += 0x8000;
2677   return bfd_reloc_continue;
2678 }
2679
2680 static bfd_reloc_status_type
2681 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2682                        void *data, asection *input_section,
2683                        bfd *output_bfd, char **error_message)
2684 {
2685   bfd_vma TOCstart;
2686   bfd_size_type octets;
2687
2688   /* If this is a relocatable link (output_bfd test tells us), just
2689      call the generic function.  Any adjustment will be done at final
2690      link time.  */
2691   if (output_bfd != NULL)
2692     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2693                                   input_section, output_bfd, error_message);
2694
2695   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2696   if (TOCstart == 0)
2697     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2698
2699   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2700   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2701   return bfd_reloc_ok;
2702 }
2703
2704 static bfd_reloc_status_type
2705 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2706                            void *data, asection *input_section,
2707                            bfd *output_bfd, char **error_message)
2708 {
2709   /* If this is a relocatable link (output_bfd test tells us), just
2710      call the generic function.  Any adjustment will be done at final
2711      link time.  */
2712   if (output_bfd != NULL)
2713     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2714                                   input_section, output_bfd, error_message);
2715
2716   if (error_message != NULL)
2717     {
2718       static char buf[60];
2719       sprintf (buf, "generic linker can't handle %s",
2720                reloc_entry->howto->name);
2721       *error_message = buf;
2722     }
2723   return bfd_reloc_dangerous;
2724 }
2725
2726 /* Track GOT entries needed for a given symbol.  We might need more
2727    than one got entry per symbol.  */
2728 struct got_entry
2729 {
2730   struct got_entry *next;
2731
2732   /* The symbol addend that we'll be placing in the GOT.  */
2733   bfd_vma addend;
2734
2735   /* Unlike other ELF targets, we use separate GOT entries for the same
2736      symbol referenced from different input files.  This is to support
2737      automatic multiple TOC/GOT sections, where the TOC base can vary
2738      from one input file to another.  After partitioning into TOC groups
2739      we merge entries within the group.
2740
2741      Point to the BFD owning this GOT entry.  */
2742   bfd *owner;
2743
2744   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2745      TLS_TPREL or TLS_DTPREL for tls entries.  */
2746   unsigned char tls_type;
2747
2748   /* Non-zero if got.ent points to real entry.  */
2749   unsigned char is_indirect;
2750
2751   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2752   union
2753     {
2754       bfd_signed_vma refcount;
2755       bfd_vma offset;
2756       struct got_entry *ent;
2757     } got;
2758 };
2759
2760 /* The same for PLT.  */
2761 struct plt_entry
2762 {
2763   struct plt_entry *next;
2764
2765   bfd_vma addend;
2766
2767   union
2768     {
2769       bfd_signed_vma refcount;
2770       bfd_vma offset;
2771     } plt;
2772 };
2773
2774 struct ppc64_elf_obj_tdata
2775 {
2776   struct elf_obj_tdata elf;
2777
2778   /* Shortcuts to dynamic linker sections.  */
2779   asection *got;
2780   asection *relgot;
2781
2782   /* Used during garbage collection.  We attach global symbols defined
2783      on removed .opd entries to this section so that the sym is removed.  */
2784   asection *deleted_section;
2785
2786   /* TLS local dynamic got entry handling.  Support for multiple GOT
2787      sections means we potentially need one of these for each input bfd.  */
2788   struct got_entry tlsld_got;
2789
2790   union {
2791     /* A copy of relocs before they are modified for --emit-relocs.  */
2792     Elf_Internal_Rela *relocs;
2793
2794     /* Section contents.  */
2795     bfd_byte *contents;
2796   } opd;
2797
2798   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2799      the reloc to be in the range -32768 to 32767.  */
2800   unsigned int has_small_toc_reloc : 1;
2801
2802   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2803      instruction not one we handle.  */
2804   unsigned int unexpected_toc_insn : 1;
2805 };
2806
2807 #define ppc64_elf_tdata(bfd) \
2808   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2809
2810 #define ppc64_tlsld_got(bfd) \
2811   (&ppc64_elf_tdata (bfd)->tlsld_got)
2812
2813 #define is_ppc64_elf(bfd) \
2814   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2815    && elf_object_id (bfd) == PPC64_ELF_DATA)
2816
2817 /* Override the generic function because we store some extras.  */
2818
2819 static bfd_boolean
2820 ppc64_elf_mkobject (bfd *abfd)
2821 {
2822   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2823                                   PPC64_ELF_DATA);
2824 }
2825
2826 /* Fix bad default arch selected for a 64 bit input bfd when the
2827    default is 32 bit.  */
2828
2829 static bfd_boolean
2830 ppc64_elf_object_p (bfd *abfd)
2831 {
2832   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2833     {
2834       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2835
2836       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2837         {
2838           /* Relies on arch after 32 bit default being 64 bit default.  */
2839           abfd->arch_info = abfd->arch_info->next;
2840           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2841         }
2842     }
2843   return TRUE;
2844 }
2845
2846 /* Support for core dump NOTE sections.  */
2847
2848 static bfd_boolean
2849 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2850 {
2851   size_t offset, size;
2852
2853   if (note->descsz != 504)
2854     return FALSE;
2855
2856   /* pr_cursig */
2857   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2858
2859   /* pr_pid */
2860   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2861
2862   /* pr_reg */
2863   offset = 112;
2864   size = 384;
2865
2866   /* Make a ".reg/999" section.  */
2867   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2868                                           size, note->descpos + offset);
2869 }
2870
2871 static bfd_boolean
2872 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2873 {
2874   if (note->descsz != 136)
2875     return FALSE;
2876
2877   elf_tdata (abfd)->core->pid
2878     = bfd_get_32 (abfd, note->descdata + 24);
2879   elf_tdata (abfd)->core->program
2880     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2881   elf_tdata (abfd)->core->command
2882     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2883
2884   return TRUE;
2885 }
2886
2887 static char *
2888 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2889                            ...)
2890 {
2891   switch (note_type)
2892     {
2893     default:
2894       return NULL;
2895
2896     case NT_PRPSINFO:
2897       {
2898         char data[136];
2899         va_list ap;
2900
2901         va_start (ap, note_type);
2902         memset (data, 0, sizeof (data));
2903         strncpy (data + 40, va_arg (ap, const char *), 16);
2904         strncpy (data + 56, va_arg (ap, const char *), 80);
2905         va_end (ap);
2906         return elfcore_write_note (abfd, buf, bufsiz,
2907                                    "CORE", note_type, data, sizeof (data));
2908       }
2909
2910     case NT_PRSTATUS:
2911       {
2912         char data[504];
2913         va_list ap;
2914         long pid;
2915         int cursig;
2916         const void *greg;
2917
2918         va_start (ap, note_type);
2919         memset (data, 0, 112);
2920         pid = va_arg (ap, long);
2921         bfd_put_32 (abfd, pid, data + 32);
2922         cursig = va_arg (ap, int);
2923         bfd_put_16 (abfd, cursig, data + 12);
2924         greg = va_arg (ap, const void *);
2925         memcpy (data + 112, greg, 384);
2926         memset (data + 496, 0, 8);
2927         va_end (ap);
2928         return elfcore_write_note (abfd, buf, bufsiz,
2929                                    "CORE", note_type, data, sizeof (data));
2930       }
2931     }
2932 }
2933
2934 /* Add extra PPC sections.  */
2935
2936 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2937 {
2938   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2939   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2940   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2941   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2942   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2943   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2944   { NULL,                     0,  0, 0,            0 }
2945 };
2946
2947 enum _ppc64_sec_type {
2948   sec_normal = 0,
2949   sec_opd = 1,
2950   sec_toc = 2
2951 };
2952
2953 struct _ppc64_elf_section_data
2954 {
2955   struct bfd_elf_section_data elf;
2956
2957   union
2958   {
2959     /* An array with one entry for each opd function descriptor,
2960        and some spares since opd entries may be either 16 or 24 bytes.  */
2961 #define OPD_NDX(OFF) ((OFF) >> 4)
2962     struct _opd_sec_data
2963     {
2964       /* Points to the function code section for local opd entries.  */
2965       asection **func_sec;
2966
2967       /* After editing .opd, adjust references to opd local syms.  */
2968       long *adjust;
2969     } opd;
2970
2971     /* An array for toc sections, indexed by offset/8.  */
2972     struct _toc_sec_data
2973     {
2974       /* Specifies the relocation symbol index used at a given toc offset.  */
2975       unsigned *symndx;
2976
2977       /* And the relocation addend.  */
2978       bfd_vma *add;
2979     } toc;
2980   } u;
2981
2982   enum _ppc64_sec_type sec_type:2;
2983
2984   /* Flag set when small branches are detected.  Used to
2985      select suitable defaults for the stub group size.  */
2986   unsigned int has_14bit_branch:1;
2987 };
2988
2989 #define ppc64_elf_section_data(sec) \
2990   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2991
2992 static bfd_boolean
2993 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2994 {
2995   if (!sec->used_by_bfd)
2996     {
2997       struct _ppc64_elf_section_data *sdata;
2998       bfd_size_type amt = sizeof (*sdata);
2999
3000       sdata = bfd_zalloc (abfd, amt);
3001       if (sdata == NULL)
3002         return FALSE;
3003       sec->used_by_bfd = sdata;
3004     }
3005
3006   return _bfd_elf_new_section_hook (abfd, sec);
3007 }
3008
3009 static struct _opd_sec_data *
3010 get_opd_info (asection * sec)
3011 {
3012   if (sec != NULL
3013       && ppc64_elf_section_data (sec) != NULL
3014       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3015     return &ppc64_elf_section_data (sec)->u.opd;
3016   return NULL;
3017 }
3018 \f
3019 /* Parameters for the qsort hook.  */
3020 static bfd_boolean synthetic_relocatable;
3021
3022 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3023
3024 static int
3025 compare_symbols (const void *ap, const void *bp)
3026 {
3027   const asymbol *a = * (const asymbol **) ap;
3028   const asymbol *b = * (const asymbol **) bp;
3029
3030   /* Section symbols first.  */
3031   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3032     return -1;
3033   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3034     return 1;
3035
3036   /* then .opd symbols.  */
3037   if (strcmp (a->section->name, ".opd") == 0
3038       && strcmp (b->section->name, ".opd") != 0)
3039     return -1;
3040   if (strcmp (a->section->name, ".opd") != 0
3041       && strcmp (b->section->name, ".opd") == 0)
3042     return 1;
3043
3044   /* then other code symbols.  */
3045   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3046       == (SEC_CODE | SEC_ALLOC)
3047       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3048          != (SEC_CODE | SEC_ALLOC))
3049     return -1;
3050
3051   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3052       != (SEC_CODE | SEC_ALLOC)
3053       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3054          == (SEC_CODE | SEC_ALLOC))
3055     return 1;
3056
3057   if (synthetic_relocatable)
3058     {
3059       if (a->section->id < b->section->id)
3060         return -1;
3061
3062       if (a->section->id > b->section->id)
3063         return 1;
3064     }
3065
3066   if (a->value + a->section->vma < b->value + b->section->vma)
3067     return -1;
3068
3069   if (a->value + a->section->vma > b->value + b->section->vma)
3070     return 1;
3071
3072   /* For syms with the same value, prefer strong dynamic global function
3073      syms over other syms.  */
3074   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3075     return -1;
3076
3077   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3078     return 1;
3079
3080   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3081     return -1;
3082
3083   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3084     return 1;
3085
3086   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3087     return -1;
3088
3089   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3090     return 1;
3091
3092   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3093     return -1;
3094
3095   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3096     return 1;
3097
3098   return 0;
3099 }
3100
3101 /* Search SYMS for a symbol of the given VALUE.  */
3102
3103 static asymbol *
3104 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3105 {
3106   long mid;
3107
3108   if (id == -1)
3109     {
3110       while (lo < hi)
3111         {
3112           mid = (lo + hi) >> 1;
3113           if (syms[mid]->value + syms[mid]->section->vma < value)
3114             lo = mid + 1;
3115           else if (syms[mid]->value + syms[mid]->section->vma > value)
3116             hi = mid;
3117           else
3118             return syms[mid];
3119         }
3120     }
3121   else
3122     {
3123       while (lo < hi)
3124         {
3125           mid = (lo + hi) >> 1;
3126           if (syms[mid]->section->id < id)
3127             lo = mid + 1;
3128           else if (syms[mid]->section->id > id)
3129             hi = mid;
3130           else if (syms[mid]->value < value)
3131             lo = mid + 1;
3132           else if (syms[mid]->value > value)
3133             hi = mid;
3134           else
3135             return syms[mid];
3136         }
3137     }
3138   return NULL;
3139 }
3140
3141 static bfd_boolean
3142 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3143 {
3144   bfd_vma vma = *(bfd_vma *) ptr;
3145   return ((section->flags & SEC_ALLOC) != 0
3146           && section->vma <= vma
3147           && vma < section->vma + section->size);
3148 }
3149
3150 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3151    entry syms.  Also generate @plt symbols for the glink branch table.
3152    Returns count of synthetic symbols in RET or -1 on error.  */
3153
3154 static long
3155 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3156                                 long static_count, asymbol **static_syms,
3157                                 long dyn_count, asymbol **dyn_syms,
3158                                 asymbol **ret)
3159 {
3160   asymbol *s;
3161   long i;
3162   long count;
3163   char *names;
3164   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3165   asection *opd = NULL;
3166   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3167   asymbol **syms;
3168   int abi = abiversion (abfd);
3169
3170   *ret = NULL;
3171
3172   if (abi < 2)
3173     {
3174       opd = bfd_get_section_by_name (abfd, ".opd");
3175       if (opd == NULL && abi == 1)
3176         return 0;
3177     }
3178
3179   symcount = static_count;
3180   if (!relocatable)
3181     symcount += dyn_count;
3182   if (symcount == 0)
3183     return 0;
3184
3185   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3186   if (syms == NULL)
3187     return -1;
3188
3189   if (!relocatable && static_count != 0 && dyn_count != 0)
3190     {
3191       /* Use both symbol tables.  */
3192       memcpy (syms, static_syms, static_count * sizeof (*syms));
3193       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3194     }
3195   else if (!relocatable && static_count == 0)
3196     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3197   else
3198     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3199
3200   synthetic_relocatable = relocatable;
3201   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3202
3203   if (!relocatable && symcount > 1)
3204     {
3205       long j;
3206       /* Trim duplicate syms, since we may have merged the normal and
3207          dynamic symbols.  Actually, we only care about syms that have
3208          different values, so trim any with the same value.  */
3209       for (i = 1, j = 1; i < symcount; ++i)
3210         if (syms[i - 1]->value + syms[i - 1]->section->vma
3211             != syms[i]->value + syms[i]->section->vma)
3212           syms[j++] = syms[i];
3213       symcount = j;
3214     }
3215
3216   i = 0;
3217   if (strcmp (syms[i]->section->name, ".opd") == 0)
3218     ++i;
3219   codesecsym = i;
3220
3221   for (; i < symcount; ++i)
3222     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3223          != (SEC_CODE | SEC_ALLOC))
3224         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3225       break;
3226   codesecsymend = i;
3227
3228   for (; i < symcount; ++i)
3229     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3230       break;
3231   secsymend = i;
3232
3233   for (; i < symcount; ++i)
3234     if (strcmp (syms[i]->section->name, ".opd") != 0)
3235       break;
3236   opdsymend = i;
3237
3238   for (; i < symcount; ++i)
3239     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3240         != (SEC_CODE | SEC_ALLOC))
3241       break;
3242   symcount = i;
3243
3244   count = 0;
3245
3246   if (relocatable)
3247     {
3248       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3249       arelent *r;
3250       size_t size;
3251       long relcount;
3252
3253       if (opdsymend == secsymend)
3254         goto done;
3255
3256       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3257       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3258       if (relcount == 0)
3259         goto done;
3260
3261       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3262         {
3263           count = -1;
3264           goto done;
3265         }
3266
3267       size = 0;
3268       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3269         {
3270           asymbol *sym;
3271
3272           while (r < opd->relocation + relcount
3273                  && r->address < syms[i]->value + opd->vma)
3274             ++r;
3275
3276           if (r == opd->relocation + relcount)
3277             break;
3278
3279           if (r->address != syms[i]->value + opd->vma)
3280             continue;
3281
3282           if (r->howto->type != R_PPC64_ADDR64)
3283             continue;
3284
3285           sym = *r->sym_ptr_ptr;
3286           if (!sym_exists_at (syms, opdsymend, symcount,
3287                               sym->section->id, sym->value + r->addend))
3288             {
3289               ++count;
3290               size += sizeof (asymbol);
3291               size += strlen (syms[i]->name) + 2;
3292             }
3293         }
3294
3295       if (size == 0)
3296         goto done;
3297       s = *ret = bfd_malloc (size);
3298       if (s == NULL)
3299         {
3300           count = -1;
3301           goto done;
3302         }
3303
3304       names = (char *) (s + count);
3305
3306       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3307         {
3308           asymbol *sym;
3309
3310           while (r < opd->relocation + relcount
3311                  && r->address < syms[i]->value + opd->vma)
3312             ++r;
3313
3314           if (r == opd->relocation + relcount)
3315             break;
3316
3317           if (r->address != syms[i]->value + opd->vma)
3318             continue;
3319
3320           if (r->howto->type != R_PPC64_ADDR64)
3321             continue;
3322
3323           sym = *r->sym_ptr_ptr;
3324           if (!sym_exists_at (syms, opdsymend, symcount,
3325                               sym->section->id, sym->value + r->addend))
3326             {
3327               size_t len;
3328
3329               *s = *syms[i];
3330               s->flags |= BSF_SYNTHETIC;
3331               s->section = sym->section;
3332               s->value = sym->value + r->addend;
3333               s->name = names;
3334               *names++ = '.';
3335               len = strlen (syms[i]->name);
3336               memcpy (names, syms[i]->name, len + 1);
3337               names += len + 1;
3338               /* Have udata.p point back to the original symbol this
3339                  synthetic symbol was derived from.  */
3340               s->udata.p = syms[i];
3341               s++;
3342             }
3343         }
3344     }
3345   else
3346     {
3347       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3348       bfd_byte *contents = NULL;
3349       size_t size;
3350       long plt_count = 0;
3351       bfd_vma glink_vma = 0, resolv_vma = 0;
3352       asection *dynamic, *glink = NULL, *relplt = NULL;
3353       arelent *p;
3354
3355       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3356         {
3357         free_contents_and_exit_err:
3358           count = -1;
3359         free_contents_and_exit:
3360           if (contents)
3361             free (contents);
3362           goto done;
3363         }
3364
3365       size = 0;
3366       for (i = secsymend; i < opdsymend; ++i)
3367         {
3368           bfd_vma ent;
3369
3370           /* Ignore bogus symbols.  */
3371           if (syms[i]->value > opd->size - 8)
3372             continue;
3373
3374           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3375           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3376             {
3377               ++count;
3378               size += sizeof (asymbol);
3379               size += strlen (syms[i]->name) + 2;
3380             }
3381         }
3382
3383       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3384       if (dyn_count != 0
3385           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3386         {
3387           bfd_byte *dynbuf, *extdyn, *extdynend;
3388           size_t extdynsize;
3389           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3390
3391           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3392             goto free_contents_and_exit_err;
3393
3394           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3395           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3396
3397           extdyn = dynbuf;
3398           extdynend = extdyn + dynamic->size;
3399           for (; extdyn < extdynend; extdyn += extdynsize)
3400             {
3401               Elf_Internal_Dyn dyn;
3402               (*swap_dyn_in) (abfd, extdyn, &dyn);
3403
3404               if (dyn.d_tag == DT_NULL)
3405                 break;
3406
3407               if (dyn.d_tag == DT_PPC64_GLINK)
3408                 {
3409                   /* The first glink stub starts at offset 32; see
3410                      comment in ppc64_elf_finish_dynamic_sections. */
3411                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3412                   /* The .glink section usually does not survive the final
3413                      link; search for the section (usually .text) where the
3414                      glink stubs now reside.  */
3415                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3416                                                 &glink_vma);
3417                   break;
3418                 }
3419             }
3420
3421           free (dynbuf);
3422         }
3423
3424       if (glink != NULL)
3425         {
3426           /* Determine __glink trampoline by reading the relative branch
3427              from the first glink stub.  */
3428           bfd_byte buf[4];
3429           unsigned int off = 0;
3430
3431           while (bfd_get_section_contents (abfd, glink, buf,
3432                                            glink_vma + off - glink->vma, 4))
3433             {
3434               unsigned int insn = bfd_get_32 (abfd, buf);
3435               insn ^= B_DOT;
3436               if ((insn & ~0x3fffffc) == 0)
3437                 {
3438                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3439                   break;
3440                 }
3441               off += 4;
3442               if (off > 4)
3443                 break;
3444             }
3445
3446           if (resolv_vma)
3447             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3448
3449           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3450           if (relplt != NULL)
3451             {
3452               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3453               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3454                 goto free_contents_and_exit_err;
3455
3456               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3457               size += plt_count * sizeof (asymbol);
3458
3459               p = relplt->relocation;
3460               for (i = 0; i < plt_count; i++, p++)
3461                 {
3462                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3463                   if (p->addend != 0)
3464                     size += sizeof ("+0x") - 1 + 16;
3465                 }
3466             }
3467         }
3468
3469       if (size == 0)
3470         goto free_contents_and_exit;
3471       s = *ret = bfd_malloc (size);
3472       if (s == NULL)
3473         goto free_contents_and_exit_err;
3474
3475       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3476
3477       for (i = secsymend; i < opdsymend; ++i)
3478         {
3479           bfd_vma ent;
3480
3481           if (syms[i]->value > opd->size - 8)
3482             continue;
3483
3484           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3485           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3486             {
3487               long lo, hi;
3488               size_t len;
3489               asection *sec = abfd->sections;
3490
3491               *s = *syms[i];
3492               lo = codesecsym;
3493               hi = codesecsymend;
3494               while (lo < hi)
3495                 {
3496                   long mid = (lo + hi) >> 1;
3497                   if (syms[mid]->section->vma < ent)
3498                     lo = mid + 1;
3499                   else if (syms[mid]->section->vma > ent)
3500                     hi = mid;
3501                   else
3502                     {
3503                       sec = syms[mid]->section;
3504                       break;
3505                     }
3506                 }
3507
3508               if (lo >= hi && lo > codesecsym)
3509                 sec = syms[lo - 1]->section;
3510
3511               for (; sec != NULL; sec = sec->next)
3512                 {
3513                   if (sec->vma > ent)
3514                     break;
3515                   /* SEC_LOAD may not be set if SEC is from a separate debug
3516                      info file.  */
3517                   if ((sec->flags & SEC_ALLOC) == 0)
3518                     break;
3519                   if ((sec->flags & SEC_CODE) != 0)
3520                     s->section = sec;
3521                 }
3522               s->flags |= BSF_SYNTHETIC;
3523               s->value = ent - s->section->vma;
3524               s->name = names;
3525               *names++ = '.';
3526               len = strlen (syms[i]->name);
3527               memcpy (names, syms[i]->name, len + 1);
3528               names += len + 1;
3529               /* Have udata.p point back to the original symbol this
3530                  synthetic symbol was derived from.  */
3531               s->udata.p = syms[i];
3532               s++;
3533             }
3534         }
3535       free (contents);
3536
3537       if (glink != NULL && relplt != NULL)
3538         {
3539           if (resolv_vma)
3540             {
3541               /* Add a symbol for the main glink trampoline.  */
3542               memset (s, 0, sizeof *s);
3543               s->the_bfd = abfd;
3544               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3545               s->section = glink;
3546               s->value = resolv_vma - glink->vma;
3547               s->name = names;
3548               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3549               names += sizeof ("__glink_PLTresolve");
3550               s++;
3551               count++;
3552             }
3553
3554           /* FIXME: It would be very much nicer to put sym@plt on the
3555              stub rather than on the glink branch table entry.  The
3556              objdump disassembler would then use a sensible symbol
3557              name on plt calls.  The difficulty in doing so is
3558              a) finding the stubs, and,
3559              b) matching stubs against plt entries, and,
3560              c) there can be multiple stubs for a given plt entry.
3561
3562              Solving (a) could be done by code scanning, but older
3563              ppc64 binaries used different stubs to current code.
3564              (b) is the tricky one since you need to known the toc
3565              pointer for at least one function that uses a pic stub to
3566              be able to calculate the plt address referenced.
3567              (c) means gdb would need to set multiple breakpoints (or
3568              find the glink branch itself) when setting breakpoints
3569              for pending shared library loads.  */
3570           p = relplt->relocation;
3571           for (i = 0; i < plt_count; i++, p++)
3572             {
3573               size_t len;
3574
3575               *s = **p->sym_ptr_ptr;
3576               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3577                  we are defining a symbol, ensure one of them is set.  */
3578               if ((s->flags & BSF_LOCAL) == 0)
3579                 s->flags |= BSF_GLOBAL;
3580               s->flags |= BSF_SYNTHETIC;
3581               s->section = glink;
3582               s->value = glink_vma - glink->vma;
3583               s->name = names;
3584               s->udata.p = NULL;
3585               len = strlen ((*p->sym_ptr_ptr)->name);
3586               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3587               names += len;
3588               if (p->addend != 0)
3589                 {
3590                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3591                   names += sizeof ("+0x") - 1;
3592                   bfd_sprintf_vma (abfd, names, p->addend);
3593                   names += strlen (names);
3594                 }
3595               memcpy (names, "@plt", sizeof ("@plt"));
3596               names += sizeof ("@plt");
3597               s++;
3598               if (abi < 2)
3599                 {
3600                   glink_vma += 8;
3601                   if (i >= 0x8000)
3602                     glink_vma += 4;
3603                 }
3604               else
3605                 glink_vma += 4;
3606             }
3607           count += plt_count;
3608         }
3609     }
3610
3611  done:
3612   free (syms);
3613   return count;
3614 }
3615 \f
3616 /* The following functions are specific to the ELF linker, while
3617    functions above are used generally.  Those named ppc64_elf_* are
3618    called by the main ELF linker code.  They appear in this file more
3619    or less in the order in which they are called.  eg.
3620    ppc64_elf_check_relocs is called early in the link process,
3621    ppc64_elf_finish_dynamic_sections is one of the last functions
3622    called.
3623
3624    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3625    functions have both a function code symbol and a function descriptor
3626    symbol.  A call to foo in a relocatable object file looks like:
3627
3628    .            .text
3629    .    x:
3630    .            bl      .foo
3631    .            nop
3632
3633    The function definition in another object file might be:
3634
3635    .            .section .opd
3636    .    foo:    .quad   .foo
3637    .            .quad   .TOC.@tocbase
3638    .            .quad   0
3639    .
3640    .            .text
3641    .    .foo:   blr
3642
3643    When the linker resolves the call during a static link, the branch
3644    unsurprisingly just goes to .foo and the .opd information is unused.
3645    If the function definition is in a shared library, things are a little
3646    different:  The call goes via a plt call stub, the opd information gets
3647    copied to the plt, and the linker patches the nop.
3648
3649    .    x:
3650    .            bl      .foo_stub
3651    .            ld      2,40(1)
3652    .
3653    .
3654    .    .foo_stub:
3655    .            std     2,40(1)                 # in practice, the call stub
3656    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3657    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3658    .            ld      12,0(11)
3659    .            ld      2,8(11)
3660    .            mtctr   12
3661    .            ld      11,16(11)
3662    .            bctr
3663    .
3664    .            .section .plt
3665    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3666
3667    The "reloc ()" notation is supposed to indicate that the linker emits
3668    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3669    copying.
3670
3671    What are the difficulties here?  Well, firstly, the relocations
3672    examined by the linker in check_relocs are against the function code
3673    sym .foo, while the dynamic relocation in the plt is emitted against
3674    the function descriptor symbol, foo.  Somewhere along the line, we need
3675    to carefully copy dynamic link information from one symbol to the other.
3676    Secondly, the generic part of the elf linker will make .foo a dynamic
3677    symbol as is normal for most other backends.  We need foo dynamic
3678    instead, at least for an application final link.  However, when
3679    creating a shared library containing foo, we need to have both symbols
3680    dynamic so that references to .foo are satisfied during the early
3681    stages of linking.  Otherwise the linker might decide to pull in a
3682    definition from some other object, eg. a static library.
3683
3684    Update: As of August 2004, we support a new convention.  Function
3685    calls may use the function descriptor symbol, ie. "bl foo".  This
3686    behaves exactly as "bl .foo".  */
3687
3688 /* Of those relocs that might be copied as dynamic relocs, this function
3689    selects those that must be copied when linking a shared library,
3690    even when the symbol is local.  */
3691
3692 static int
3693 must_be_dyn_reloc (struct bfd_link_info *info,
3694                    enum elf_ppc64_reloc_type r_type)
3695 {
3696   switch (r_type)
3697     {
3698     default:
3699       return 1;
3700
3701     case R_PPC64_REL32:
3702     case R_PPC64_REL64:
3703     case R_PPC64_REL30:
3704       return 0;
3705
3706     case R_PPC64_TPREL16:
3707     case R_PPC64_TPREL16_LO:
3708     case R_PPC64_TPREL16_HI:
3709     case R_PPC64_TPREL16_HA:
3710     case R_PPC64_TPREL16_DS:
3711     case R_PPC64_TPREL16_LO_DS:
3712     case R_PPC64_TPREL16_HIGH:
3713     case R_PPC64_TPREL16_HIGHA:
3714     case R_PPC64_TPREL16_HIGHER:
3715     case R_PPC64_TPREL16_HIGHERA:
3716     case R_PPC64_TPREL16_HIGHEST:
3717     case R_PPC64_TPREL16_HIGHESTA:
3718     case R_PPC64_TPREL64:
3719       return !info->executable;
3720     }
3721 }
3722
3723 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3724    copying dynamic variables from a shared lib into an app's dynbss
3725    section, and instead use a dynamic relocation to point into the
3726    shared lib.  With code that gcc generates, it's vital that this be
3727    enabled;  In the PowerPC64 ABI, the address of a function is actually
3728    the address of a function descriptor, which resides in the .opd
3729    section.  gcc uses the descriptor directly rather than going via the
3730    GOT as some other ABI's do, which means that initialized function
3731    pointers must reference the descriptor.  Thus, a function pointer
3732    initialized to the address of a function in a shared library will
3733    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3734    redefines the function descriptor symbol to point to the copy.  This
3735    presents a problem as a plt entry for that function is also
3736    initialized from the function descriptor symbol and the copy reloc
3737    may not be initialized first.  */
3738 #define ELIMINATE_COPY_RELOCS 1
3739
3740 /* Section name for stubs is the associated section name plus this
3741    string.  */
3742 #define STUB_SUFFIX ".stub"
3743
3744 /* Linker stubs.
3745    ppc_stub_long_branch:
3746    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3747    destination, but a 24 bit branch in a stub section will reach.
3748    .    b       dest
3749
3750    ppc_stub_plt_branch:
3751    Similar to the above, but a 24 bit branch in the stub section won't
3752    reach its destination.
3753    .    addis   %r11,%r2,xxx@toc@ha
3754    .    ld      %r12,xxx@toc@l(%r11)
3755    .    mtctr   %r12
3756    .    bctr
3757
3758    ppc_stub_plt_call:
3759    Used to call a function in a shared library.  If it so happens that
3760    the plt entry referenced crosses a 64k boundary, then an extra
3761    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3762    .    std     %r2,40(%r1)
3763    .    addis   %r11,%r2,xxx@toc@ha
3764    .    ld      %r12,xxx+0@toc@l(%r11)
3765    .    mtctr   %r12
3766    .    ld      %r2,xxx+8@toc@l(%r11)
3767    .    ld      %r11,xxx+16@toc@l(%r11)
3768    .    bctr
3769
3770    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3771    code to adjust the value and save r2 to support multiple toc sections.
3772    A ppc_stub_long_branch with an r2 offset looks like:
3773    .    std     %r2,40(%r1)
3774    .    addis   %r2,%r2,off@ha
3775    .    addi    %r2,%r2,off@l
3776    .    b       dest
3777
3778    A ppc_stub_plt_branch with an r2 offset looks like:
3779    .    std     %r2,40(%r1)
3780    .    addis   %r11,%r2,xxx@toc@ha
3781    .    ld      %r12,xxx@toc@l(%r11)
3782    .    addis   %r2,%r2,off@ha
3783    .    addi    %r2,%r2,off@l
3784    .    mtctr   %r12
3785    .    bctr
3786
3787    In cases where the "addis" instruction would add zero, the "addis" is
3788    omitted and following instructions modified slightly in some cases.
3789 */
3790
3791 enum ppc_stub_type {
3792   ppc_stub_none,
3793   ppc_stub_long_branch,
3794   ppc_stub_long_branch_r2off,
3795   ppc_stub_plt_branch,
3796   ppc_stub_plt_branch_r2off,
3797   ppc_stub_plt_call,
3798   ppc_stub_plt_call_r2save,
3799   ppc_stub_global_entry
3800 };
3801
3802 struct ppc_stub_hash_entry {
3803
3804   /* Base hash table entry structure.  */
3805   struct bfd_hash_entry root;
3806
3807   enum ppc_stub_type stub_type;
3808
3809   /* The stub section.  */
3810   asection *stub_sec;
3811
3812   /* Offset within stub_sec of the beginning of this stub.  */
3813   bfd_vma stub_offset;
3814
3815   /* Given the symbol's value and its section we can determine its final
3816      value when building the stubs (so the stub knows where to jump.  */
3817   bfd_vma target_value;
3818   asection *target_section;
3819
3820   /* The symbol table entry, if any, that this was derived from.  */
3821   struct ppc_link_hash_entry *h;
3822   struct plt_entry *plt_ent;
3823
3824   /* Where this stub is being called from, or, in the case of combined
3825      stub sections, the first input section in the group.  */
3826   asection *id_sec;
3827
3828   /* Symbol st_other.  */
3829   unsigned char other;
3830 };
3831
3832 struct ppc_branch_hash_entry {
3833
3834   /* Base hash table entry structure.  */
3835   struct bfd_hash_entry root;
3836
3837   /* Offset within branch lookup table.  */
3838   unsigned int offset;
3839
3840   /* Generation marker.  */
3841   unsigned int iter;
3842 };
3843
3844 /* Used to track dynamic relocations for local symbols.  */
3845 struct ppc_dyn_relocs
3846 {
3847   struct ppc_dyn_relocs *next;
3848
3849   /* The input section of the reloc.  */
3850   asection *sec;
3851
3852   /* Total number of relocs copied for the input section.  */
3853   unsigned int count : 31;
3854
3855   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3856   unsigned int ifunc : 1;
3857 };
3858
3859 struct ppc_link_hash_entry
3860 {
3861   struct elf_link_hash_entry elf;
3862
3863   union {
3864     /* A pointer to the most recently used stub hash entry against this
3865        symbol.  */
3866     struct ppc_stub_hash_entry *stub_cache;
3867
3868     /* A pointer to the next symbol starting with a '.'  */
3869     struct ppc_link_hash_entry *next_dot_sym;
3870   } u;
3871
3872   /* Track dynamic relocs copied for this symbol.  */
3873   struct elf_dyn_relocs *dyn_relocs;
3874
3875   /* Link between function code and descriptor symbols.  */
3876   struct ppc_link_hash_entry *oh;
3877
3878   /* Flag function code and descriptor symbols.  */
3879   unsigned int is_func:1;
3880   unsigned int is_func_descriptor:1;
3881   unsigned int fake:1;
3882
3883   /* Whether global opd/toc sym has been adjusted or not.
3884      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3885      should be set for all globals defined in any opd/toc section.  */
3886   unsigned int adjust_done:1;
3887
3888   /* Set if we twiddled this symbol to weak at some stage.  */
3889   unsigned int was_undefined:1;
3890
3891   /* Contexts in which symbol is used in the GOT (or TOC).
3892      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3893      corresponding relocs are encountered during check_relocs.
3894      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3895      indicate the corresponding GOT entry type is not needed.
3896      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3897      a TPREL one.  We use a separate flag rather than setting TPREL
3898      just for convenience in distinguishing the two cases.  */
3899 #define TLS_GD           1      /* GD reloc. */
3900 #define TLS_LD           2      /* LD reloc. */
3901 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3902 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3903 #define TLS_TLS         16      /* Any TLS reloc.  */
3904 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3905 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3906 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3907   unsigned char tls_mask;
3908 };
3909
3910 /* ppc64 ELF linker hash table.  */
3911
3912 struct ppc_link_hash_table
3913 {
3914   struct elf_link_hash_table elf;
3915
3916   /* The stub hash table.  */
3917   struct bfd_hash_table stub_hash_table;
3918
3919   /* Another hash table for plt_branch stubs.  */
3920   struct bfd_hash_table branch_hash_table;
3921
3922   /* Hash table for function prologue tocsave.  */
3923   htab_t tocsave_htab;
3924
3925   /* Various options and other info passed from the linker.  */
3926   struct ppc64_elf_params *params;
3927
3928   /* Array to keep track of which stub sections have been created, and
3929      information on stub grouping.  */
3930   struct map_stub {
3931     /* This is the section to which stubs in the group will be attached.  */
3932     asection *link_sec;
3933     /* The stub section.  */
3934     asection *stub_sec;
3935     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3936     bfd_vma toc_off;
3937   } *stub_group;
3938
3939   /* Temp used when calculating TOC pointers.  */
3940   bfd_vma toc_curr;
3941   bfd *toc_bfd;
3942   asection *toc_first_sec;
3943
3944   /* Highest input section id.  */
3945   int top_id;
3946
3947   /* Highest output section index.  */
3948   int top_index;
3949
3950   /* Used when adding symbols.  */
3951   struct ppc_link_hash_entry *dot_syms;
3952
3953   /* List of input sections for each output section.  */
3954   asection **input_list;
3955
3956   /* Shortcuts to get to dynamic linker sections.  */
3957   asection *dynbss;
3958   asection *relbss;
3959   asection *glink;
3960   asection *sfpr;
3961   asection *brlt;
3962   asection *relbrlt;
3963   asection *glink_eh_frame;
3964
3965   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3966   struct ppc_link_hash_entry *tls_get_addr;
3967   struct ppc_link_hash_entry *tls_get_addr_fd;
3968
3969   /* The size of reliplt used by got entry relocs.  */
3970   bfd_size_type got_reli_size;
3971
3972   /* Statistics.  */
3973   unsigned long stub_count[ppc_stub_global_entry];
3974
3975   /* Number of stubs against global syms.  */
3976   unsigned long stub_globals;
3977
3978   /* Set if we're linking code with function descriptors.  */
3979   unsigned int opd_abi:1;
3980
3981   /* Support for multiple toc sections.  */
3982   unsigned int do_multi_toc:1;
3983   unsigned int multi_toc_needed:1;
3984   unsigned int second_toc_pass:1;
3985   unsigned int do_toc_opt:1;
3986
3987   /* Set on error.  */
3988   unsigned int stub_error:1;
3989
3990   /* Temp used by ppc64_elf_before_check_relocs.  */
3991   unsigned int twiddled_syms:1;
3992
3993   /* Incremented every time we size stubs.  */
3994   unsigned int stub_iteration;
3995
3996   /* Small local sym cache.  */
3997   struct sym_cache sym_cache;
3998 };
3999
4000 /* Rename some of the generic section flags to better document how they
4001    are used here.  */
4002
4003 /* Nonzero if this section has TLS related relocations.  */
4004 #define has_tls_reloc sec_flg0
4005
4006 /* Nonzero if this section has a call to __tls_get_addr.  */
4007 #define has_tls_get_addr_call sec_flg1
4008
4009 /* Nonzero if this section has any toc or got relocs.  */
4010 #define has_toc_reloc sec_flg2
4011
4012 /* Nonzero if this section has a call to another section that uses
4013    the toc or got.  */
4014 #define makes_toc_func_call sec_flg3
4015
4016 /* Recursion protection when determining above flag.  */
4017 #define call_check_in_progress sec_flg4
4018 #define call_check_done sec_flg5
4019
4020 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4021
4022 #define ppc_hash_table(p) \
4023   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4024   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4025
4026 #define ppc_stub_hash_lookup(table, string, create, copy) \
4027   ((struct ppc_stub_hash_entry *) \
4028    bfd_hash_lookup ((table), (string), (create), (copy)))
4029
4030 #define ppc_branch_hash_lookup(table, string, create, copy) \
4031   ((struct ppc_branch_hash_entry *) \
4032    bfd_hash_lookup ((table), (string), (create), (copy)))
4033
4034 /* Create an entry in the stub hash table.  */
4035
4036 static struct bfd_hash_entry *
4037 stub_hash_newfunc (struct bfd_hash_entry *entry,
4038                    struct bfd_hash_table *table,
4039                    const char *string)
4040 {
4041   /* Allocate the structure if it has not already been allocated by a
4042      subclass.  */
4043   if (entry == NULL)
4044     {
4045       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4046       if (entry == NULL)
4047         return entry;
4048     }
4049
4050   /* Call the allocation method of the superclass.  */
4051   entry = bfd_hash_newfunc (entry, table, string);
4052   if (entry != NULL)
4053     {
4054       struct ppc_stub_hash_entry *eh;
4055
4056       /* Initialize the local fields.  */
4057       eh = (struct ppc_stub_hash_entry *) entry;
4058       eh->stub_type = ppc_stub_none;
4059       eh->stub_sec = NULL;
4060       eh->stub_offset = 0;
4061       eh->target_value = 0;
4062       eh->target_section = NULL;
4063       eh->h = NULL;
4064       eh->plt_ent = NULL;
4065       eh->id_sec = NULL;
4066       eh->other = 0;
4067     }
4068
4069   return entry;
4070 }
4071
4072 /* Create an entry in the branch hash table.  */
4073
4074 static struct bfd_hash_entry *
4075 branch_hash_newfunc (struct bfd_hash_entry *entry,
4076                      struct bfd_hash_table *table,
4077                      const char *string)
4078 {
4079   /* Allocate the structure if it has not already been allocated by a
4080      subclass.  */
4081   if (entry == NULL)
4082     {
4083       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4084       if (entry == NULL)
4085         return entry;
4086     }
4087
4088   /* Call the allocation method of the superclass.  */
4089   entry = bfd_hash_newfunc (entry, table, string);
4090   if (entry != NULL)
4091     {
4092       struct ppc_branch_hash_entry *eh;
4093
4094       /* Initialize the local fields.  */
4095       eh = (struct ppc_branch_hash_entry *) entry;
4096       eh->offset = 0;
4097       eh->iter = 0;
4098     }
4099
4100   return entry;
4101 }
4102
4103 /* Create an entry in a ppc64 ELF linker hash table.  */
4104
4105 static struct bfd_hash_entry *
4106 link_hash_newfunc (struct bfd_hash_entry *entry,
4107                    struct bfd_hash_table *table,
4108                    const char *string)
4109 {
4110   /* Allocate the structure if it has not already been allocated by a
4111      subclass.  */
4112   if (entry == NULL)
4113     {
4114       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4115       if (entry == NULL)
4116         return entry;
4117     }
4118
4119   /* Call the allocation method of the superclass.  */
4120   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4121   if (entry != NULL)
4122     {
4123       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4124
4125       memset (&eh->u.stub_cache, 0,
4126               (sizeof (struct ppc_link_hash_entry)
4127                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4128
4129       /* When making function calls, old ABI code references function entry
4130          points (dot symbols), while new ABI code references the function
4131          descriptor symbol.  We need to make any combination of reference and
4132          definition work together, without breaking archive linking.
4133
4134          For a defined function "foo" and an undefined call to "bar":
4135          An old object defines "foo" and ".foo", references ".bar" (possibly
4136          "bar" too).
4137          A new object defines "foo" and references "bar".
4138
4139          A new object thus has no problem with its undefined symbols being
4140          satisfied by definitions in an old object.  On the other hand, the
4141          old object won't have ".bar" satisfied by a new object.
4142
4143          Keep a list of newly added dot-symbols.  */
4144
4145       if (string[0] == '.')
4146         {
4147           struct ppc_link_hash_table *htab;
4148
4149           htab = (struct ppc_link_hash_table *) table;
4150           eh->u.next_dot_sym = htab->dot_syms;
4151           htab->dot_syms = eh;
4152         }
4153     }
4154
4155   return entry;
4156 }
4157
4158 struct tocsave_entry {
4159   asection *sec;
4160   bfd_vma offset;
4161 };
4162
4163 static hashval_t
4164 tocsave_htab_hash (const void *p)
4165 {
4166   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4167   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4168 }
4169
4170 static int
4171 tocsave_htab_eq (const void *p1, const void *p2)
4172 {
4173   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4174   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4175   return e1->sec == e2->sec && e1->offset == e2->offset;
4176 }
4177
4178 /* Destroy a ppc64 ELF linker hash table.  */
4179
4180 static void
4181 ppc64_elf_link_hash_table_free (bfd *obfd)
4182 {
4183   struct ppc_link_hash_table *htab;
4184
4185   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4186   if (htab->tocsave_htab)
4187     htab_delete (htab->tocsave_htab);
4188   bfd_hash_table_free (&htab->branch_hash_table);
4189   bfd_hash_table_free (&htab->stub_hash_table);
4190   _bfd_elf_link_hash_table_free (obfd);
4191 }
4192
4193 /* Create a ppc64 ELF linker hash table.  */
4194
4195 static struct bfd_link_hash_table *
4196 ppc64_elf_link_hash_table_create (bfd *abfd)
4197 {
4198   struct ppc_link_hash_table *htab;
4199   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4200
4201   htab = bfd_zmalloc (amt);
4202   if (htab == NULL)
4203     return NULL;
4204
4205   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4206                                       sizeof (struct ppc_link_hash_entry),
4207                                       PPC64_ELF_DATA))
4208     {
4209       free (htab);
4210       return NULL;
4211     }
4212
4213   /* Init the stub hash table too.  */
4214   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4215                             sizeof (struct ppc_stub_hash_entry)))
4216     {
4217       _bfd_elf_link_hash_table_free (abfd);
4218       return NULL;
4219     }
4220
4221   /* And the branch hash table.  */
4222   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4223                             sizeof (struct ppc_branch_hash_entry)))
4224     {
4225       bfd_hash_table_free (&htab->stub_hash_table);
4226       _bfd_elf_link_hash_table_free (abfd);
4227       return NULL;
4228     }
4229
4230   htab->tocsave_htab = htab_try_create (1024,
4231                                         tocsave_htab_hash,
4232                                         tocsave_htab_eq,
4233                                         NULL);
4234   if (htab->tocsave_htab == NULL)
4235     {
4236       ppc64_elf_link_hash_table_free (abfd);
4237       return NULL;
4238     }
4239   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4240
4241   /* Initializing two fields of the union is just cosmetic.  We really
4242      only care about glist, but when compiled on a 32-bit host the
4243      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4244      debugger inspection of these fields look nicer.  */
4245   htab->elf.init_got_refcount.refcount = 0;
4246   htab->elf.init_got_refcount.glist = NULL;
4247   htab->elf.init_plt_refcount.refcount = 0;
4248   htab->elf.init_plt_refcount.glist = NULL;
4249   htab->elf.init_got_offset.offset = 0;
4250   htab->elf.init_got_offset.glist = NULL;
4251   htab->elf.init_plt_offset.offset = 0;
4252   htab->elf.init_plt_offset.glist = NULL;
4253
4254   return &htab->elf.root;
4255 }
4256
4257 /* Create sections for linker generated code.  */
4258
4259 static bfd_boolean
4260 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4261 {
4262   struct ppc_link_hash_table *htab;
4263   flagword flags;
4264
4265   htab = ppc_hash_table (info);
4266
4267   /* Create .sfpr for code to save and restore fp regs.  */
4268   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4269            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4271                                                    flags);
4272   if (htab->sfpr == NULL
4273       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4274     return FALSE;
4275
4276   /* Create .glink for lazy dynamic linking support.  */
4277   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4278                                                     flags);
4279   if (htab->glink == NULL
4280       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4281     return FALSE;
4282
4283   if (!info->no_ld_generated_unwind_info)
4284     {
4285       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4286                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4287       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4288                                                                  ".eh_frame",
4289                                                                  flags);
4290       if (htab->glink_eh_frame == NULL
4291           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4292         return FALSE;
4293     }
4294
4295   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4296   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4297   if (htab->elf.iplt == NULL
4298       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4299     return FALSE;
4300
4301   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4302            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4303   htab->elf.irelplt
4304     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4305   if (htab->elf.irelplt == NULL
4306       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4307     return FALSE;
4308
4309   /* Create branch lookup table for plt_branch stubs.  */
4310   flags = (SEC_ALLOC | SEC_LOAD
4311            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4312   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4313                                                    flags);
4314   if (htab->brlt == NULL
4315       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4316     return FALSE;
4317
4318   if (!info->shared)
4319     return TRUE;
4320
4321   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4322            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4323   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4324                                                       ".rela.branch_lt",
4325                                                       flags);
4326   if (htab->relbrlt == NULL
4327       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4328     return FALSE;
4329
4330   return TRUE;
4331 }
4332
4333 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4334
4335 bfd_boolean
4336 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4337                          struct ppc64_elf_params *params)
4338 {
4339   struct ppc_link_hash_table *htab;
4340
4341   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4342
4343 /* Always hook our dynamic sections into the first bfd, which is the
4344    linker created stub bfd.  This ensures that the GOT header is at
4345    the start of the output TOC section.  */
4346   htab = ppc_hash_table (info);
4347   if (htab == NULL)
4348     return FALSE;
4349   htab->elf.dynobj = params->stub_bfd;
4350   htab->params = params;
4351
4352   if (info->relocatable)
4353     return TRUE;
4354
4355   return create_linkage_sections (htab->elf.dynobj, info);
4356 }
4357
4358 /* Build a name for an entry in the stub hash table.  */
4359
4360 static char *
4361 ppc_stub_name (const asection *input_section,
4362                const asection *sym_sec,
4363                const struct ppc_link_hash_entry *h,
4364                const Elf_Internal_Rela *rel)
4365 {
4366   char *stub_name;
4367   ssize_t len;
4368
4369   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4370      offsets from a sym as a branch target?  In fact, we could
4371      probably assume the addend is always zero.  */
4372   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4373
4374   if (h)
4375     {
4376       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4377       stub_name = bfd_malloc (len);
4378       if (stub_name == NULL)
4379         return stub_name;
4380
4381       len = sprintf (stub_name, "%08x.%s+%x",
4382                      input_section->id & 0xffffffff,
4383                      h->elf.root.root.string,
4384                      (int) rel->r_addend & 0xffffffff);
4385     }
4386   else
4387     {
4388       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4389       stub_name = bfd_malloc (len);
4390       if (stub_name == NULL)
4391         return stub_name;
4392
4393       len = sprintf (stub_name, "%08x.%x:%x+%x",
4394                      input_section->id & 0xffffffff,
4395                      sym_sec->id & 0xffffffff,
4396                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4397                      (int) rel->r_addend & 0xffffffff);
4398     }
4399   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4400     stub_name[len - 2] = 0;
4401   return stub_name;
4402 }
4403
4404 /* Look up an entry in the stub hash.  Stub entries are cached because
4405    creating the stub name takes a bit of time.  */
4406
4407 static struct ppc_stub_hash_entry *
4408 ppc_get_stub_entry (const asection *input_section,
4409                     const asection *sym_sec,
4410                     struct ppc_link_hash_entry *h,
4411                     const Elf_Internal_Rela *rel,
4412                     struct ppc_link_hash_table *htab)
4413 {
4414   struct ppc_stub_hash_entry *stub_entry;
4415   const asection *id_sec;
4416
4417   /* If this input section is part of a group of sections sharing one
4418      stub section, then use the id of the first section in the group.
4419      Stub names need to include a section id, as there may well be
4420      more than one stub used to reach say, printf, and we need to
4421      distinguish between them.  */
4422   id_sec = htab->stub_group[input_section->id].link_sec;
4423
4424   if (h != NULL && h->u.stub_cache != NULL
4425       && h->u.stub_cache->h == h
4426       && h->u.stub_cache->id_sec == id_sec)
4427     {
4428       stub_entry = h->u.stub_cache;
4429     }
4430   else
4431     {
4432       char *stub_name;
4433
4434       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4435       if (stub_name == NULL)
4436         return NULL;
4437
4438       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4439                                          stub_name, FALSE, FALSE);
4440       if (h != NULL)
4441         h->u.stub_cache = stub_entry;
4442
4443       free (stub_name);
4444     }
4445
4446   return stub_entry;
4447 }
4448
4449 /* Add a new stub entry to the stub hash.  Not all fields of the new
4450    stub entry are initialised.  */
4451
4452 static struct ppc_stub_hash_entry *
4453 ppc_add_stub (const char *stub_name,
4454               asection *section,
4455               struct bfd_link_info *info)
4456 {
4457   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4458   asection *link_sec;
4459   asection *stub_sec;
4460   struct ppc_stub_hash_entry *stub_entry;
4461
4462   link_sec = htab->stub_group[section->id].link_sec;
4463   stub_sec = htab->stub_group[section->id].stub_sec;
4464   if (stub_sec == NULL)
4465     {
4466       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4467       if (stub_sec == NULL)
4468         {
4469           size_t namelen;
4470           bfd_size_type len;
4471           char *s_name;
4472
4473           namelen = strlen (link_sec->name);
4474           len = namelen + sizeof (STUB_SUFFIX);
4475           s_name = bfd_alloc (htab->params->stub_bfd, len);
4476           if (s_name == NULL)
4477             return NULL;
4478
4479           memcpy (s_name, link_sec->name, namelen);
4480           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4481           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4482           if (stub_sec == NULL)
4483             return NULL;
4484           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4485         }
4486       htab->stub_group[section->id].stub_sec = stub_sec;
4487     }
4488
4489   /* Enter this entry into the linker stub hash table.  */
4490   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4491                                      TRUE, FALSE);
4492   if (stub_entry == NULL)
4493     {
4494       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4495                               section->owner, stub_name);
4496       return NULL;
4497     }
4498
4499   stub_entry->stub_sec = stub_sec;
4500   stub_entry->stub_offset = 0;
4501   stub_entry->id_sec = link_sec;
4502   return stub_entry;
4503 }
4504
4505 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4506    not already done.  */
4507
4508 static bfd_boolean
4509 create_got_section (bfd *abfd, struct bfd_link_info *info)
4510 {
4511   asection *got, *relgot;
4512   flagword flags;
4513   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4514
4515   if (!is_ppc64_elf (abfd))
4516     return FALSE;
4517   if (htab == NULL)
4518     return FALSE;
4519
4520   if (!htab->elf.sgot
4521       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4522     return FALSE;
4523
4524   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4525            | SEC_LINKER_CREATED);
4526
4527   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4528   if (!got
4529       || !bfd_set_section_alignment (abfd, got, 3))
4530     return FALSE;
4531
4532   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4533                                                flags | SEC_READONLY);
4534   if (!relgot
4535       || ! bfd_set_section_alignment (abfd, relgot, 3))
4536     return FALSE;
4537
4538   ppc64_elf_tdata (abfd)->got = got;
4539   ppc64_elf_tdata (abfd)->relgot = relgot;
4540   return TRUE;
4541 }
4542
4543 /* Create the dynamic sections, and set up shortcuts.  */
4544
4545 static bfd_boolean
4546 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4547 {
4548   struct ppc_link_hash_table *htab;
4549
4550   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4551     return FALSE;
4552
4553   htab = ppc_hash_table (info);
4554   if (htab == NULL)
4555     return FALSE;
4556
4557   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4558   if (!info->shared)
4559     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4560
4561   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4562       || (!info->shared && !htab->relbss))
4563     abort ();
4564
4565   return TRUE;
4566 }
4567
4568 /* Follow indirect and warning symbol links.  */
4569
4570 static inline struct bfd_link_hash_entry *
4571 follow_link (struct bfd_link_hash_entry *h)
4572 {
4573   while (h->type == bfd_link_hash_indirect
4574          || h->type == bfd_link_hash_warning)
4575     h = h->u.i.link;
4576   return h;
4577 }
4578
4579 static inline struct elf_link_hash_entry *
4580 elf_follow_link (struct elf_link_hash_entry *h)
4581 {
4582   return (struct elf_link_hash_entry *) follow_link (&h->root);
4583 }
4584
4585 static inline struct ppc_link_hash_entry *
4586 ppc_follow_link (struct ppc_link_hash_entry *h)
4587 {
4588   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4589 }
4590
4591 /* Merge PLT info on FROM with that on TO.  */
4592
4593 static void
4594 move_plt_plist (struct ppc_link_hash_entry *from,
4595                 struct ppc_link_hash_entry *to)
4596 {
4597   if (from->elf.plt.plist != NULL)
4598     {
4599       if (to->elf.plt.plist != NULL)
4600         {
4601           struct plt_entry **entp;
4602           struct plt_entry *ent;
4603
4604           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4605             {
4606               struct plt_entry *dent;
4607
4608               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4609                 if (dent->addend == ent->addend)
4610                   {
4611                     dent->plt.refcount += ent->plt.refcount;
4612                     *entp = ent->next;
4613                     break;
4614                   }
4615               if (dent == NULL)
4616                 entp = &ent->next;
4617             }
4618           *entp = to->elf.plt.plist;
4619         }
4620
4621       to->elf.plt.plist = from->elf.plt.plist;
4622       from->elf.plt.plist = NULL;
4623     }
4624 }
4625
4626 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4627
4628 static void
4629 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4630                                 struct elf_link_hash_entry *dir,
4631                                 struct elf_link_hash_entry *ind)
4632 {
4633   struct ppc_link_hash_entry *edir, *eind;
4634
4635   edir = (struct ppc_link_hash_entry *) dir;
4636   eind = (struct ppc_link_hash_entry *) ind;
4637
4638   edir->is_func |= eind->is_func;
4639   edir->is_func_descriptor |= eind->is_func_descriptor;
4640   edir->tls_mask |= eind->tls_mask;
4641   if (eind->oh != NULL)
4642     edir->oh = ppc_follow_link (eind->oh);
4643
4644   /* If called to transfer flags for a weakdef during processing
4645      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4646      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4647   if (!(ELIMINATE_COPY_RELOCS
4648         && eind->elf.root.type != bfd_link_hash_indirect
4649         && edir->elf.dynamic_adjusted))
4650     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4651
4652   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4653   edir->elf.ref_regular |= eind->elf.ref_regular;
4654   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4655   edir->elf.needs_plt |= eind->elf.needs_plt;
4656   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4657
4658   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4659   if (eind->dyn_relocs != NULL)
4660     {
4661       if (edir->dyn_relocs != NULL)
4662         {
4663           struct elf_dyn_relocs **pp;
4664           struct elf_dyn_relocs *p;
4665
4666           /* Add reloc counts against the indirect sym to the direct sym
4667              list.  Merge any entries against the same section.  */
4668           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4669             {
4670               struct elf_dyn_relocs *q;
4671
4672               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4673                 if (q->sec == p->sec)
4674                   {
4675                     q->pc_count += p->pc_count;
4676                     q->count += p->count;
4677                     *pp = p->next;
4678                     break;
4679                   }
4680               if (q == NULL)
4681                 pp = &p->next;
4682             }
4683           *pp = edir->dyn_relocs;
4684         }
4685
4686       edir->dyn_relocs = eind->dyn_relocs;
4687       eind->dyn_relocs = NULL;
4688     }
4689
4690   /* If we were called to copy over info for a weak sym, that's all.
4691      You might think dyn_relocs need not be copied over;  After all,
4692      both syms will be dynamic or both non-dynamic so we're just
4693      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4694      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4695      dyn_relocs in read-only sections, and it does so on what is the
4696      DIR sym here.  */
4697   if (eind->elf.root.type != bfd_link_hash_indirect)
4698     return;
4699
4700   /* Copy over got entries that we may have already seen to the
4701      symbol which just became indirect.  */
4702   if (eind->elf.got.glist != NULL)
4703     {
4704       if (edir->elf.got.glist != NULL)
4705         {
4706           struct got_entry **entp;
4707           struct got_entry *ent;
4708
4709           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4710             {
4711               struct got_entry *dent;
4712
4713               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4714                 if (dent->addend == ent->addend
4715                     && dent->owner == ent->owner
4716                     && dent->tls_type == ent->tls_type)
4717                   {
4718                     dent->got.refcount += ent->got.refcount;
4719                     *entp = ent->next;
4720                     break;
4721                   }
4722               if (dent == NULL)
4723                 entp = &ent->next;
4724             }
4725           *entp = edir->elf.got.glist;
4726         }
4727
4728       edir->elf.got.glist = eind->elf.got.glist;
4729       eind->elf.got.glist = NULL;
4730     }
4731
4732   /* And plt entries.  */
4733   move_plt_plist (eind, edir);
4734
4735   if (eind->elf.dynindx != -1)
4736     {
4737       if (edir->elf.dynindx != -1)
4738         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4739                                 edir->elf.dynstr_index);
4740       edir->elf.dynindx = eind->elf.dynindx;
4741       edir->elf.dynstr_index = eind->elf.dynstr_index;
4742       eind->elf.dynindx = -1;
4743       eind->elf.dynstr_index = 0;
4744     }
4745 }
4746
4747 /* Find the function descriptor hash entry from the given function code
4748    hash entry FH.  Link the entries via their OH fields.  */
4749
4750 static struct ppc_link_hash_entry *
4751 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4752 {
4753   struct ppc_link_hash_entry *fdh = fh->oh;
4754
4755   if (fdh == NULL)
4756     {
4757       const char *fd_name = fh->elf.root.root.string + 1;
4758
4759       fdh = (struct ppc_link_hash_entry *)
4760         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4761       if (fdh == NULL)
4762         return fdh;
4763
4764       fdh->is_func_descriptor = 1;
4765       fdh->oh = fh;
4766       fh->is_func = 1;
4767       fh->oh = fdh;
4768     }
4769
4770   return ppc_follow_link (fdh);
4771 }
4772
4773 /* Make a fake function descriptor sym for the code sym FH.  */
4774
4775 static struct ppc_link_hash_entry *
4776 make_fdh (struct bfd_link_info *info,
4777           struct ppc_link_hash_entry *fh)
4778 {
4779   bfd *abfd;
4780   asymbol *newsym;
4781   struct bfd_link_hash_entry *bh;
4782   struct ppc_link_hash_entry *fdh;
4783
4784   abfd = fh->elf.root.u.undef.abfd;
4785   newsym = bfd_make_empty_symbol (abfd);
4786   newsym->name = fh->elf.root.root.string + 1;
4787   newsym->section = bfd_und_section_ptr;
4788   newsym->value = 0;
4789   newsym->flags = BSF_WEAK;
4790
4791   bh = NULL;
4792   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4793                                          newsym->flags, newsym->section,
4794                                          newsym->value, NULL, FALSE, FALSE,
4795                                          &bh))
4796     return NULL;
4797
4798   fdh = (struct ppc_link_hash_entry *) bh;
4799   fdh->elf.non_elf = 0;
4800   fdh->fake = 1;
4801   fdh->is_func_descriptor = 1;
4802   fdh->oh = fh;
4803   fh->is_func = 1;
4804   fh->oh = fdh;
4805   return fdh;
4806 }
4807
4808 /* Fix function descriptor symbols defined in .opd sections to be
4809    function type.  */
4810
4811 static bfd_boolean
4812 ppc64_elf_add_symbol_hook (bfd *ibfd,
4813                            struct bfd_link_info *info,
4814                            Elf_Internal_Sym *isym,
4815                            const char **name,
4816                            flagword *flags ATTRIBUTE_UNUSED,
4817                            asection **sec,
4818                            bfd_vma *value)
4819 {
4820   if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4821        || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4822       && (ibfd->flags & DYNAMIC) == 0
4823       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4824     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
4825
4826   if (*sec != NULL
4827       && strcmp ((*sec)->name, ".opd") == 0)
4828     {
4829       asection *code_sec;
4830
4831       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4832             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4833         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4834
4835       /* If the symbol is a function defined in .opd, and the function
4836          code is in a discarded group, let it appear to be undefined.  */
4837       if (!info->relocatable
4838           && (*sec)->reloc_count != 0
4839           && opd_entry_value (*sec, *value, &code_sec, NULL,
4840                               FALSE) != (bfd_vma) -1
4841           && discarded_section (code_sec))
4842         {
4843           *sec = bfd_und_section_ptr;
4844           isym->st_shndx = SHN_UNDEF;
4845         }
4846     }
4847   else if (*sec != NULL
4848            && strcmp ((*sec)->name, ".toc") == 0
4849            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4850     {
4851       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4852       if (htab != NULL)
4853         htab->params->object_in_toc = 1;
4854     }
4855
4856   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4857     {
4858       if (abiversion (ibfd) == 0)
4859         set_abiversion (ibfd, 2);
4860       else if (abiversion (ibfd) == 1)
4861         {
4862           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4863                                     " for ABI version 1\n"), name);
4864           bfd_set_error (bfd_error_bad_value);
4865           return FALSE;
4866         }
4867     }
4868
4869   return TRUE;
4870 }
4871
4872 /* Merge non-visibility st_other attributes: local entry point.  */
4873
4874 static void
4875 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4876                                   const Elf_Internal_Sym *isym,
4877                                   bfd_boolean definition,
4878                                   bfd_boolean dynamic)
4879 {
4880   if (definition && !dynamic)
4881     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4882                 | ELF_ST_VISIBILITY (h->other));
4883 }
4884
4885 /* This function makes an old ABI object reference to ".bar" cause the
4886    inclusion of a new ABI object archive that defines "bar".
4887    NAME is a symbol defined in an archive.  Return a symbol in the hash
4888    table that might be satisfied by the archive symbols.  */
4889
4890 static struct elf_link_hash_entry *
4891 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4892                                  struct bfd_link_info *info,
4893                                  const char *name)
4894 {
4895   struct elf_link_hash_entry *h;
4896   char *dot_name;
4897   size_t len;
4898
4899   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4900   if (h != NULL
4901       /* Don't return this sym if it is a fake function descriptor
4902          created by add_symbol_adjust.  */
4903       && !(h->root.type == bfd_link_hash_undefweak
4904            && ((struct ppc_link_hash_entry *) h)->fake))
4905     return h;
4906
4907   if (name[0] == '.')
4908     return h;
4909
4910   len = strlen (name);
4911   dot_name = bfd_alloc (abfd, len + 2);
4912   if (dot_name == NULL)
4913     return (struct elf_link_hash_entry *) 0 - 1;
4914   dot_name[0] = '.';
4915   memcpy (dot_name + 1, name, len + 1);
4916   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4917   bfd_release (abfd, dot_name);
4918   return h;
4919 }
4920
4921 /* This function satisfies all old ABI object references to ".bar" if a
4922    new ABI object defines "bar".  Well, at least, undefined dot symbols
4923    are made weak.  This stops later archive searches from including an
4924    object if we already have a function descriptor definition.  It also
4925    prevents the linker complaining about undefined symbols.
4926    We also check and correct mismatched symbol visibility here.  The
4927    most restrictive visibility of the function descriptor and the
4928    function entry symbol is used.  */
4929
4930 static bfd_boolean
4931 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4932 {
4933   struct ppc_link_hash_table *htab;
4934   struct ppc_link_hash_entry *fdh;
4935
4936   if (eh->elf.root.type == bfd_link_hash_indirect)
4937     return TRUE;
4938
4939   if (eh->elf.root.type == bfd_link_hash_warning)
4940     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4941
4942   if (eh->elf.root.root.string[0] != '.')
4943     abort ();
4944
4945   htab = ppc_hash_table (info);
4946   if (htab == NULL)
4947     return FALSE;
4948
4949   fdh = lookup_fdh (eh, htab);
4950   if (fdh == NULL)
4951     {
4952       if (!info->relocatable
4953           && (eh->elf.root.type == bfd_link_hash_undefined
4954               || eh->elf.root.type == bfd_link_hash_undefweak)
4955           && eh->elf.ref_regular)
4956         {
4957           /* Make an undefweak function descriptor sym, which is enough to
4958              pull in an --as-needed shared lib, but won't cause link
4959              errors.  Archives are handled elsewhere.  */
4960           fdh = make_fdh (info, eh);
4961           if (fdh == NULL)
4962             return FALSE;
4963           fdh->elf.ref_regular = 1;
4964         }
4965     }
4966   else
4967     {
4968       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4969       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4970       if (entry_vis < descr_vis)
4971         fdh->elf.other += entry_vis - descr_vis;
4972       else if (entry_vis > descr_vis)
4973         eh->elf.other += descr_vis - entry_vis;
4974
4975       if ((fdh->elf.root.type == bfd_link_hash_defined
4976            || fdh->elf.root.type == bfd_link_hash_defweak)
4977           && eh->elf.root.type == bfd_link_hash_undefined)
4978         {
4979           eh->elf.root.type = bfd_link_hash_undefweak;
4980           eh->was_undefined = 1;
4981           htab->twiddled_syms = 1;
4982         }
4983     }
4984
4985   return TRUE;
4986 }
4987
4988 /* Set up opd section info and abiversion for IBFD, and process list
4989    of dot-symbols we made in link_hash_newfunc.  */
4990
4991 static bfd_boolean
4992 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4993 {
4994   struct ppc_link_hash_table *htab;
4995   struct ppc_link_hash_entry **p, *eh;
4996   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4997
4998   if (opd != NULL && opd->size != 0)
4999     {
5000       if (abiversion (ibfd) == 0)
5001         set_abiversion (ibfd, 1);
5002       else if (abiversion (ibfd) == 2)
5003         {
5004           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5005                                     " version %d\n"),
5006                                   ibfd, abiversion (ibfd));
5007           bfd_set_error (bfd_error_bad_value);
5008           return FALSE;
5009         }
5010
5011       if ((ibfd->flags & DYNAMIC) == 0
5012           && (opd->flags & SEC_RELOC) != 0
5013           && opd->reloc_count != 0
5014           && !bfd_is_abs_section (opd->output_section))
5015         {
5016           /* Garbage collection needs some extra help with .opd sections.
5017              We don't want to necessarily keep everything referenced by
5018              relocs in .opd, as that would keep all functions.  Instead,
5019              if we reference an .opd symbol (a function descriptor), we
5020              want to keep the function code symbol's section.  This is
5021              easy for global symbols, but for local syms we need to keep
5022              information about the associated function section.  */
5023           bfd_size_type amt;
5024           asection **opd_sym_map;
5025
5026           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5027           opd_sym_map = bfd_zalloc (ibfd, amt);
5028           if (opd_sym_map == NULL)
5029             return FALSE;
5030           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5031           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5032           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5033         }
5034     }
5035
5036   if (!is_ppc64_elf (info->output_bfd))
5037     return TRUE;
5038   htab = ppc_hash_table (info);
5039   if (htab == NULL)
5040     return FALSE;
5041
5042   /* For input files without an explicit abiversion in e_flags
5043      we should have flagged any with symbol st_other bits set
5044      as ELFv1 and above flagged those with .opd as ELFv2.
5045      Set the output abiversion if not yet set, and for any input
5046      still ambiguous, take its abiversion from the output.
5047      Differences in ABI are reported later.  */
5048   if (abiversion (info->output_bfd) == 0)
5049     set_abiversion (info->output_bfd, abiversion (ibfd));
5050   else if (abiversion (ibfd) == 0)
5051     set_abiversion (ibfd, abiversion (info->output_bfd));
5052
5053   p = &htab->dot_syms;
5054   while ((eh = *p) != NULL)
5055     {
5056       *p = NULL;
5057       if (&eh->elf == htab->elf.hgot)
5058         ;
5059       else if (htab->elf.hgot == NULL
5060                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5061         htab->elf.hgot = &eh->elf;
5062       else if (!add_symbol_adjust (eh, info))
5063         return FALSE;
5064       p = &eh->u.next_dot_sym;
5065     }
5066
5067   /* Clear the list for non-ppc64 input files.  */
5068   p = &htab->dot_syms;
5069   while ((eh = *p) != NULL)
5070     {
5071       *p = NULL;
5072       p = &eh->u.next_dot_sym;
5073     }
5074
5075   /* We need to fix the undefs list for any syms we have twiddled to
5076      undef_weak.  */
5077   if (htab->twiddled_syms)
5078     {
5079       bfd_link_repair_undef_list (&htab->elf.root);
5080       htab->twiddled_syms = 0;
5081     }
5082   return TRUE;
5083 }
5084
5085 /* Undo hash table changes when an --as-needed input file is determined
5086    not to be needed.  */
5087
5088 static bfd_boolean
5089 ppc64_elf_notice_as_needed (bfd *ibfd,
5090                             struct bfd_link_info *info,
5091                             enum notice_asneeded_action act)
5092 {
5093   if (act == notice_not_needed)
5094     {
5095       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5096
5097       if (htab == NULL)
5098         return FALSE;
5099
5100       htab->dot_syms = NULL;
5101     }
5102   return _bfd_elf_notice_as_needed (ibfd, info, act);
5103 }
5104
5105 /* If --just-symbols against a final linked binary, then assume we need
5106    toc adjusting stubs when calling functions defined there.  */
5107
5108 static void
5109 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5110 {
5111   if ((sec->flags & SEC_CODE) != 0
5112       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5113       && is_ppc64_elf (sec->owner))
5114     {
5115       if (abiversion (sec->owner) >= 2
5116           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5117         sec->has_toc_reloc = 1;
5118     }
5119   _bfd_elf_link_just_syms (sec, info);
5120 }
5121
5122 static struct plt_entry **
5123 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5124                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5125 {
5126   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5127   struct plt_entry **local_plt;
5128   unsigned char *local_got_tls_masks;
5129
5130   if (local_got_ents == NULL)
5131     {
5132       bfd_size_type size = symtab_hdr->sh_info;
5133
5134       size *= (sizeof (*local_got_ents)
5135                + sizeof (*local_plt)
5136                + sizeof (*local_got_tls_masks));
5137       local_got_ents = bfd_zalloc (abfd, size);
5138       if (local_got_ents == NULL)
5139         return NULL;
5140       elf_local_got_ents (abfd) = local_got_ents;
5141     }
5142
5143   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5144     {
5145       struct got_entry *ent;
5146
5147       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5148         if (ent->addend == r_addend
5149             && ent->owner == abfd
5150             && ent->tls_type == tls_type)
5151           break;
5152       if (ent == NULL)
5153         {
5154           bfd_size_type amt = sizeof (*ent);
5155           ent = bfd_alloc (abfd, amt);
5156           if (ent == NULL)
5157             return FALSE;
5158           ent->next = local_got_ents[r_symndx];
5159           ent->addend = r_addend;
5160           ent->owner = abfd;
5161           ent->tls_type = tls_type;
5162           ent->is_indirect = FALSE;
5163           ent->got.refcount = 0;
5164           local_got_ents[r_symndx] = ent;
5165         }
5166       ent->got.refcount += 1;
5167     }
5168
5169   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5170   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5171   local_got_tls_masks[r_symndx] |= tls_type;
5172
5173   return local_plt + r_symndx;
5174 }
5175
5176 static bfd_boolean
5177 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5178 {
5179   struct plt_entry *ent;
5180
5181   for (ent = *plist; ent != NULL; ent = ent->next)
5182     if (ent->addend == addend)
5183       break;
5184   if (ent == NULL)
5185     {
5186       bfd_size_type amt = sizeof (*ent);
5187       ent = bfd_alloc (abfd, amt);
5188       if (ent == NULL)
5189         return FALSE;
5190       ent->next = *plist;
5191       ent->addend = addend;
5192       ent->plt.refcount = 0;
5193       *plist = ent;
5194     }
5195   ent->plt.refcount += 1;
5196   return TRUE;
5197 }
5198
5199 static bfd_boolean
5200 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5201 {
5202   return (r_type == R_PPC64_REL24
5203           || r_type == R_PPC64_REL14
5204           || r_type == R_PPC64_REL14_BRTAKEN
5205           || r_type == R_PPC64_REL14_BRNTAKEN
5206           || r_type == R_PPC64_ADDR24
5207           || r_type == R_PPC64_ADDR14
5208           || r_type == R_PPC64_ADDR14_BRTAKEN
5209           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5210 }
5211
5212 /* Look through the relocs for a section during the first phase, and
5213    calculate needed space in the global offset table, procedure
5214    linkage table, and dynamic reloc sections.  */
5215
5216 static bfd_boolean
5217 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5218                         asection *sec, const Elf_Internal_Rela *relocs)
5219 {
5220   struct ppc_link_hash_table *htab;
5221   Elf_Internal_Shdr *symtab_hdr;
5222   struct elf_link_hash_entry **sym_hashes;
5223   const Elf_Internal_Rela *rel;
5224   const Elf_Internal_Rela *rel_end;
5225   asection *sreloc;
5226   asection **opd_sym_map;
5227   struct elf_link_hash_entry *tga, *dottga;
5228
5229   if (info->relocatable)
5230     return TRUE;
5231
5232   /* Don't do anything special with non-loaded, non-alloced sections.
5233      In particular, any relocs in such sections should not affect GOT
5234      and PLT reference counting (ie. we don't allow them to create GOT
5235      or PLT entries), there's no possibility or desire to optimize TLS
5236      relocs, and there's not much point in propagating relocs to shared
5237      libs that the dynamic linker won't relocate.  */
5238   if ((sec->flags & SEC_ALLOC) == 0)
5239     return TRUE;
5240
5241   BFD_ASSERT (is_ppc64_elf (abfd));
5242
5243   htab = ppc_hash_table (info);
5244   if (htab == NULL)
5245     return FALSE;
5246
5247   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5248                               FALSE, FALSE, TRUE);
5249   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5250                                  FALSE, FALSE, TRUE);
5251   symtab_hdr = &elf_symtab_hdr (abfd);
5252   sym_hashes = elf_sym_hashes (abfd);
5253   sreloc = NULL;
5254   opd_sym_map = NULL;
5255   if (ppc64_elf_section_data (sec) != NULL
5256       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5257     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5258
5259   rel_end = relocs + sec->reloc_count;
5260   for (rel = relocs; rel < rel_end; rel++)
5261     {
5262       unsigned long r_symndx;
5263       struct elf_link_hash_entry *h;
5264       enum elf_ppc64_reloc_type r_type;
5265       int tls_type;
5266       struct _ppc64_elf_section_data *ppc64_sec;
5267       struct plt_entry **ifunc;
5268
5269       r_symndx = ELF64_R_SYM (rel->r_info);
5270       if (r_symndx < symtab_hdr->sh_info)
5271         h = NULL;
5272       else
5273         {
5274           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5275           h = elf_follow_link (h);
5276
5277           /* PR15323, ref flags aren't set for references in the same
5278              object.  */
5279           h->root.non_ir_ref = 1;
5280
5281           if (h == htab->elf.hgot)
5282             sec->has_toc_reloc = 1;
5283         }
5284
5285       tls_type = 0;
5286       ifunc = NULL;
5287       if (h != NULL)
5288         {
5289           if (h->type == STT_GNU_IFUNC)
5290             {
5291               h->needs_plt = 1;
5292               ifunc = &h->plt.plist;
5293             }
5294         }
5295       else
5296         {
5297           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5298                                                           abfd, r_symndx);
5299           if (isym == NULL)
5300             return FALSE;
5301
5302           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5303             {
5304               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5305                                              rel->r_addend, PLT_IFUNC);
5306               if (ifunc == NULL)
5307                 return FALSE;
5308             }
5309         }
5310       r_type = ELF64_R_TYPE (rel->r_info);
5311       if (is_branch_reloc (r_type))
5312         {
5313           if (h != NULL && (h == tga || h == dottga))
5314             {
5315               if (rel != relocs
5316                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5317                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5318                 /* We have a new-style __tls_get_addr call with a marker
5319                    reloc.  */
5320                 ;
5321               else
5322                 /* Mark this section as having an old-style call.  */
5323                 sec->has_tls_get_addr_call = 1;
5324             }
5325
5326           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5327           if (ifunc != NULL
5328               && !update_plt_info (abfd, ifunc, rel->r_addend))
5329             return FALSE;
5330         }
5331
5332       switch (r_type)
5333         {
5334         case R_PPC64_TLSGD:
5335         case R_PPC64_TLSLD:
5336           /* These special tls relocs tie a call to __tls_get_addr with
5337              its parameter symbol.  */
5338           break;
5339
5340         case R_PPC64_GOT_TLSLD16:
5341         case R_PPC64_GOT_TLSLD16_LO:
5342         case R_PPC64_GOT_TLSLD16_HI:
5343         case R_PPC64_GOT_TLSLD16_HA:
5344           tls_type = TLS_TLS | TLS_LD;
5345           goto dogottls;
5346
5347         case R_PPC64_GOT_TLSGD16:
5348         case R_PPC64_GOT_TLSGD16_LO:
5349         case R_PPC64_GOT_TLSGD16_HI:
5350         case R_PPC64_GOT_TLSGD16_HA:
5351           tls_type = TLS_TLS | TLS_GD;
5352           goto dogottls;
5353
5354         case R_PPC64_GOT_TPREL16_DS:
5355         case R_PPC64_GOT_TPREL16_LO_DS:
5356         case R_PPC64_GOT_TPREL16_HI:
5357         case R_PPC64_GOT_TPREL16_HA:
5358           if (info->shared)
5359             info->flags |= DF_STATIC_TLS;
5360           tls_type = TLS_TLS | TLS_TPREL;
5361           goto dogottls;
5362
5363         case R_PPC64_GOT_DTPREL16_DS:
5364         case R_PPC64_GOT_DTPREL16_LO_DS:
5365         case R_PPC64_GOT_DTPREL16_HI:
5366         case R_PPC64_GOT_DTPREL16_HA:
5367           tls_type = TLS_TLS | TLS_DTPREL;
5368         dogottls:
5369           sec->has_tls_reloc = 1;
5370           /* Fall thru */
5371
5372         case R_PPC64_GOT16:
5373         case R_PPC64_GOT16_DS:
5374         case R_PPC64_GOT16_HA:
5375         case R_PPC64_GOT16_HI:
5376         case R_PPC64_GOT16_LO:
5377         case R_PPC64_GOT16_LO_DS:
5378           /* This symbol requires a global offset table entry.  */
5379           sec->has_toc_reloc = 1;
5380           if (r_type == R_PPC64_GOT_TLSLD16
5381               || r_type == R_PPC64_GOT_TLSGD16
5382               || r_type == R_PPC64_GOT_TPREL16_DS
5383               || r_type == R_PPC64_GOT_DTPREL16_DS
5384               || r_type == R_PPC64_GOT16
5385               || r_type == R_PPC64_GOT16_DS)
5386             {
5387               htab->do_multi_toc = 1;
5388               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5389             }
5390
5391           if (ppc64_elf_tdata (abfd)->got == NULL
5392               && !create_got_section (abfd, info))
5393             return FALSE;
5394
5395           if (h != NULL)
5396             {
5397               struct ppc_link_hash_entry *eh;
5398               struct got_entry *ent;
5399
5400               eh = (struct ppc_link_hash_entry *) h;
5401               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5402                 if (ent->addend == rel->r_addend
5403                     && ent->owner == abfd
5404                     && ent->tls_type == tls_type)
5405                   break;
5406               if (ent == NULL)
5407                 {
5408                   bfd_size_type amt = sizeof (*ent);
5409                   ent = bfd_alloc (abfd, amt);
5410                   if (ent == NULL)
5411                     return FALSE;
5412                   ent->next = eh->elf.got.glist;
5413                   ent->addend = rel->r_addend;
5414                   ent->owner = abfd;
5415                   ent->tls_type = tls_type;
5416                   ent->is_indirect = FALSE;
5417                   ent->got.refcount = 0;
5418                   eh->elf.got.glist = ent;
5419                 }
5420               ent->got.refcount += 1;
5421               eh->tls_mask |= tls_type;
5422             }
5423           else
5424             /* This is a global offset table entry for a local symbol.  */
5425             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5426                                         rel->r_addend, tls_type))
5427               return FALSE;
5428
5429           /* We may also need a plt entry if the symbol turns out to be
5430              an ifunc.  */
5431           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5432             {
5433               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5434                 return FALSE;
5435             }
5436           break;
5437
5438         case R_PPC64_PLT16_HA:
5439         case R_PPC64_PLT16_HI:
5440         case R_PPC64_PLT16_LO:
5441         case R_PPC64_PLT32:
5442         case R_PPC64_PLT64:
5443           /* This symbol requires a procedure linkage table entry.  We
5444              actually build the entry in adjust_dynamic_symbol,
5445              because this might be a case of linking PIC code without
5446              linking in any dynamic objects, in which case we don't
5447              need to generate a procedure linkage table after all.  */
5448           if (h == NULL)
5449             {
5450               /* It does not make sense to have a procedure linkage
5451                  table entry for a local symbol.  */
5452               bfd_set_error (bfd_error_bad_value);
5453               return FALSE;
5454             }
5455           else
5456             {
5457               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5458                 return FALSE;
5459               h->needs_plt = 1;
5460               if (h->root.root.string[0] == '.'
5461                   && h->root.root.string[1] != '\0')
5462                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5463             }
5464           break;
5465
5466           /* The following relocations don't need to propagate the
5467              relocation if linking a shared object since they are
5468              section relative.  */
5469         case R_PPC64_SECTOFF:
5470         case R_PPC64_SECTOFF_LO:
5471         case R_PPC64_SECTOFF_HI:
5472         case R_PPC64_SECTOFF_HA:
5473         case R_PPC64_SECTOFF_DS:
5474         case R_PPC64_SECTOFF_LO_DS:
5475         case R_PPC64_DTPREL16:
5476         case R_PPC64_DTPREL16_LO:
5477         case R_PPC64_DTPREL16_HI:
5478         case R_PPC64_DTPREL16_HA:
5479         case R_PPC64_DTPREL16_DS:
5480         case R_PPC64_DTPREL16_LO_DS:
5481         case R_PPC64_DTPREL16_HIGH:
5482         case R_PPC64_DTPREL16_HIGHA:
5483         case R_PPC64_DTPREL16_HIGHER:
5484         case R_PPC64_DTPREL16_HIGHERA:
5485         case R_PPC64_DTPREL16_HIGHEST:
5486         case R_PPC64_DTPREL16_HIGHESTA:
5487           break;
5488
5489           /* Nor do these.  */
5490         case R_PPC64_REL16:
5491         case R_PPC64_REL16_LO:
5492         case R_PPC64_REL16_HI:
5493         case R_PPC64_REL16_HA:
5494           break;
5495
5496           /* Not supported as a dynamic relocation.  */
5497         case R_PPC64_ADDR64_LOCAL:
5498           if (info->shared)
5499             {
5500               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5501                 ppc_howto_init ();
5502               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5503                                         "in shared libraries and PIEs.\n"),
5504                                       abfd, sec, rel->r_offset,
5505                                       ppc64_elf_howto_table[r_type]->name);
5506               bfd_set_error (bfd_error_bad_value);
5507               return FALSE;
5508             }
5509           break;
5510
5511         case R_PPC64_TOC16:
5512         case R_PPC64_TOC16_DS:
5513           htab->do_multi_toc = 1;
5514           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5515         case R_PPC64_TOC16_LO:
5516         case R_PPC64_TOC16_HI:
5517         case R_PPC64_TOC16_HA:
5518         case R_PPC64_TOC16_LO_DS:
5519           sec->has_toc_reloc = 1;
5520           break;
5521
5522           /* This relocation describes the C++ object vtable hierarchy.
5523              Reconstruct it for later use during GC.  */
5524         case R_PPC64_GNU_VTINHERIT:
5525           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5526             return FALSE;
5527           break;
5528
5529           /* This relocation describes which C++ vtable entries are actually
5530              used.  Record for later use during GC.  */
5531         case R_PPC64_GNU_VTENTRY:
5532           BFD_ASSERT (h != NULL);
5533           if (h != NULL
5534               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5535             return FALSE;
5536           break;
5537
5538         case R_PPC64_REL14:
5539         case R_PPC64_REL14_BRTAKEN:
5540         case R_PPC64_REL14_BRNTAKEN:
5541           {
5542             asection *dest = NULL;
5543
5544             /* Heuristic: If jumping outside our section, chances are
5545                we are going to need a stub.  */
5546             if (h != NULL)
5547               {
5548                 /* If the sym is weak it may be overridden later, so
5549                    don't assume we know where a weak sym lives.  */
5550                 if (h->root.type == bfd_link_hash_defined)
5551                   dest = h->root.u.def.section;
5552               }
5553             else
5554               {
5555                 Elf_Internal_Sym *isym;
5556
5557                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5558                                               abfd, r_symndx);
5559                 if (isym == NULL)
5560                   return FALSE;
5561
5562                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5563               }
5564
5565             if (dest != sec)
5566               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5567           }
5568           /* Fall through.  */
5569
5570         case R_PPC64_REL24:
5571           if (h != NULL && ifunc == NULL)
5572             {
5573               /* We may need a .plt entry if the function this reloc
5574                  refers to is in a shared lib.  */
5575               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5576                 return FALSE;
5577               h->needs_plt = 1;
5578               if (h->root.root.string[0] == '.'
5579                   && h->root.root.string[1] != '\0')
5580                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5581               if (h == tga || h == dottga)
5582                 sec->has_tls_reloc = 1;
5583             }
5584           break;
5585
5586         case R_PPC64_TPREL64:
5587           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5588           if (info->shared)
5589             info->flags |= DF_STATIC_TLS;
5590           goto dotlstoc;
5591
5592         case R_PPC64_DTPMOD64:
5593           if (rel + 1 < rel_end
5594               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5595               && rel[1].r_offset == rel->r_offset + 8)
5596             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5597           else
5598             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5599           goto dotlstoc;
5600
5601         case R_PPC64_DTPREL64:
5602           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5603           if (rel != relocs
5604               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5605               && rel[-1].r_offset == rel->r_offset - 8)
5606             /* This is the second reloc of a dtpmod, dtprel pair.
5607                Don't mark with TLS_DTPREL.  */
5608             goto dodyn;
5609
5610         dotlstoc:
5611           sec->has_tls_reloc = 1;
5612           if (h != NULL)
5613             {
5614               struct ppc_link_hash_entry *eh;
5615               eh = (struct ppc_link_hash_entry *) h;
5616               eh->tls_mask |= tls_type;
5617             }
5618           else
5619             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5620                                         rel->r_addend, tls_type))
5621               return FALSE;
5622
5623           ppc64_sec = ppc64_elf_section_data (sec);
5624           if (ppc64_sec->sec_type != sec_toc)
5625             {
5626               bfd_size_type amt;
5627
5628               /* One extra to simplify get_tls_mask.  */
5629               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5630               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5631               if (ppc64_sec->u.toc.symndx == NULL)
5632                 return FALSE;
5633               amt = sec->size * sizeof (bfd_vma) / 8;
5634               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5635               if (ppc64_sec->u.toc.add == NULL)
5636                 return FALSE;
5637               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5638               ppc64_sec->sec_type = sec_toc;
5639             }
5640           BFD_ASSERT (rel->r_offset % 8 == 0);
5641           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5642           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5643
5644           /* Mark the second slot of a GD or LD entry.
5645              -1 to indicate GD and -2 to indicate LD.  */
5646           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5647             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5648           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5649             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5650           goto dodyn;
5651
5652         case R_PPC64_TPREL16:
5653         case R_PPC64_TPREL16_LO:
5654         case R_PPC64_TPREL16_HI:
5655         case R_PPC64_TPREL16_HA:
5656         case R_PPC64_TPREL16_DS:
5657         case R_PPC64_TPREL16_LO_DS:
5658         case R_PPC64_TPREL16_HIGH:
5659         case R_PPC64_TPREL16_HIGHA:
5660         case R_PPC64_TPREL16_HIGHER:
5661         case R_PPC64_TPREL16_HIGHERA:
5662         case R_PPC64_TPREL16_HIGHEST:
5663         case R_PPC64_TPREL16_HIGHESTA:
5664           if (info->shared)
5665             {
5666               info->flags |= DF_STATIC_TLS;
5667               goto dodyn;
5668             }
5669           break;
5670
5671         case R_PPC64_ADDR64:
5672           if (opd_sym_map != NULL
5673               && rel + 1 < rel_end
5674               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5675             {
5676               if (h != NULL)
5677                 {
5678                   if (h->root.root.string[0] == '.'
5679                       && h->root.root.string[1] != 0
5680                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5681                     ;
5682                   else
5683                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5684                 }
5685               else
5686                 {
5687                   asection *s;
5688                   Elf_Internal_Sym *isym;
5689
5690                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5691                                                 abfd, r_symndx);
5692                   if (isym == NULL)
5693                     return FALSE;
5694
5695                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5696                   if (s != NULL && s != sec)
5697                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5698                 }
5699             }
5700           /* Fall through.  */
5701
5702         case R_PPC64_ADDR16:
5703         case R_PPC64_ADDR16_DS:
5704         case R_PPC64_ADDR16_HA:
5705         case R_PPC64_ADDR16_HI:
5706         case R_PPC64_ADDR16_HIGH:
5707         case R_PPC64_ADDR16_HIGHA:
5708         case R_PPC64_ADDR16_HIGHER:
5709         case R_PPC64_ADDR16_HIGHERA:
5710         case R_PPC64_ADDR16_HIGHEST:
5711         case R_PPC64_ADDR16_HIGHESTA:
5712         case R_PPC64_ADDR16_LO:
5713         case R_PPC64_ADDR16_LO_DS:
5714           if (h != NULL && !info->shared && abiversion (abfd) != 1
5715               && rel->r_addend == 0)
5716             {
5717               /* We may need a .plt entry if this reloc refers to a
5718                  function in a shared lib.  */
5719               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5720                 return FALSE;
5721               h->pointer_equality_needed = 1;
5722             }
5723           /* Fall through.  */
5724
5725         case R_PPC64_REL30:
5726         case R_PPC64_REL32:
5727         case R_PPC64_REL64:
5728         case R_PPC64_ADDR14:
5729         case R_PPC64_ADDR14_BRNTAKEN:
5730         case R_PPC64_ADDR14_BRTAKEN:
5731         case R_PPC64_ADDR24:
5732         case R_PPC64_ADDR32:
5733         case R_PPC64_UADDR16:
5734         case R_PPC64_UADDR32:
5735         case R_PPC64_UADDR64:
5736         case R_PPC64_TOC:
5737           if (h != NULL && !info->shared)
5738             /* We may need a copy reloc.  */
5739             h->non_got_ref = 1;
5740
5741           /* Don't propagate .opd relocs.  */
5742           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5743             break;
5744
5745           /* If we are creating a shared library, and this is a reloc
5746              against a global symbol, or a non PC relative reloc
5747              against a local symbol, then we need to copy the reloc
5748              into the shared library.  However, if we are linking with
5749              -Bsymbolic, we do not need to copy a reloc against a
5750              global symbol which is defined in an object we are
5751              including in the link (i.e., DEF_REGULAR is set).  At
5752              this point we have not seen all the input files, so it is
5753              possible that DEF_REGULAR is not set now but will be set
5754              later (it is never cleared).  In case of a weak definition,
5755              DEF_REGULAR may be cleared later by a strong definition in
5756              a shared library.  We account for that possibility below by
5757              storing information in the dyn_relocs field of the hash
5758              table entry.  A similar situation occurs when creating
5759              shared libraries and symbol visibility changes render the
5760              symbol local.
5761
5762              If on the other hand, we are creating an executable, we
5763              may need to keep relocations for symbols satisfied by a
5764              dynamic library if we manage to avoid copy relocs for the
5765              symbol.  */
5766         dodyn:
5767           if ((info->shared
5768                && (must_be_dyn_reloc (info, r_type)
5769                    || (h != NULL
5770                        && (!SYMBOLIC_BIND (info, h)
5771                            || h->root.type == bfd_link_hash_defweak
5772                            || !h->def_regular))))
5773               || (ELIMINATE_COPY_RELOCS
5774                   && !info->shared
5775                   && h != NULL
5776                   && (h->root.type == bfd_link_hash_defweak
5777                       || !h->def_regular))
5778               || (!info->shared
5779                   && ifunc != NULL))
5780             {
5781               /* We must copy these reloc types into the output file.
5782                  Create a reloc section in dynobj and make room for
5783                  this reloc.  */
5784               if (sreloc == NULL)
5785                 {
5786                   sreloc = _bfd_elf_make_dynamic_reloc_section
5787                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5788
5789                   if (sreloc == NULL)
5790                     return FALSE;
5791                 }
5792
5793               /* If this is a global symbol, we count the number of
5794                  relocations we need for this symbol.  */
5795               if (h != NULL)
5796                 {
5797                   struct elf_dyn_relocs *p;
5798                   struct elf_dyn_relocs **head;
5799
5800                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5801                   p = *head;
5802                   if (p == NULL || p->sec != sec)
5803                     {
5804                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5805                       if (p == NULL)
5806                         return FALSE;
5807                       p->next = *head;
5808                       *head = p;
5809                       p->sec = sec;
5810                       p->count = 0;
5811                       p->pc_count = 0;
5812                     }
5813                   p->count += 1;
5814                   if (!must_be_dyn_reloc (info, r_type))
5815                     p->pc_count += 1;
5816                 }
5817               else
5818                 {
5819                   /* Track dynamic relocs needed for local syms too.
5820                      We really need local syms available to do this
5821                      easily.  Oh well.  */
5822                   struct ppc_dyn_relocs *p;
5823                   struct ppc_dyn_relocs **head;
5824                   bfd_boolean is_ifunc;
5825                   asection *s;
5826                   void *vpp;
5827                   Elf_Internal_Sym *isym;
5828
5829                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5830                                                 abfd, r_symndx);
5831                   if (isym == NULL)
5832                     return FALSE;
5833
5834                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5835                   if (s == NULL)
5836                     s = sec;
5837
5838                   vpp = &elf_section_data (s)->local_dynrel;
5839                   head = (struct ppc_dyn_relocs **) vpp;
5840                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5841                   p = *head;
5842                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5843                     p = p->next;
5844                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5845                     {
5846                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5847                       if (p == NULL)
5848                         return FALSE;
5849                       p->next = *head;
5850                       *head = p;
5851                       p->sec = sec;
5852                       p->ifunc = is_ifunc;
5853                       p->count = 0;
5854                     }
5855                   p->count += 1;
5856                 }
5857             }
5858           break;
5859
5860         default:
5861           break;
5862         }
5863     }
5864
5865   return TRUE;
5866 }
5867
5868 /* Merge backend specific data from an object file to the output
5869    object file when linking.  */
5870
5871 static bfd_boolean
5872 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5873 {
5874   unsigned long iflags, oflags;
5875
5876   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5877     return TRUE;
5878
5879   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5880     return TRUE;
5881
5882   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5883     return FALSE;
5884
5885   iflags = elf_elfheader (ibfd)->e_flags;
5886   oflags = elf_elfheader (obfd)->e_flags;
5887
5888   if (iflags & ~EF_PPC64_ABI)
5889     {
5890       (*_bfd_error_handler)
5891         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5892       bfd_set_error (bfd_error_bad_value);
5893       return FALSE;
5894     }
5895   else if (iflags != oflags && iflags != 0)
5896     {
5897       (*_bfd_error_handler)
5898         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5899          ibfd, iflags, oflags);
5900       bfd_set_error (bfd_error_bad_value);
5901       return FALSE;
5902     }
5903
5904   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5905   _bfd_elf_merge_object_attributes (ibfd, obfd);
5906
5907   return TRUE;
5908 }
5909
5910 static bfd_boolean
5911 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5912 {
5913   /* Print normal ELF private data.  */
5914   _bfd_elf_print_private_bfd_data (abfd, ptr);
5915
5916   if (elf_elfheader (abfd)->e_flags != 0)
5917     {
5918       FILE *file = ptr;
5919
5920       /* xgettext:c-format */
5921       fprintf (file, _("private flags = 0x%lx:"),
5922                elf_elfheader (abfd)->e_flags);
5923
5924       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5925         fprintf (file, _(" [abiv%ld]"),
5926                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5927       fputc ('\n', file);
5928     }
5929
5930   return TRUE;
5931 }
5932
5933 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5934    of the code entry point, and its section, which must be in the same
5935    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
5936
5937 static bfd_vma
5938 opd_entry_value (asection *opd_sec,
5939                  bfd_vma offset,
5940                  asection **code_sec,
5941                  bfd_vma *code_off,
5942                  bfd_boolean in_code_sec)
5943 {
5944   bfd *opd_bfd = opd_sec->owner;
5945   Elf_Internal_Rela *relocs;
5946   Elf_Internal_Rela *lo, *hi, *look;
5947   bfd_vma val;
5948
5949   /* No relocs implies we are linking a --just-symbols object, or looking
5950      at a final linked executable with addr2line or somesuch.  */
5951   if (opd_sec->reloc_count == 0)
5952     {
5953       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5954
5955       if (contents == NULL)
5956         {
5957           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5958             return (bfd_vma) -1;
5959           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5960         }
5961
5962       /* PR 17512: file: 64b9dfbb.  */
5963       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
5964         return (bfd_vma) -1;
5965
5966       val = bfd_get_64 (opd_bfd, contents + offset);
5967       if (code_sec != NULL)
5968         {
5969           asection *sec, *likely = NULL;
5970
5971           if (in_code_sec)
5972             {
5973               sec = *code_sec;
5974               if (sec->vma <= val
5975                   && val < sec->vma + sec->size)
5976                 likely = sec;
5977               else
5978                 val = -1;
5979             }
5980           else
5981             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5982               if (sec->vma <= val
5983                   && (sec->flags & SEC_LOAD) != 0
5984                   && (sec->flags & SEC_ALLOC) != 0)
5985                 likely = sec;
5986           if (likely != NULL)
5987             {
5988               *code_sec = likely;
5989               if (code_off != NULL)
5990                 *code_off = val - likely->vma;
5991             }
5992         }
5993       return val;
5994     }
5995
5996   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5997
5998   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5999   if (relocs == NULL)
6000     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6001   /* PR 17512: file: df8e1fd6.  */
6002   if (relocs == NULL)
6003     return (bfd_vma) -1;
6004
6005   /* Go find the opd reloc at the sym address.  */
6006   lo = relocs;
6007   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6008   val = (bfd_vma) -1;
6009   while (lo < hi)
6010     {
6011       look = lo + (hi - lo) / 2;
6012       if (look->r_offset < offset)
6013         lo = look + 1;
6014       else if (look->r_offset > offset)
6015         hi = look;
6016       else
6017         {
6018           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6019
6020           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6021               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6022             {
6023               unsigned long symndx = ELF64_R_SYM (look->r_info);
6024               asection *sec = NULL;
6025
6026               if (symndx >= symtab_hdr->sh_info
6027                   && elf_sym_hashes (opd_bfd) != NULL)
6028                 {
6029                   struct elf_link_hash_entry **sym_hashes;
6030                   struct elf_link_hash_entry *rh;
6031
6032                   sym_hashes = elf_sym_hashes (opd_bfd);
6033                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6034                   if (rh != NULL)
6035                     {
6036                       rh = elf_follow_link (rh);
6037                       if (rh->root.type != bfd_link_hash_defined
6038                           && rh->root.type != bfd_link_hash_defweak)
6039                         break;
6040                       if (rh->root.u.def.section->owner == opd_bfd)
6041                         {
6042                           val = rh->root.u.def.value;
6043                           sec = rh->root.u.def.section;
6044                         }
6045                     }
6046                 }
6047
6048               if (sec == NULL)
6049                 {
6050                   Elf_Internal_Sym *sym;
6051
6052                   if (symndx < symtab_hdr->sh_info)
6053                     {
6054                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6055                       if (sym == NULL)
6056                         {
6057                           size_t symcnt = symtab_hdr->sh_info;
6058                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6059                                                       symcnt, 0,
6060                                                       NULL, NULL, NULL);
6061                           if (sym == NULL)
6062                             break;
6063                           symtab_hdr->contents = (bfd_byte *) sym;
6064                         }
6065                       sym += symndx;
6066                     }
6067                   else
6068                     {
6069                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6070                                                   1, symndx,
6071                                                   NULL, NULL, NULL);
6072                       if (sym == NULL)
6073                         break;
6074                     }
6075                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6076                   if (sec == NULL)
6077                     break;
6078                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6079                   val = sym->st_value;
6080                 }
6081
6082               val += look->r_addend;
6083               if (code_off != NULL)
6084                 *code_off = val;
6085               if (code_sec != NULL)
6086                 {
6087                   if (in_code_sec && *code_sec != sec)
6088                     return -1;
6089                   else
6090                     *code_sec = sec;
6091                 }
6092               if (sec->output_section != NULL)
6093                 val += sec->output_section->vma + sec->output_offset;
6094             }
6095           break;
6096         }
6097     }
6098
6099   return val;
6100 }
6101
6102 /* If the ELF symbol SYM might be a function in SEC, return the
6103    function size and set *CODE_OFF to the function's entry point,
6104    otherwise return zero.  */
6105
6106 static bfd_size_type
6107 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6108                               bfd_vma *code_off)
6109 {
6110   bfd_size_type size;
6111
6112   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6113                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6114     return 0;
6115
6116   size = 0;
6117   if (!(sym->flags & BSF_SYNTHETIC))
6118     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6119
6120   if (strcmp (sym->section->name, ".opd") == 0)
6121     {
6122       if (opd_entry_value (sym->section, sym->value,
6123                            &sec, code_off, TRUE) == (bfd_vma) -1)
6124         return 0;
6125       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6126          symbol.  This size has nothing to do with the code size of the
6127          function, which is what we're supposed to return, but the
6128          code size isn't available without looking up the dot-sym.
6129          However, doing that would be a waste of time particularly
6130          since elf_find_function will look at the dot-sym anyway.
6131          Now, elf_find_function will keep the largest size of any
6132          function sym found at the code address of interest, so return
6133          1 here to avoid it incorrectly caching a larger function size
6134          for a small function.  This does mean we return the wrong
6135          size for a new-ABI function of size 24, but all that does is
6136          disable caching for such functions.  */
6137       if (size == 24)
6138         size = 1;
6139     }
6140   else
6141     {
6142       if (sym->section != sec)
6143         return 0;
6144       *code_off = sym->value;
6145     }
6146   if (size == 0)
6147     size = 1;
6148   return size;
6149 }
6150
6151 /* Return true if symbol is defined in a regular object file.  */
6152
6153 static bfd_boolean
6154 is_static_defined (struct elf_link_hash_entry *h)
6155 {
6156   return ((h->root.type == bfd_link_hash_defined
6157            || h->root.type == bfd_link_hash_defweak)
6158           && h->root.u.def.section != NULL
6159           && h->root.u.def.section->output_section != NULL);
6160 }
6161
6162 /* If FDH is a function descriptor symbol, return the associated code
6163    entry symbol if it is defined.  Return NULL otherwise.  */
6164
6165 static struct ppc_link_hash_entry *
6166 defined_code_entry (struct ppc_link_hash_entry *fdh)
6167 {
6168   if (fdh->is_func_descriptor)
6169     {
6170       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6171       if (fh->elf.root.type == bfd_link_hash_defined
6172           || fh->elf.root.type == bfd_link_hash_defweak)
6173         return fh;
6174     }
6175   return NULL;
6176 }
6177
6178 /* If FH is a function code entry symbol, return the associated
6179    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6180
6181 static struct ppc_link_hash_entry *
6182 defined_func_desc (struct ppc_link_hash_entry *fh)
6183 {
6184   if (fh->oh != NULL
6185       && fh->oh->is_func_descriptor)
6186     {
6187       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6188       if (fdh->elf.root.type == bfd_link_hash_defined
6189           || fdh->elf.root.type == bfd_link_hash_defweak)
6190         return fdh;
6191     }
6192   return NULL;
6193 }
6194
6195 /* Mark all our entry sym sections, both opd and code section.  */
6196
6197 static void
6198 ppc64_elf_gc_keep (struct bfd_link_info *info)
6199 {
6200   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6201   struct bfd_sym_chain *sym;
6202
6203   if (htab == NULL)
6204     return;
6205
6206   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6207     {
6208       struct ppc_link_hash_entry *eh, *fh;
6209       asection *sec;
6210
6211       eh = (struct ppc_link_hash_entry *)
6212         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6213       if (eh == NULL)
6214         continue;
6215       if (eh->elf.root.type != bfd_link_hash_defined
6216           && eh->elf.root.type != bfd_link_hash_defweak)
6217         continue;
6218
6219       fh = defined_code_entry (eh);
6220       if (fh != NULL)
6221         {
6222           sec = fh->elf.root.u.def.section;
6223           sec->flags |= SEC_KEEP;
6224         }
6225       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6226                && opd_entry_value (eh->elf.root.u.def.section,
6227                                    eh->elf.root.u.def.value,
6228                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6229         sec->flags |= SEC_KEEP;
6230
6231       sec = eh->elf.root.u.def.section;
6232       sec->flags |= SEC_KEEP;
6233     }
6234 }
6235
6236 /* Mark sections containing dynamically referenced symbols.  When
6237    building shared libraries, we must assume that any visible symbol is
6238    referenced.  */
6239
6240 static bfd_boolean
6241 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6242 {
6243   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6244   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6245   struct ppc_link_hash_entry *fdh;
6246   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6247
6248   /* Dynamic linking info is on the func descriptor sym.  */
6249   fdh = defined_func_desc (eh);
6250   if (fdh != NULL)
6251     eh = fdh;
6252
6253   if ((eh->elf.root.type == bfd_link_hash_defined
6254        || eh->elf.root.type == bfd_link_hash_defweak)
6255       && (eh->elf.ref_dynamic
6256           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6257               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6258               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6259               && (!info->executable
6260                   || info->export_dynamic
6261                   || (eh->elf.dynamic
6262                       && d != NULL
6263                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6264               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6265                   || !bfd_hide_sym_by_version (info->version_info,
6266                                                eh->elf.root.root.string)))))
6267     {
6268       asection *code_sec;
6269       struct ppc_link_hash_entry *fh;
6270
6271       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6272
6273       /* Function descriptor syms cause the associated
6274          function code sym section to be marked.  */
6275       fh = defined_code_entry (eh);
6276       if (fh != NULL)
6277         {
6278           code_sec = fh->elf.root.u.def.section;
6279           code_sec->flags |= SEC_KEEP;
6280         }
6281       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6282                && opd_entry_value (eh->elf.root.u.def.section,
6283                                    eh->elf.root.u.def.value,
6284                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6285         code_sec->flags |= SEC_KEEP;
6286     }
6287
6288   return TRUE;
6289 }
6290
6291 /* Return the section that should be marked against GC for a given
6292    relocation.  */
6293
6294 static asection *
6295 ppc64_elf_gc_mark_hook (asection *sec,
6296                         struct bfd_link_info *info,
6297                         Elf_Internal_Rela *rel,
6298                         struct elf_link_hash_entry *h,
6299                         Elf_Internal_Sym *sym)
6300 {
6301   asection *rsec;
6302
6303   /* Syms return NULL if we're marking .opd, so we avoid marking all
6304      function sections, as all functions are referenced in .opd.  */
6305   rsec = NULL;
6306   if (get_opd_info (sec) != NULL)
6307     return rsec;
6308
6309   if (h != NULL)
6310     {
6311       enum elf_ppc64_reloc_type r_type;
6312       struct ppc_link_hash_entry *eh, *fh, *fdh;
6313
6314       r_type = ELF64_R_TYPE (rel->r_info);
6315       switch (r_type)
6316         {
6317         case R_PPC64_GNU_VTINHERIT:
6318         case R_PPC64_GNU_VTENTRY:
6319           break;
6320
6321         default:
6322           switch (h->root.type)
6323             {
6324             case bfd_link_hash_defined:
6325             case bfd_link_hash_defweak:
6326               eh = (struct ppc_link_hash_entry *) h;
6327               fdh = defined_func_desc (eh);
6328               if (fdh != NULL)
6329                 eh = fdh;
6330
6331               /* Function descriptor syms cause the associated
6332                  function code sym section to be marked.  */
6333               fh = defined_code_entry (eh);
6334               if (fh != NULL)
6335                 {
6336                   /* They also mark their opd section.  */
6337                   eh->elf.root.u.def.section->gc_mark = 1;
6338
6339                   rsec = fh->elf.root.u.def.section;
6340                 }
6341               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6342                        && opd_entry_value (eh->elf.root.u.def.section,
6343                                            eh->elf.root.u.def.value,
6344                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6345                 eh->elf.root.u.def.section->gc_mark = 1;
6346               else
6347                 rsec = h->root.u.def.section;
6348               break;
6349
6350             case bfd_link_hash_common:
6351               rsec = h->root.u.c.p->section;
6352               break;
6353
6354             default:
6355               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6356             }
6357         }
6358     }
6359   else
6360     {
6361       struct _opd_sec_data *opd;
6362
6363       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6364       opd = get_opd_info (rsec);
6365       if (opd != NULL && opd->func_sec != NULL)
6366         {
6367           rsec->gc_mark = 1;
6368
6369           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6370         }
6371     }
6372
6373   return rsec;
6374 }
6375
6376 /* Update the .got, .plt. and dynamic reloc reference counts for the
6377    section being removed.  */
6378
6379 static bfd_boolean
6380 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6381                          asection *sec, const Elf_Internal_Rela *relocs)
6382 {
6383   struct ppc_link_hash_table *htab;
6384   Elf_Internal_Shdr *symtab_hdr;
6385   struct elf_link_hash_entry **sym_hashes;
6386   struct got_entry **local_got_ents;
6387   const Elf_Internal_Rela *rel, *relend;
6388
6389   if (info->relocatable)
6390     return TRUE;
6391
6392   if ((sec->flags & SEC_ALLOC) == 0)
6393     return TRUE;
6394
6395   elf_section_data (sec)->local_dynrel = NULL;
6396
6397   htab = ppc_hash_table (info);
6398   if (htab == NULL)
6399     return FALSE;
6400
6401   symtab_hdr = &elf_symtab_hdr (abfd);
6402   sym_hashes = elf_sym_hashes (abfd);
6403   local_got_ents = elf_local_got_ents (abfd);
6404
6405   relend = relocs + sec->reloc_count;
6406   for (rel = relocs; rel < relend; rel++)
6407     {
6408       unsigned long r_symndx;
6409       enum elf_ppc64_reloc_type r_type;
6410       struct elf_link_hash_entry *h = NULL;
6411       unsigned char tls_type = 0;
6412
6413       r_symndx = ELF64_R_SYM (rel->r_info);
6414       r_type = ELF64_R_TYPE (rel->r_info);
6415       if (r_symndx >= symtab_hdr->sh_info)
6416         {
6417           struct ppc_link_hash_entry *eh;
6418           struct elf_dyn_relocs **pp;
6419           struct elf_dyn_relocs *p;
6420
6421           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6422           h = elf_follow_link (h);
6423           eh = (struct ppc_link_hash_entry *) h;
6424
6425           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6426             if (p->sec == sec)
6427               {
6428                 /* Everything must go for SEC.  */
6429                 *pp = p->next;
6430                 break;
6431               }
6432         }
6433
6434       if (is_branch_reloc (r_type))
6435         {
6436           struct plt_entry **ifunc = NULL;
6437           if (h != NULL)
6438             {
6439               if (h->type == STT_GNU_IFUNC)
6440                 ifunc = &h->plt.plist;
6441             }
6442           else if (local_got_ents != NULL)
6443             {
6444               struct plt_entry **local_plt = (struct plt_entry **)
6445                 (local_got_ents + symtab_hdr->sh_info);
6446               unsigned char *local_got_tls_masks = (unsigned char *)
6447                 (local_plt + symtab_hdr->sh_info);
6448               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6449                 ifunc = local_plt + r_symndx;
6450             }
6451           if (ifunc != NULL)
6452             {
6453               struct plt_entry *ent;
6454
6455               for (ent = *ifunc; ent != NULL; ent = ent->next)
6456                 if (ent->addend == rel->r_addend)
6457                   break;
6458               if (ent == NULL)
6459                 abort ();
6460               if (ent->plt.refcount > 0)
6461                 ent->plt.refcount -= 1;
6462               continue;
6463             }
6464         }
6465
6466       switch (r_type)
6467         {
6468         case R_PPC64_GOT_TLSLD16:
6469         case R_PPC64_GOT_TLSLD16_LO:
6470         case R_PPC64_GOT_TLSLD16_HI:
6471         case R_PPC64_GOT_TLSLD16_HA:
6472           tls_type = TLS_TLS | TLS_LD;
6473           goto dogot;
6474
6475         case R_PPC64_GOT_TLSGD16:
6476         case R_PPC64_GOT_TLSGD16_LO:
6477         case R_PPC64_GOT_TLSGD16_HI:
6478         case R_PPC64_GOT_TLSGD16_HA:
6479           tls_type = TLS_TLS | TLS_GD;
6480           goto dogot;
6481
6482         case R_PPC64_GOT_TPREL16_DS:
6483         case R_PPC64_GOT_TPREL16_LO_DS:
6484         case R_PPC64_GOT_TPREL16_HI:
6485         case R_PPC64_GOT_TPREL16_HA:
6486           tls_type = TLS_TLS | TLS_TPREL;
6487           goto dogot;
6488
6489         case R_PPC64_GOT_DTPREL16_DS:
6490         case R_PPC64_GOT_DTPREL16_LO_DS:
6491         case R_PPC64_GOT_DTPREL16_HI:
6492         case R_PPC64_GOT_DTPREL16_HA:
6493           tls_type = TLS_TLS | TLS_DTPREL;
6494           goto dogot;
6495
6496         case R_PPC64_GOT16:
6497         case R_PPC64_GOT16_DS:
6498         case R_PPC64_GOT16_HA:
6499         case R_PPC64_GOT16_HI:
6500         case R_PPC64_GOT16_LO:
6501         case R_PPC64_GOT16_LO_DS:
6502         dogot:
6503           {
6504             struct got_entry *ent;
6505
6506             if (h != NULL)
6507               ent = h->got.glist;
6508             else
6509               ent = local_got_ents[r_symndx];
6510
6511             for (; ent != NULL; ent = ent->next)
6512               if (ent->addend == rel->r_addend
6513                   && ent->owner == abfd
6514                   && ent->tls_type == tls_type)
6515                 break;
6516             if (ent == NULL)
6517               abort ();
6518             if (ent->got.refcount > 0)
6519               ent->got.refcount -= 1;
6520           }
6521           break;
6522
6523         case R_PPC64_PLT16_HA:
6524         case R_PPC64_PLT16_HI:
6525         case R_PPC64_PLT16_LO:
6526         case R_PPC64_PLT32:
6527         case R_PPC64_PLT64:
6528         case R_PPC64_REL14:
6529         case R_PPC64_REL14_BRNTAKEN:
6530         case R_PPC64_REL14_BRTAKEN:
6531         case R_PPC64_REL24:
6532           if (h != NULL)
6533             {
6534               struct plt_entry *ent;
6535
6536               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6537                 if (ent->addend == rel->r_addend)
6538                   break;
6539               if (ent != NULL && ent->plt.refcount > 0)
6540                 ent->plt.refcount -= 1;
6541             }
6542           break;
6543
6544         default:
6545           break;
6546         }
6547     }
6548   return TRUE;
6549 }
6550
6551 /* The maximum size of .sfpr.  */
6552 #define SFPR_MAX (218*4)
6553
6554 struct sfpr_def_parms
6555 {
6556   const char name[12];
6557   unsigned char lo, hi;
6558   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6559   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6560 };
6561
6562 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6563
6564 static bfd_boolean
6565 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6566 {
6567   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6568   unsigned int i;
6569   size_t len = strlen (parm->name);
6570   bfd_boolean writing = FALSE;
6571   char sym[16];
6572
6573   if (htab == NULL)
6574     return FALSE;
6575
6576   memcpy (sym, parm->name, len);
6577   sym[len + 2] = 0;
6578
6579   for (i = parm->lo; i <= parm->hi; i++)
6580     {
6581       struct elf_link_hash_entry *h;
6582
6583       sym[len + 0] = i / 10 + '0';
6584       sym[len + 1] = i % 10 + '0';
6585       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6586       if (h != NULL
6587           && !h->def_regular)
6588         {
6589           h->root.type = bfd_link_hash_defined;
6590           h->root.u.def.section = htab->sfpr;
6591           h->root.u.def.value = htab->sfpr->size;
6592           h->type = STT_FUNC;
6593           h->def_regular = 1;
6594           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6595           writing = TRUE;
6596           if (htab->sfpr->contents == NULL)
6597             {
6598               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6599               if (htab->sfpr->contents == NULL)
6600                 return FALSE;
6601             }
6602         }
6603       if (writing)
6604         {
6605           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6606           if (i != parm->hi)
6607             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6608           else
6609             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6610           htab->sfpr->size = p - htab->sfpr->contents;
6611         }
6612     }
6613
6614   return TRUE;
6615 }
6616
6617 static bfd_byte *
6618 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6619 {
6620   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6621   return p + 4;
6622 }
6623
6624 static bfd_byte *
6625 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6626 {
6627   p = savegpr0 (abfd, p, r);
6628   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6629   p = p + 4;
6630   bfd_put_32 (abfd, BLR, p);
6631   return p + 4;
6632 }
6633
6634 static bfd_byte *
6635 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6636 {
6637   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6638   return p + 4;
6639 }
6640
6641 static bfd_byte *
6642 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6643 {
6644   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6645   p = p + 4;
6646   p = restgpr0 (abfd, p, r);
6647   bfd_put_32 (abfd, MTLR_R0, p);
6648   p = p + 4;
6649   if (r == 29)
6650     {
6651       p = restgpr0 (abfd, p, 30);
6652       p = restgpr0 (abfd, p, 31);
6653     }
6654   bfd_put_32 (abfd, BLR, p);
6655   return p + 4;
6656 }
6657
6658 static bfd_byte *
6659 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6660 {
6661   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6662   return p + 4;
6663 }
6664
6665 static bfd_byte *
6666 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6667 {
6668   p = savegpr1 (abfd, p, r);
6669   bfd_put_32 (abfd, BLR, p);
6670   return p + 4;
6671 }
6672
6673 static bfd_byte *
6674 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6675 {
6676   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6677   return p + 4;
6678 }
6679
6680 static bfd_byte *
6681 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6682 {
6683   p = restgpr1 (abfd, p, r);
6684   bfd_put_32 (abfd, BLR, p);
6685   return p + 4;
6686 }
6687
6688 static bfd_byte *
6689 savefpr (bfd *abfd, bfd_byte *p, int r)
6690 {
6691   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6692   return p + 4;
6693 }
6694
6695 static bfd_byte *
6696 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6697 {
6698   p = savefpr (abfd, p, r);
6699   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6700   p = p + 4;
6701   bfd_put_32 (abfd, BLR, p);
6702   return p + 4;
6703 }
6704
6705 static bfd_byte *
6706 restfpr (bfd *abfd, bfd_byte *p, int r)
6707 {
6708   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6709   return p + 4;
6710 }
6711
6712 static bfd_byte *
6713 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6714 {
6715   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6716   p = p + 4;
6717   p = restfpr (abfd, p, r);
6718   bfd_put_32 (abfd, MTLR_R0, p);
6719   p = p + 4;
6720   if (r == 29)
6721     {
6722       p = restfpr (abfd, p, 30);
6723       p = restfpr (abfd, p, 31);
6724     }
6725   bfd_put_32 (abfd, BLR, p);
6726   return p + 4;
6727 }
6728
6729 static bfd_byte *
6730 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6731 {
6732   p = savefpr (abfd, p, r);
6733   bfd_put_32 (abfd, BLR, p);
6734   return p + 4;
6735 }
6736
6737 static bfd_byte *
6738 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6739 {
6740   p = restfpr (abfd, p, r);
6741   bfd_put_32 (abfd, BLR, p);
6742   return p + 4;
6743 }
6744
6745 static bfd_byte *
6746 savevr (bfd *abfd, bfd_byte *p, int r)
6747 {
6748   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6749   p = p + 4;
6750   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6751   return p + 4;
6752 }
6753
6754 static bfd_byte *
6755 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6756 {
6757   p = savevr (abfd, p, r);
6758   bfd_put_32 (abfd, BLR, p);
6759   return p + 4;
6760 }
6761
6762 static bfd_byte *
6763 restvr (bfd *abfd, bfd_byte *p, int r)
6764 {
6765   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6766   p = p + 4;
6767   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6768   return p + 4;
6769 }
6770
6771 static bfd_byte *
6772 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6773 {
6774   p = restvr (abfd, p, r);
6775   bfd_put_32 (abfd, BLR, p);
6776   return p + 4;
6777 }
6778
6779 /* Called via elf_link_hash_traverse to transfer dynamic linking
6780    information on function code symbol entries to their corresponding
6781    function descriptor symbol entries.  */
6782
6783 static bfd_boolean
6784 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6785 {
6786   struct bfd_link_info *info;
6787   struct ppc_link_hash_table *htab;
6788   struct plt_entry *ent;
6789   struct ppc_link_hash_entry *fh;
6790   struct ppc_link_hash_entry *fdh;
6791   bfd_boolean force_local;
6792
6793   fh = (struct ppc_link_hash_entry *) h;
6794   if (fh->elf.root.type == bfd_link_hash_indirect)
6795     return TRUE;
6796
6797   info = inf;
6798   htab = ppc_hash_table (info);
6799   if (htab == NULL)
6800     return FALSE;
6801
6802   /* Resolve undefined references to dot-symbols as the value
6803      in the function descriptor, if we have one in a regular object.
6804      This is to satisfy cases like ".quad .foo".  Calls to functions
6805      in dynamic objects are handled elsewhere.  */
6806   if (fh->elf.root.type == bfd_link_hash_undefweak
6807       && fh->was_undefined
6808       && (fdh = defined_func_desc (fh)) != NULL
6809       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6810       && opd_entry_value (fdh->elf.root.u.def.section,
6811                           fdh->elf.root.u.def.value,
6812                           &fh->elf.root.u.def.section,
6813                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6814     {
6815       fh->elf.root.type = fdh->elf.root.type;
6816       fh->elf.forced_local = 1;
6817       fh->elf.def_regular = fdh->elf.def_regular;
6818       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6819     }
6820
6821   /* If this is a function code symbol, transfer dynamic linking
6822      information to the function descriptor symbol.  */
6823   if (!fh->is_func)
6824     return TRUE;
6825
6826   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6827     if (ent->plt.refcount > 0)
6828       break;
6829   if (ent == NULL
6830       || fh->elf.root.root.string[0] != '.'
6831       || fh->elf.root.root.string[1] == '\0')
6832     return TRUE;
6833
6834   /* Find the corresponding function descriptor symbol.  Create it
6835      as undefined if necessary.  */
6836
6837   fdh = lookup_fdh (fh, htab);
6838   if (fdh == NULL
6839       && !info->executable
6840       && (fh->elf.root.type == bfd_link_hash_undefined
6841           || fh->elf.root.type == bfd_link_hash_undefweak))
6842     {
6843       fdh = make_fdh (info, fh);
6844       if (fdh == NULL)
6845         return FALSE;
6846     }
6847
6848   /* Fake function descriptors are made undefweak.  If the function
6849      code symbol is strong undefined, make the fake sym the same.
6850      If the function code symbol is defined, then force the fake
6851      descriptor local;  We can't support overriding of symbols in a
6852      shared library on a fake descriptor.  */
6853
6854   if (fdh != NULL
6855       && fdh->fake
6856       && fdh->elf.root.type == bfd_link_hash_undefweak)
6857     {
6858       if (fh->elf.root.type == bfd_link_hash_undefined)
6859         {
6860           fdh->elf.root.type = bfd_link_hash_undefined;
6861           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6862         }
6863       else if (fh->elf.root.type == bfd_link_hash_defined
6864                || fh->elf.root.type == bfd_link_hash_defweak)
6865         {
6866           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6867         }
6868     }
6869
6870   if (fdh != NULL
6871       && !fdh->elf.forced_local
6872       && (!info->executable
6873           || fdh->elf.def_dynamic
6874           || fdh->elf.ref_dynamic
6875           || (fdh->elf.root.type == bfd_link_hash_undefweak
6876               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6877     {
6878       if (fdh->elf.dynindx == -1)
6879         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6880           return FALSE;
6881       fdh->elf.ref_regular |= fh->elf.ref_regular;
6882       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6883       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6884       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6885       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6886         {
6887           move_plt_plist (fh, fdh);
6888           fdh->elf.needs_plt = 1;
6889         }
6890       fdh->is_func_descriptor = 1;
6891       fdh->oh = fh;
6892       fh->oh = fdh;
6893     }
6894
6895   /* Now that the info is on the function descriptor, clear the
6896      function code sym info.  Any function code syms for which we
6897      don't have a definition in a regular file, we force local.
6898      This prevents a shared library from exporting syms that have
6899      been imported from another library.  Function code syms that
6900      are really in the library we must leave global to prevent the
6901      linker dragging in a definition from a static library.  */
6902   force_local = (!fh->elf.def_regular
6903                  || fdh == NULL
6904                  || !fdh->elf.def_regular
6905                  || fdh->elf.forced_local);
6906   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6907
6908   return TRUE;
6909 }
6910
6911 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6912    this hook to a) provide some gcc support functions, and b) transfer
6913    dynamic linking information gathered so far on function code symbol
6914    entries, to their corresponding function descriptor symbol entries.  */
6915
6916 static bfd_boolean
6917 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6918                             struct bfd_link_info *info)
6919 {
6920   struct ppc_link_hash_table *htab;
6921   unsigned int i;
6922   static const struct sfpr_def_parms funcs[] =
6923     {
6924       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6925       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6926       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6927       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6928       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6929       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6930       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6931       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6932       { "._savef", 14, 31, savefpr, savefpr1_tail },
6933       { "._restf", 14, 31, restfpr, restfpr1_tail },
6934       { "_savevr_", 20, 31, savevr, savevr_tail },
6935       { "_restvr_", 20, 31, restvr, restvr_tail }
6936     };
6937
6938   htab = ppc_hash_table (info);
6939   if (htab == NULL)
6940     return FALSE;
6941
6942   if (!info->relocatable
6943       && htab->elf.hgot != NULL)
6944     {
6945       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6946       /* Make .TOC. defined so as to prevent it being made dynamic.
6947          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6948       htab->elf.hgot->type = STT_OBJECT;
6949       htab->elf.hgot->root.type = bfd_link_hash_defined;
6950       htab->elf.hgot->root.u.def.value = 0;
6951       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6952       htab->elf.hgot->def_regular = 1;
6953       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6954                                | STV_HIDDEN);
6955     }
6956
6957   if (htab->sfpr == NULL)
6958     /* We don't have any relocs.  */
6959     return TRUE;
6960
6961   /* Provide any missing _save* and _rest* functions.  */
6962   htab->sfpr->size = 0;
6963   if (htab->params->save_restore_funcs)
6964     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6965       if (!sfpr_define (info, &funcs[i]))
6966         return FALSE;
6967
6968   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6969
6970   if (htab->sfpr->size == 0)
6971     htab->sfpr->flags |= SEC_EXCLUDE;
6972
6973   return TRUE;
6974 }
6975
6976 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6977
6978 static bfd_boolean
6979 readonly_dynrelocs (struct elf_link_hash_entry *h)
6980 {
6981   struct ppc_link_hash_entry *eh;
6982   struct elf_dyn_relocs *p;
6983
6984   eh = (struct ppc_link_hash_entry *) h;
6985   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6986     {
6987       asection *s = p->sec->output_section;
6988
6989       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6990         return TRUE;
6991     }
6992   return FALSE;
6993 }
6994
6995 /* Adjust a symbol defined by a dynamic object and referenced by a
6996    regular object.  The current definition is in some section of the
6997    dynamic object, but we're not including those sections.  We have to
6998    change the definition to something the rest of the link can
6999    understand.  */
7000
7001 static bfd_boolean
7002 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7003                                  struct elf_link_hash_entry *h)
7004 {
7005   struct ppc_link_hash_table *htab;
7006   asection *s;
7007
7008   htab = ppc_hash_table (info);
7009   if (htab == NULL)
7010     return FALSE;
7011
7012   /* Deal with function syms.  */
7013   if (h->type == STT_FUNC
7014       || h->type == STT_GNU_IFUNC
7015       || h->needs_plt)
7016     {
7017       /* Clear procedure linkage table information for any symbol that
7018          won't need a .plt entry.  */
7019       struct plt_entry *ent;
7020       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7021         if (ent->plt.refcount > 0)
7022           break;
7023       if (ent == NULL
7024           || (h->type != STT_GNU_IFUNC
7025               && (SYMBOL_CALLS_LOCAL (info, h)
7026                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7027                       && h->root.type == bfd_link_hash_undefweak))))
7028         {
7029           h->plt.plist = NULL;
7030           h->needs_plt = 0;
7031           h->pointer_equality_needed = 0;
7032         }
7033       else if (abiversion (info->output_bfd) == 2)
7034         {
7035           /* Taking a function's address in a read/write section
7036              doesn't require us to define the function symbol in the
7037              executable on a global entry stub.  A dynamic reloc can
7038              be used instead.  */
7039           if (h->pointer_equality_needed
7040               && h->type != STT_GNU_IFUNC
7041               && !readonly_dynrelocs (h))
7042             {
7043               h->pointer_equality_needed = 0;
7044               h->non_got_ref = 0;
7045             }
7046
7047           /* After adjust_dynamic_symbol, non_got_ref set in the
7048              non-shared case means that we have allocated space in
7049              .dynbss for the symbol and thus dyn_relocs for this
7050              symbol should be discarded.
7051              If we get here we know we are making a PLT entry for this
7052              symbol, and in an executable we'd normally resolve
7053              relocations against this symbol to the PLT entry.  Allow
7054              dynamic relocs if the reference is weak, and the dynamic
7055              relocs will not cause text relocation.  */
7056           else if (!h->ref_regular_nonweak
7057                    && h->non_got_ref
7058                    && h->type != STT_GNU_IFUNC
7059                    && !readonly_dynrelocs (h))
7060             h->non_got_ref = 0;
7061
7062           /* If making a plt entry, then we don't need copy relocs.  */
7063           return TRUE;
7064         }
7065     }
7066   else
7067     h->plt.plist = NULL;
7068
7069   /* If this is a weak symbol, and there is a real definition, the
7070      processor independent code will have arranged for us to see the
7071      real definition first, and we can just use the same value.  */
7072   if (h->u.weakdef != NULL)
7073     {
7074       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7075                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7076       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7077       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7078       if (ELIMINATE_COPY_RELOCS)
7079         h->non_got_ref = h->u.weakdef->non_got_ref;
7080       return TRUE;
7081     }
7082
7083   /* If we are creating a shared library, we must presume that the
7084      only references to the symbol are via the global offset table.
7085      For such cases we need not do anything here; the relocations will
7086      be handled correctly by relocate_section.  */
7087   if (info->shared)
7088     return TRUE;
7089
7090   /* If there are no references to this symbol that do not use the
7091      GOT, we don't need to generate a copy reloc.  */
7092   if (!h->non_got_ref)
7093     return TRUE;
7094
7095   /* Don't generate a copy reloc for symbols defined in the executable.  */
7096   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7097     return TRUE;
7098
7099   /* If -z nocopyreloc was given, don't generate them either.  */
7100   if (info->nocopyreloc)
7101     {
7102       h->non_got_ref = 0;
7103       return TRUE;
7104     }
7105
7106   /* If we didn't find any dynamic relocs in read-only sections, then
7107      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7108   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7109     {
7110       h->non_got_ref = 0;
7111       return TRUE;
7112     }
7113
7114   /* Protected variables do not work with .dynbss.  The copy in
7115      .dynbss won't be used by the shared library with the protected
7116      definition for the variable.  Text relocations are preferable
7117      to an incorrect program.  */
7118   if (h->protected_def)
7119     {
7120       h->non_got_ref = 0;
7121       return TRUE;
7122     }
7123
7124   if (h->plt.plist != NULL)
7125     {
7126       /* We should never get here, but unfortunately there are versions
7127          of gcc out there that improperly (for this ABI) put initialized
7128          function pointers, vtable refs and suchlike in read-only
7129          sections.  Allow them to proceed, but warn that this might
7130          break at runtime.  */
7131       info->callbacks->einfo
7132         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7133            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7134          h->root.root.string);
7135     }
7136
7137   /* This is a reference to a symbol defined by a dynamic object which
7138      is not a function.  */
7139
7140   /* We must allocate the symbol in our .dynbss section, which will
7141      become part of the .bss section of the executable.  There will be
7142      an entry for this symbol in the .dynsym section.  The dynamic
7143      object will contain position independent code, so all references
7144      from the dynamic object to this symbol will go through the global
7145      offset table.  The dynamic linker will use the .dynsym entry to
7146      determine the address it must put in the global offset table, so
7147      both the dynamic object and the regular object will refer to the
7148      same memory location for the variable.  */
7149
7150   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7151      to copy the initial value out of the dynamic object and into the
7152      runtime process image.  We need to remember the offset into the
7153      .rela.bss section we are going to use.  */
7154   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7155     {
7156       htab->relbss->size += sizeof (Elf64_External_Rela);
7157       h->needs_copy = 1;
7158     }
7159
7160   s = htab->dynbss;
7161
7162   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7163 }
7164
7165 /* If given a function descriptor symbol, hide both the function code
7166    sym and the descriptor.  */
7167 static void
7168 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7169                        struct elf_link_hash_entry *h,
7170                        bfd_boolean force_local)
7171 {
7172   struct ppc_link_hash_entry *eh;
7173   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7174
7175   eh = (struct ppc_link_hash_entry *) h;
7176   if (eh->is_func_descriptor)
7177     {
7178       struct ppc_link_hash_entry *fh = eh->oh;
7179
7180       if (fh == NULL)
7181         {
7182           const char *p, *q;
7183           struct ppc_link_hash_table *htab;
7184           char save;
7185
7186           /* We aren't supposed to use alloca in BFD because on
7187              systems which do not have alloca the version in libiberty
7188              calls xmalloc, which might cause the program to crash
7189              when it runs out of memory.  This function doesn't have a
7190              return status, so there's no way to gracefully return an
7191              error.  So cheat.  We know that string[-1] can be safely
7192              accessed;  It's either a string in an ELF string table,
7193              or allocated in an objalloc structure.  */
7194
7195           p = eh->elf.root.root.string - 1;
7196           save = *p;
7197           *(char *) p = '.';
7198           htab = ppc_hash_table (info);
7199           if (htab == NULL)
7200             return;
7201
7202           fh = (struct ppc_link_hash_entry *)
7203             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7204           *(char *) p = save;
7205
7206           /* Unfortunately, if it so happens that the string we were
7207              looking for was allocated immediately before this string,
7208              then we overwrote the string terminator.  That's the only
7209              reason the lookup should fail.  */
7210           if (fh == NULL)
7211             {
7212               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7213               while (q >= eh->elf.root.root.string && *q == *p)
7214                 --q, --p;
7215               if (q < eh->elf.root.root.string && *p == '.')
7216                 fh = (struct ppc_link_hash_entry *)
7217                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7218             }
7219           if (fh != NULL)
7220             {
7221               eh->oh = fh;
7222               fh->oh = eh;
7223             }
7224         }
7225       if (fh != NULL)
7226         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7227     }
7228 }
7229
7230 static bfd_boolean
7231 get_sym_h (struct elf_link_hash_entry **hp,
7232            Elf_Internal_Sym **symp,
7233            asection **symsecp,
7234            unsigned char **tls_maskp,
7235            Elf_Internal_Sym **locsymsp,
7236            unsigned long r_symndx,
7237            bfd *ibfd)
7238 {
7239   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7240
7241   if (r_symndx >= symtab_hdr->sh_info)
7242     {
7243       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7244       struct elf_link_hash_entry *h;
7245
7246       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7247       h = elf_follow_link (h);
7248
7249       if (hp != NULL)
7250         *hp = h;
7251
7252       if (symp != NULL)
7253         *symp = NULL;
7254
7255       if (symsecp != NULL)
7256         {
7257           asection *symsec = NULL;
7258           if (h->root.type == bfd_link_hash_defined
7259               || h->root.type == bfd_link_hash_defweak)
7260             symsec = h->root.u.def.section;
7261           *symsecp = symsec;
7262         }
7263
7264       if (tls_maskp != NULL)
7265         {
7266           struct ppc_link_hash_entry *eh;
7267
7268           eh = (struct ppc_link_hash_entry *) h;
7269           *tls_maskp = &eh->tls_mask;
7270         }
7271     }
7272   else
7273     {
7274       Elf_Internal_Sym *sym;
7275       Elf_Internal_Sym *locsyms = *locsymsp;
7276
7277       if (locsyms == NULL)
7278         {
7279           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7280           if (locsyms == NULL)
7281             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7282                                             symtab_hdr->sh_info,
7283                                             0, NULL, NULL, NULL);
7284           if (locsyms == NULL)
7285             return FALSE;
7286           *locsymsp = locsyms;
7287         }
7288       sym = locsyms + r_symndx;
7289
7290       if (hp != NULL)
7291         *hp = NULL;
7292
7293       if (symp != NULL)
7294         *symp = sym;
7295
7296       if (symsecp != NULL)
7297         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7298
7299       if (tls_maskp != NULL)
7300         {
7301           struct got_entry **lgot_ents;
7302           unsigned char *tls_mask;
7303
7304           tls_mask = NULL;
7305           lgot_ents = elf_local_got_ents (ibfd);
7306           if (lgot_ents != NULL)
7307             {
7308               struct plt_entry **local_plt = (struct plt_entry **)
7309                 (lgot_ents + symtab_hdr->sh_info);
7310               unsigned char *lgot_masks = (unsigned char *)
7311                 (local_plt + symtab_hdr->sh_info);
7312               tls_mask = &lgot_masks[r_symndx];
7313             }
7314           *tls_maskp = tls_mask;
7315         }
7316     }
7317   return TRUE;
7318 }
7319
7320 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7321    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7322    type suitable for optimization, and 1 otherwise.  */
7323
7324 static int
7325 get_tls_mask (unsigned char **tls_maskp,
7326               unsigned long *toc_symndx,
7327               bfd_vma *toc_addend,
7328               Elf_Internal_Sym **locsymsp,
7329               const Elf_Internal_Rela *rel,
7330               bfd *ibfd)
7331 {
7332   unsigned long r_symndx;
7333   int next_r;
7334   struct elf_link_hash_entry *h;
7335   Elf_Internal_Sym *sym;
7336   asection *sec;
7337   bfd_vma off;
7338
7339   r_symndx = ELF64_R_SYM (rel->r_info);
7340   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7341     return 0;
7342
7343   if ((*tls_maskp != NULL && **tls_maskp != 0)
7344       || sec == NULL
7345       || ppc64_elf_section_data (sec) == NULL
7346       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7347     return 1;
7348
7349   /* Look inside a TOC section too.  */
7350   if (h != NULL)
7351     {
7352       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7353       off = h->root.u.def.value;
7354     }
7355   else
7356     off = sym->st_value;
7357   off += rel->r_addend;
7358   BFD_ASSERT (off % 8 == 0);
7359   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7360   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7361   if (toc_symndx != NULL)
7362     *toc_symndx = r_symndx;
7363   if (toc_addend != NULL)
7364     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7365   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7366     return 0;
7367   if ((h == NULL || is_static_defined (h))
7368       && (next_r == -1 || next_r == -2))
7369     return 1 - next_r;
7370   return 1;
7371 }
7372
7373 /* Find (or create) an entry in the tocsave hash table.  */
7374
7375 static struct tocsave_entry *
7376 tocsave_find (struct ppc_link_hash_table *htab,
7377               enum insert_option insert,
7378               Elf_Internal_Sym **local_syms,
7379               const Elf_Internal_Rela *irela,
7380               bfd *ibfd)
7381 {
7382   unsigned long r_indx;
7383   struct elf_link_hash_entry *h;
7384   Elf_Internal_Sym *sym;
7385   struct tocsave_entry ent, *p;
7386   hashval_t hash;
7387   struct tocsave_entry **slot;
7388
7389   r_indx = ELF64_R_SYM (irela->r_info);
7390   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7391     return NULL;
7392   if (ent.sec == NULL || ent.sec->output_section == NULL)
7393     {
7394       (*_bfd_error_handler)
7395         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7396       return NULL;
7397     }
7398
7399   if (h != NULL)
7400     ent.offset = h->root.u.def.value;
7401   else
7402     ent.offset = sym->st_value;
7403   ent.offset += irela->r_addend;
7404
7405   hash = tocsave_htab_hash (&ent);
7406   slot = ((struct tocsave_entry **)
7407           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7408   if (slot == NULL)
7409     return NULL;
7410
7411   if (*slot == NULL)
7412     {
7413       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7414       if (p == NULL)
7415         return NULL;
7416       *p = ent;
7417       *slot = p;
7418     }
7419   return *slot;
7420 }
7421
7422 /* Adjust all global syms defined in opd sections.  In gcc generated
7423    code for the old ABI, these will already have been done.  */
7424
7425 static bfd_boolean
7426 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7427 {
7428   struct ppc_link_hash_entry *eh;
7429   asection *sym_sec;
7430   struct _opd_sec_data *opd;
7431
7432   if (h->root.type == bfd_link_hash_indirect)
7433     return TRUE;
7434
7435   if (h->root.type != bfd_link_hash_defined
7436       && h->root.type != bfd_link_hash_defweak)
7437     return TRUE;
7438
7439   eh = (struct ppc_link_hash_entry *) h;
7440   if (eh->adjust_done)
7441     return TRUE;
7442
7443   sym_sec = eh->elf.root.u.def.section;
7444   opd = get_opd_info (sym_sec);
7445   if (opd != NULL && opd->adjust != NULL)
7446     {
7447       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7448       if (adjust == -1)
7449         {
7450           /* This entry has been deleted.  */
7451           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7452           if (dsec == NULL)
7453             {
7454               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7455                 if (discarded_section (dsec))
7456                   {
7457                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7458                     break;
7459                   }
7460             }
7461           eh->elf.root.u.def.value = 0;
7462           eh->elf.root.u.def.section = dsec;
7463         }
7464       else
7465         eh->elf.root.u.def.value += adjust;
7466       eh->adjust_done = 1;
7467     }
7468   return TRUE;
7469 }
7470
7471 /* Handles decrementing dynamic reloc counts for the reloc specified by
7472    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7473    have already been determined.  */
7474
7475 static bfd_boolean
7476 dec_dynrel_count (bfd_vma r_info,
7477                   asection *sec,
7478                   struct bfd_link_info *info,
7479                   Elf_Internal_Sym **local_syms,
7480                   struct elf_link_hash_entry *h,
7481                   Elf_Internal_Sym *sym)
7482 {
7483   enum elf_ppc64_reloc_type r_type;
7484   asection *sym_sec = NULL;
7485
7486   /* Can this reloc be dynamic?  This switch, and later tests here
7487      should be kept in sync with the code in check_relocs.  */
7488   r_type = ELF64_R_TYPE (r_info);
7489   switch (r_type)
7490     {
7491     default:
7492       return TRUE;
7493
7494     case R_PPC64_TPREL16:
7495     case R_PPC64_TPREL16_LO:
7496     case R_PPC64_TPREL16_HI:
7497     case R_PPC64_TPREL16_HA:
7498     case R_PPC64_TPREL16_DS:
7499     case R_PPC64_TPREL16_LO_DS:
7500     case R_PPC64_TPREL16_HIGH:
7501     case R_PPC64_TPREL16_HIGHA:
7502     case R_PPC64_TPREL16_HIGHER:
7503     case R_PPC64_TPREL16_HIGHERA:
7504     case R_PPC64_TPREL16_HIGHEST:
7505     case R_PPC64_TPREL16_HIGHESTA:
7506       if (!info->shared)
7507         return TRUE;
7508
7509     case R_PPC64_TPREL64:
7510     case R_PPC64_DTPMOD64:
7511     case R_PPC64_DTPREL64:
7512     case R_PPC64_ADDR64:
7513     case R_PPC64_REL30:
7514     case R_PPC64_REL32:
7515     case R_PPC64_REL64:
7516     case R_PPC64_ADDR14:
7517     case R_PPC64_ADDR14_BRNTAKEN:
7518     case R_PPC64_ADDR14_BRTAKEN:
7519     case R_PPC64_ADDR16:
7520     case R_PPC64_ADDR16_DS:
7521     case R_PPC64_ADDR16_HA:
7522     case R_PPC64_ADDR16_HI:
7523     case R_PPC64_ADDR16_HIGH:
7524     case R_PPC64_ADDR16_HIGHA:
7525     case R_PPC64_ADDR16_HIGHER:
7526     case R_PPC64_ADDR16_HIGHERA:
7527     case R_PPC64_ADDR16_HIGHEST:
7528     case R_PPC64_ADDR16_HIGHESTA:
7529     case R_PPC64_ADDR16_LO:
7530     case R_PPC64_ADDR16_LO_DS:
7531     case R_PPC64_ADDR24:
7532     case R_PPC64_ADDR32:
7533     case R_PPC64_UADDR16:
7534     case R_PPC64_UADDR32:
7535     case R_PPC64_UADDR64:
7536     case R_PPC64_TOC:
7537       break;
7538     }
7539
7540   if (local_syms != NULL)
7541     {
7542       unsigned long r_symndx;
7543       bfd *ibfd = sec->owner;
7544
7545       r_symndx = ELF64_R_SYM (r_info);
7546       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7547         return FALSE;
7548     }
7549
7550   if ((info->shared
7551        && (must_be_dyn_reloc (info, r_type)
7552            || (h != NULL
7553                && (!SYMBOLIC_BIND (info, h)
7554                    || h->root.type == bfd_link_hash_defweak
7555                    || !h->def_regular))))
7556       || (ELIMINATE_COPY_RELOCS
7557           && !info->shared
7558           && h != NULL
7559           && (h->root.type == bfd_link_hash_defweak
7560               || !h->def_regular)))
7561     ;
7562   else
7563     return TRUE;
7564
7565   if (h != NULL)
7566     {
7567       struct elf_dyn_relocs *p;
7568       struct elf_dyn_relocs **pp;
7569       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7570
7571       /* elf_gc_sweep may have already removed all dyn relocs associated
7572          with local syms for a given section.  Also, symbol flags are
7573          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7574          report a dynreloc miscount.  */
7575       if (*pp == NULL && info->gc_sections)
7576         return TRUE;
7577
7578       while ((p = *pp) != NULL)
7579         {
7580           if (p->sec == sec)
7581             {
7582               if (!must_be_dyn_reloc (info, r_type))
7583                 p->pc_count -= 1;
7584               p->count -= 1;
7585               if (p->count == 0)
7586                 *pp = p->next;
7587               return TRUE;
7588             }
7589           pp = &p->next;
7590         }
7591     }
7592   else
7593     {
7594       struct ppc_dyn_relocs *p;
7595       struct ppc_dyn_relocs **pp;
7596       void *vpp;
7597       bfd_boolean is_ifunc;
7598
7599       if (local_syms == NULL)
7600         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7601       if (sym_sec == NULL)
7602         sym_sec = sec;
7603
7604       vpp = &elf_section_data (sym_sec)->local_dynrel;
7605       pp = (struct ppc_dyn_relocs **) vpp;
7606
7607       if (*pp == NULL && info->gc_sections)
7608         return TRUE;
7609
7610       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7611       while ((p = *pp) != NULL)
7612         {
7613           if (p->sec == sec && p->ifunc == is_ifunc)
7614             {
7615               p->count -= 1;
7616               if (p->count == 0)
7617                 *pp = p->next;
7618               return TRUE;
7619             }
7620           pp = &p->next;
7621         }
7622     }
7623
7624   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7625                           sec->owner, sec);
7626   bfd_set_error (bfd_error_bad_value);
7627   return FALSE;
7628 }
7629
7630 /* Remove unused Official Procedure Descriptor entries.  Currently we
7631    only remove those associated with functions in discarded link-once
7632    sections, or weakly defined functions that have been overridden.  It
7633    would be possible to remove many more entries for statically linked
7634    applications.  */
7635
7636 bfd_boolean
7637 ppc64_elf_edit_opd (struct bfd_link_info *info)
7638 {
7639   bfd *ibfd;
7640   bfd_boolean some_edited = FALSE;
7641   asection *need_pad = NULL;
7642   struct ppc_link_hash_table *htab;
7643
7644   htab = ppc_hash_table (info);
7645   if (htab == NULL)
7646     return FALSE;
7647
7648   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7649     {
7650       asection *sec;
7651       Elf_Internal_Rela *relstart, *rel, *relend;
7652       Elf_Internal_Shdr *symtab_hdr;
7653       Elf_Internal_Sym *local_syms;
7654       struct _opd_sec_data *opd;
7655       bfd_boolean need_edit, add_aux_fields, broken;
7656       bfd_size_type cnt_16b = 0;
7657
7658       if (!is_ppc64_elf (ibfd))
7659         continue;
7660
7661       sec = bfd_get_section_by_name (ibfd, ".opd");
7662       if (sec == NULL || sec->size == 0)
7663         continue;
7664
7665       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7666         continue;
7667
7668       if (sec->output_section == bfd_abs_section_ptr)
7669         continue;
7670
7671       /* Look through the section relocs.  */
7672       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7673         continue;
7674
7675       local_syms = NULL;
7676       symtab_hdr = &elf_symtab_hdr (ibfd);
7677
7678       /* Read the relocations.  */
7679       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7680                                             info->keep_memory);
7681       if (relstart == NULL)
7682         return FALSE;
7683
7684       /* First run through the relocs to check they are sane, and to
7685          determine whether we need to edit this opd section.  */
7686       need_edit = FALSE;
7687       broken = FALSE;
7688       need_pad = sec;
7689       relend = relstart + sec->reloc_count;
7690       for (rel = relstart; rel < relend; )
7691         {
7692           enum elf_ppc64_reloc_type r_type;
7693           unsigned long r_symndx;
7694           asection *sym_sec;
7695           struct elf_link_hash_entry *h;
7696           Elf_Internal_Sym *sym;
7697           bfd_vma offset;
7698
7699           /* .opd contains an array of 16 or 24 byte entries.  We're
7700              only interested in the reloc pointing to a function entry
7701              point.  */
7702           offset = rel->r_offset;
7703           if (rel + 1 == relend
7704               || rel[1].r_offset != offset + 8)
7705             {
7706               /* If someone messes with .opd alignment then after a
7707                  "ld -r" we might have padding in the middle of .opd.
7708                  Also, there's nothing to prevent someone putting
7709                  something silly in .opd with the assembler.  No .opd
7710                  optimization for them!  */
7711             broken_opd:
7712               (*_bfd_error_handler)
7713                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7714               broken = TRUE;
7715               break;
7716             }
7717
7718           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7719               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7720             {
7721               (*_bfd_error_handler)
7722                 (_("%B: unexpected reloc type %u in .opd section"),
7723                  ibfd, r_type);
7724               broken = TRUE;
7725               break;
7726             }
7727
7728           r_symndx = ELF64_R_SYM (rel->r_info);
7729           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7730                           r_symndx, ibfd))
7731             goto error_ret;
7732
7733           if (sym_sec == NULL || sym_sec->owner == NULL)
7734             {
7735               const char *sym_name;
7736               if (h != NULL)
7737                 sym_name = h->root.root.string;
7738               else
7739                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7740                                              sym_sec);
7741
7742               (*_bfd_error_handler)
7743                 (_("%B: undefined sym `%s' in .opd section"),
7744                  ibfd, sym_name);
7745               broken = TRUE;
7746               break;
7747             }
7748
7749           /* opd entries are always for functions defined in the
7750              current input bfd.  If the symbol isn't defined in the
7751              input bfd, then we won't be using the function in this
7752              bfd;  It must be defined in a linkonce section in another
7753              bfd, or is weak.  It's also possible that we are
7754              discarding the function due to a linker script /DISCARD/,
7755              which we test for via the output_section.  */
7756           if (sym_sec->owner != ibfd
7757               || sym_sec->output_section == bfd_abs_section_ptr)
7758             need_edit = TRUE;
7759
7760           rel += 2;
7761           if (rel + 1 == relend
7762               || (rel + 2 < relend
7763                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7764             ++rel;
7765
7766           if (rel == relend)
7767             {
7768               if (sec->size == offset + 24)
7769                 {
7770                   need_pad = NULL;
7771                   break;
7772                 }
7773               if (sec->size == offset + 16)
7774                 {
7775                   cnt_16b++;
7776                   break;
7777                 }
7778               goto broken_opd;
7779             }
7780           else if (rel + 1 < relend
7781                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7782                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7783             {
7784               if (rel[0].r_offset == offset + 16)
7785                 cnt_16b++;
7786               else if (rel[0].r_offset != offset + 24)
7787                 goto broken_opd;
7788             }
7789           else
7790             goto broken_opd;
7791         }
7792
7793       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7794
7795       if (!broken && (need_edit || add_aux_fields))
7796         {
7797           Elf_Internal_Rela *write_rel;
7798           Elf_Internal_Shdr *rel_hdr;
7799           bfd_byte *rptr, *wptr;
7800           bfd_byte *new_contents;
7801           bfd_size_type amt;
7802
7803           new_contents = NULL;
7804           amt = OPD_NDX (sec->size) * sizeof (long);
7805           opd = &ppc64_elf_section_data (sec)->u.opd;
7806           opd->adjust = bfd_zalloc (sec->owner, amt);
7807           if (opd->adjust == NULL)
7808             return FALSE;
7809           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7810
7811           /* This seems a waste of time as input .opd sections are all
7812              zeros as generated by gcc, but I suppose there's no reason
7813              this will always be so.  We might start putting something in
7814              the third word of .opd entries.  */
7815           if ((sec->flags & SEC_IN_MEMORY) == 0)
7816             {
7817               bfd_byte *loc;
7818               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7819                 {
7820                   if (loc != NULL)
7821                     free (loc);
7822                 error_ret:
7823                   if (local_syms != NULL
7824                       && symtab_hdr->contents != (unsigned char *) local_syms)
7825                     free (local_syms);
7826                   if (elf_section_data (sec)->relocs != relstart)
7827                     free (relstart);
7828                   return FALSE;
7829                 }
7830               sec->contents = loc;
7831               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7832             }
7833
7834           elf_section_data (sec)->relocs = relstart;
7835
7836           new_contents = sec->contents;
7837           if (add_aux_fields)
7838             {
7839               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7840               if (new_contents == NULL)
7841                 return FALSE;
7842               need_pad = NULL;
7843             }
7844           wptr = new_contents;
7845           rptr = sec->contents;
7846           write_rel = relstart;
7847           for (rel = relstart; rel < relend; )
7848             {
7849               unsigned long r_symndx;
7850               asection *sym_sec;
7851               struct elf_link_hash_entry *h;
7852               struct ppc_link_hash_entry *fdh = NULL;
7853               Elf_Internal_Sym *sym;
7854               long opd_ent_size;
7855               Elf_Internal_Rela *next_rel;
7856               bfd_boolean skip;
7857
7858               r_symndx = ELF64_R_SYM (rel->r_info);
7859               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7860                               r_symndx, ibfd))
7861                 goto error_ret;
7862
7863               next_rel = rel + 2;
7864               if (next_rel + 1 == relend
7865                   || (next_rel + 2 < relend
7866                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7867                 ++next_rel;
7868
7869               /* See if the .opd entry is full 24 byte or
7870                  16 byte (with fd_aux entry overlapped with next
7871                  fd_func).  */
7872               opd_ent_size = 24;
7873               if (next_rel == relend)
7874                 {
7875                   if (sec->size == rel->r_offset + 16)
7876                     opd_ent_size = 16;
7877                 }
7878               else if (next_rel->r_offset == rel->r_offset + 16)
7879                 opd_ent_size = 16;
7880
7881               if (h != NULL
7882                   && h->root.root.string[0] == '.')
7883                 {
7884                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7885                   if (fdh != NULL
7886                       && fdh->elf.root.type != bfd_link_hash_defined
7887                       && fdh->elf.root.type != bfd_link_hash_defweak)
7888                     fdh = NULL;
7889                 }
7890
7891               skip = (sym_sec->owner != ibfd
7892                       || sym_sec->output_section == bfd_abs_section_ptr);
7893               if (skip)
7894                 {
7895                   if (fdh != NULL && sym_sec->owner == ibfd)
7896                     {
7897                       /* Arrange for the function descriptor sym
7898                          to be dropped.  */
7899                       fdh->elf.root.u.def.value = 0;
7900                       fdh->elf.root.u.def.section = sym_sec;
7901                     }
7902                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
7903
7904                   if (NO_OPD_RELOCS || info->relocatable)
7905                     rel = next_rel;
7906                   else
7907                     while (1)
7908                       {
7909                         if (!dec_dynrel_count (rel->r_info, sec, info,
7910                                                NULL, h, sym))
7911                           goto error_ret;
7912
7913                         if (++rel == next_rel)
7914                           break;
7915
7916                         r_symndx = ELF64_R_SYM (rel->r_info);
7917                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7918                                         r_symndx, ibfd))
7919                           goto error_ret;
7920                       }
7921                 }
7922               else
7923                 {
7924                   /* We'll be keeping this opd entry.  */
7925                   long adjust;
7926
7927                   if (fdh != NULL)
7928                     {
7929                       /* Redefine the function descriptor symbol to
7930                          this location in the opd section.  It is
7931                          necessary to update the value here rather
7932                          than using an array of adjustments as we do
7933                          for local symbols, because various places
7934                          in the generic ELF code use the value
7935                          stored in u.def.value.  */
7936                       fdh->elf.root.u.def.value = wptr - new_contents;
7937                       fdh->adjust_done = 1;
7938                     }
7939
7940                   /* Local syms are a bit tricky.  We could
7941                      tweak them as they can be cached, but
7942                      we'd need to look through the local syms
7943                      for the function descriptor sym which we
7944                      don't have at the moment.  So keep an
7945                      array of adjustments.  */
7946                   adjust = (wptr - new_contents) - (rptr - sec->contents);
7947                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
7948
7949                   if (wptr != rptr)
7950                     memcpy (wptr, rptr, opd_ent_size);
7951                   wptr += opd_ent_size;
7952                   if (add_aux_fields && opd_ent_size == 16)
7953                     {
7954                       memset (wptr, '\0', 8);
7955                       wptr += 8;
7956                     }
7957
7958                   /* We need to adjust any reloc offsets to point to the
7959                      new opd entries.  */
7960                   for ( ; rel != next_rel; ++rel)
7961                     {
7962                       rel->r_offset += adjust;
7963                       if (write_rel != rel)
7964                         memcpy (write_rel, rel, sizeof (*rel));
7965                       ++write_rel;
7966                     }
7967                 }
7968
7969               rptr += opd_ent_size;
7970             }
7971
7972           sec->size = wptr - new_contents;
7973           sec->reloc_count = write_rel - relstart;
7974           if (add_aux_fields)
7975             {
7976               free (sec->contents);
7977               sec->contents = new_contents;
7978             }
7979
7980           /* Fudge the header size too, as this is used later in
7981              elf_bfd_final_link if we are emitting relocs.  */
7982           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7983           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7984           some_edited = TRUE;
7985         }
7986       else if (elf_section_data (sec)->relocs != relstart)
7987         free (relstart);
7988
7989       if (local_syms != NULL
7990           && symtab_hdr->contents != (unsigned char *) local_syms)
7991         {
7992           if (!info->keep_memory)
7993             free (local_syms);
7994           else
7995             symtab_hdr->contents = (unsigned char *) local_syms;
7996         }
7997     }
7998
7999   if (some_edited)
8000     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8001
8002   /* If we are doing a final link and the last .opd entry is just 16 byte
8003      long, add a 8 byte padding after it.  */
8004   if (need_pad != NULL && !info->relocatable)
8005     {
8006       bfd_byte *p;
8007
8008       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8009         {
8010           BFD_ASSERT (need_pad->size > 0);
8011
8012           p = bfd_malloc (need_pad->size + 8);
8013           if (p == NULL)
8014             return FALSE;
8015
8016           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8017                                           p, 0, need_pad->size))
8018             return FALSE;
8019
8020           need_pad->contents = p;
8021           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8022         }
8023       else
8024         {
8025           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8026           if (p == NULL)
8027             return FALSE;
8028
8029           need_pad->contents = p;
8030         }
8031
8032       memset (need_pad->contents + need_pad->size, 0, 8);
8033       need_pad->size += 8;
8034     }
8035
8036   return TRUE;
8037 }
8038
8039 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8040
8041 asection *
8042 ppc64_elf_tls_setup (struct bfd_link_info *info)
8043 {
8044   struct ppc_link_hash_table *htab;
8045
8046   htab = ppc_hash_table (info);
8047   if (htab == NULL)
8048     return NULL;
8049
8050   if (abiversion (info->output_bfd) == 1)
8051     htab->opd_abi = 1;
8052
8053   if (htab->params->no_multi_toc)
8054     htab->do_multi_toc = 0;
8055   else if (!htab->do_multi_toc)
8056     htab->params->no_multi_toc = 1;
8057
8058   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8059                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8060                                               FALSE, FALSE, TRUE));
8061   /* Move dynamic linking info to the function descriptor sym.  */
8062   if (htab->tls_get_addr != NULL)
8063     func_desc_adjust (&htab->tls_get_addr->elf, info);
8064   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8065                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8066                                                  FALSE, FALSE, TRUE));
8067   if (!htab->params->no_tls_get_addr_opt)
8068     {
8069       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8070
8071       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8072                                   FALSE, FALSE, TRUE);
8073       if (opt != NULL)
8074         func_desc_adjust (opt, info);
8075       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8076                                      FALSE, FALSE, TRUE);
8077       if (opt_fd != NULL
8078           && (opt_fd->root.type == bfd_link_hash_defined
8079               || opt_fd->root.type == bfd_link_hash_defweak))
8080         {
8081           /* If glibc supports an optimized __tls_get_addr call stub,
8082              signalled by the presence of __tls_get_addr_opt, and we'll
8083              be calling __tls_get_addr via a plt call stub, then
8084              make __tls_get_addr point to __tls_get_addr_opt.  */
8085           tga_fd = &htab->tls_get_addr_fd->elf;
8086           if (htab->elf.dynamic_sections_created
8087               && tga_fd != NULL
8088               && (tga_fd->type == STT_FUNC
8089                   || tga_fd->needs_plt)
8090               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8091                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8092                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8093             {
8094               struct plt_entry *ent;
8095
8096               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8097                 if (ent->plt.refcount > 0)
8098                   break;
8099               if (ent != NULL)
8100                 {
8101                   tga_fd->root.type = bfd_link_hash_indirect;
8102                   tga_fd->root.u.i.link = &opt_fd->root;
8103                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8104                   if (opt_fd->dynindx != -1)
8105                     {
8106                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8107                       opt_fd->dynindx = -1;
8108                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8109                                               opt_fd->dynstr_index);
8110                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8111                         return NULL;
8112                     }
8113                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8114                   tga = &htab->tls_get_addr->elf;
8115                   if (opt != NULL && tga != NULL)
8116                     {
8117                       tga->root.type = bfd_link_hash_indirect;
8118                       tga->root.u.i.link = &opt->root;
8119                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8120                       _bfd_elf_link_hash_hide_symbol (info, opt,
8121                                                       tga->forced_local);
8122                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8123                     }
8124                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8125                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8126                   if (htab->tls_get_addr != NULL)
8127                     {
8128                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8129                       htab->tls_get_addr->is_func = 1;
8130                     }
8131                 }
8132             }
8133         }
8134       else
8135         htab->params->no_tls_get_addr_opt = TRUE;
8136     }
8137   return _bfd_elf_tls_setup (info->output_bfd, info);
8138 }
8139
8140 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8141    HASH1 or HASH2.  */
8142
8143 static bfd_boolean
8144 branch_reloc_hash_match (const bfd *ibfd,
8145                          const Elf_Internal_Rela *rel,
8146                          const struct ppc_link_hash_entry *hash1,
8147                          const struct ppc_link_hash_entry *hash2)
8148 {
8149   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8150   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8151   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8152
8153   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8154     {
8155       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8156       struct elf_link_hash_entry *h;
8157
8158       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8159       h = elf_follow_link (h);
8160       if (h == &hash1->elf || h == &hash2->elf)
8161         return TRUE;
8162     }
8163   return FALSE;
8164 }
8165
8166 /* Run through all the TLS relocs looking for optimization
8167    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8168    a preliminary section layout so that we know the TLS segment
8169    offsets.  We can't optimize earlier because some optimizations need
8170    to know the tp offset, and we need to optimize before allocating
8171    dynamic relocations.  */
8172
8173 bfd_boolean
8174 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8175 {
8176   bfd *ibfd;
8177   asection *sec;
8178   struct ppc_link_hash_table *htab;
8179   unsigned char *toc_ref;
8180   int pass;
8181
8182   if (info->relocatable || !info->executable)
8183     return TRUE;
8184
8185   htab = ppc_hash_table (info);
8186   if (htab == NULL)
8187     return FALSE;
8188
8189   /* Make two passes over the relocs.  On the first pass, mark toc
8190      entries involved with tls relocs, and check that tls relocs
8191      involved in setting up a tls_get_addr call are indeed followed by
8192      such a call.  If they are not, we can't do any tls optimization.
8193      On the second pass twiddle tls_mask flags to notify
8194      relocate_section that optimization can be done, and adjust got
8195      and plt refcounts.  */
8196   toc_ref = NULL;
8197   for (pass = 0; pass < 2; ++pass)
8198     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8199       {
8200         Elf_Internal_Sym *locsyms = NULL;
8201         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8202
8203         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8204           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8205             {
8206               Elf_Internal_Rela *relstart, *rel, *relend;
8207               bfd_boolean found_tls_get_addr_arg = 0;
8208
8209               /* Read the relocations.  */
8210               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8211                                                     info->keep_memory);
8212               if (relstart == NULL)
8213                 {
8214                   free (toc_ref);
8215                   return FALSE;
8216                 }
8217
8218               relend = relstart + sec->reloc_count;
8219               for (rel = relstart; rel < relend; rel++)
8220                 {
8221                   enum elf_ppc64_reloc_type r_type;
8222                   unsigned long r_symndx;
8223                   struct elf_link_hash_entry *h;
8224                   Elf_Internal_Sym *sym;
8225                   asection *sym_sec;
8226                   unsigned char *tls_mask;
8227                   unsigned char tls_set, tls_clear, tls_type = 0;
8228                   bfd_vma value;
8229                   bfd_boolean ok_tprel, is_local;
8230                   long toc_ref_index = 0;
8231                   int expecting_tls_get_addr = 0;
8232                   bfd_boolean ret = FALSE;
8233
8234                   r_symndx = ELF64_R_SYM (rel->r_info);
8235                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8236                                   r_symndx, ibfd))
8237                     {
8238                     err_free_rel:
8239                       if (elf_section_data (sec)->relocs != relstart)
8240                         free (relstart);
8241                       if (toc_ref != NULL)
8242                         free (toc_ref);
8243                       if (locsyms != NULL
8244                           && (elf_symtab_hdr (ibfd).contents
8245                               != (unsigned char *) locsyms))
8246                         free (locsyms);
8247                       return ret;
8248                     }
8249
8250                   if (h != NULL)
8251                     {
8252                       if (h->root.type == bfd_link_hash_defined
8253                           || h->root.type == bfd_link_hash_defweak)
8254                         value = h->root.u.def.value;
8255                       else if (h->root.type == bfd_link_hash_undefweak)
8256                         value = 0;
8257                       else
8258                         {
8259                           found_tls_get_addr_arg = 0;
8260                           continue;
8261                         }
8262                     }
8263                   else
8264                     /* Symbols referenced by TLS relocs must be of type
8265                        STT_TLS.  So no need for .opd local sym adjust.  */
8266                     value = sym->st_value;
8267
8268                   ok_tprel = FALSE;
8269                   is_local = FALSE;
8270                   if (h == NULL
8271                       || !h->def_dynamic)
8272                     {
8273                       is_local = TRUE;
8274                       if (h != NULL
8275                           && h->root.type == bfd_link_hash_undefweak)
8276                         ok_tprel = TRUE;
8277                       else
8278                         {
8279                           value += sym_sec->output_offset;
8280                           value += sym_sec->output_section->vma;
8281                           value -= htab->elf.tls_sec->vma;
8282                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8283                                       < (bfd_vma) 1 << 32);
8284                         }
8285                     }
8286
8287                   r_type = ELF64_R_TYPE (rel->r_info);
8288                   /* If this section has old-style __tls_get_addr calls
8289                      without marker relocs, then check that each
8290                      __tls_get_addr call reloc is preceded by a reloc
8291                      that conceivably belongs to the __tls_get_addr arg
8292                      setup insn.  If we don't find matching arg setup
8293                      relocs, don't do any tls optimization.  */
8294                   if (pass == 0
8295                       && sec->has_tls_get_addr_call
8296                       && h != NULL
8297                       && (h == &htab->tls_get_addr->elf
8298                           || h == &htab->tls_get_addr_fd->elf)
8299                       && !found_tls_get_addr_arg
8300                       && is_branch_reloc (r_type))
8301                     {
8302                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8303                                                 "TLS optimization disabled\n"),
8304                                               ibfd, sec, rel->r_offset);
8305                       ret = TRUE;
8306                       goto err_free_rel;
8307                     }
8308
8309                   found_tls_get_addr_arg = 0;
8310                   switch (r_type)
8311                     {
8312                     case R_PPC64_GOT_TLSLD16:
8313                     case R_PPC64_GOT_TLSLD16_LO:
8314                       expecting_tls_get_addr = 1;
8315                       found_tls_get_addr_arg = 1;
8316                       /* Fall thru */
8317
8318                     case R_PPC64_GOT_TLSLD16_HI:
8319                     case R_PPC64_GOT_TLSLD16_HA:
8320                       /* These relocs should never be against a symbol
8321                          defined in a shared lib.  Leave them alone if
8322                          that turns out to be the case.  */
8323                       if (!is_local)
8324                         continue;
8325
8326                       /* LD -> LE */
8327                       tls_set = 0;
8328                       tls_clear = TLS_LD;
8329                       tls_type = TLS_TLS | TLS_LD;
8330                       break;
8331
8332                     case R_PPC64_GOT_TLSGD16:
8333                     case R_PPC64_GOT_TLSGD16_LO:
8334                       expecting_tls_get_addr = 1;
8335                       found_tls_get_addr_arg = 1;
8336                       /* Fall thru */
8337
8338                     case R_PPC64_GOT_TLSGD16_HI:
8339                     case R_PPC64_GOT_TLSGD16_HA:
8340                       if (ok_tprel)
8341                         /* GD -> LE */
8342                         tls_set = 0;
8343                       else
8344                         /* GD -> IE */
8345                         tls_set = TLS_TLS | TLS_TPRELGD;
8346                       tls_clear = TLS_GD;
8347                       tls_type = TLS_TLS | TLS_GD;
8348                       break;
8349
8350                     case R_PPC64_GOT_TPREL16_DS:
8351                     case R_PPC64_GOT_TPREL16_LO_DS:
8352                     case R_PPC64_GOT_TPREL16_HI:
8353                     case R_PPC64_GOT_TPREL16_HA:
8354                       if (ok_tprel)
8355                         {
8356                           /* IE -> LE */
8357                           tls_set = 0;
8358                           tls_clear = TLS_TPREL;
8359                           tls_type = TLS_TLS | TLS_TPREL;
8360                           break;
8361                         }
8362                       continue;
8363
8364                     case R_PPC64_TLSGD:
8365                     case R_PPC64_TLSLD:
8366                       found_tls_get_addr_arg = 1;
8367                       /* Fall thru */
8368
8369                     case R_PPC64_TLS:
8370                     case R_PPC64_TOC16:
8371                     case R_PPC64_TOC16_LO:
8372                       if (sym_sec == NULL || sym_sec != toc)
8373                         continue;
8374
8375                       /* Mark this toc entry as referenced by a TLS
8376                          code sequence.  We can do that now in the
8377                          case of R_PPC64_TLS, and after checking for
8378                          tls_get_addr for the TOC16 relocs.  */
8379                       if (toc_ref == NULL)
8380                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8381                       if (toc_ref == NULL)
8382                         goto err_free_rel;
8383
8384                       if (h != NULL)
8385                         value = h->root.u.def.value;
8386                       else
8387                         value = sym->st_value;
8388                       value += rel->r_addend;
8389                       if (value % 8 != 0)
8390                         continue;
8391                       BFD_ASSERT (value < toc->size
8392                                   && toc->output_offset % 8 == 0);
8393                       toc_ref_index = (value + toc->output_offset) / 8;
8394                       if (r_type == R_PPC64_TLS
8395                           || r_type == R_PPC64_TLSGD
8396                           || r_type == R_PPC64_TLSLD)
8397                         {
8398                           toc_ref[toc_ref_index] = 1;
8399                           continue;
8400                         }
8401
8402                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8403                         continue;
8404
8405                       tls_set = 0;
8406                       tls_clear = 0;
8407                       expecting_tls_get_addr = 2;
8408                       break;
8409
8410                     case R_PPC64_TPREL64:
8411                       if (pass == 0
8412                           || sec != toc
8413                           || toc_ref == NULL
8414                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8415                         continue;
8416                       if (ok_tprel)
8417                         {
8418                           /* IE -> LE */
8419                           tls_set = TLS_EXPLICIT;
8420                           tls_clear = TLS_TPREL;
8421                           break;
8422                         }
8423                       continue;
8424
8425                     case R_PPC64_DTPMOD64:
8426                       if (pass == 0
8427                           || sec != toc
8428                           || toc_ref == NULL
8429                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8430                         continue;
8431                       if (rel + 1 < relend
8432                           && (rel[1].r_info
8433                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8434                           && rel[1].r_offset == rel->r_offset + 8)
8435                         {
8436                           if (ok_tprel)
8437                             /* GD -> LE */
8438                             tls_set = TLS_EXPLICIT | TLS_GD;
8439                           else
8440                             /* GD -> IE */
8441                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8442                           tls_clear = TLS_GD;
8443                         }
8444                       else
8445                         {
8446                           if (!is_local)
8447                             continue;
8448
8449                           /* LD -> LE */
8450                           tls_set = TLS_EXPLICIT;
8451                           tls_clear = TLS_LD;
8452                         }
8453                       break;
8454
8455                     default:
8456                       continue;
8457                     }
8458
8459                   if (pass == 0)
8460                     {
8461                       if (!expecting_tls_get_addr
8462                           || !sec->has_tls_get_addr_call)
8463                         continue;
8464
8465                       if (rel + 1 < relend
8466                           && branch_reloc_hash_match (ibfd, rel + 1,
8467                                                       htab->tls_get_addr,
8468                                                       htab->tls_get_addr_fd))
8469                         {
8470                           if (expecting_tls_get_addr == 2)
8471                             {
8472                               /* Check for toc tls entries.  */
8473                               unsigned char *toc_tls;
8474                               int retval;
8475
8476                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8477                                                      &locsyms,
8478                                                      rel, ibfd);
8479                               if (retval == 0)
8480                                 goto err_free_rel;
8481                               if (toc_tls != NULL)
8482                                 {
8483                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8484                                     found_tls_get_addr_arg = 1;
8485                                   if (retval > 1)
8486                                     toc_ref[toc_ref_index] = 1;
8487                                 }
8488                             }
8489                           continue;
8490                         }
8491
8492                       if (expecting_tls_get_addr != 1)
8493                         continue;
8494
8495                       /* Uh oh, we didn't find the expected call.  We
8496                          could just mark this symbol to exclude it
8497                          from tls optimization but it's safer to skip
8498                          the entire optimization.  */
8499                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8500                                                 "TLS optimization disabled\n"),
8501                                               ibfd, sec, rel->r_offset);
8502                       ret = TRUE;
8503                       goto err_free_rel;
8504                     }
8505
8506                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8507                     {
8508                       struct plt_entry *ent;
8509                       for (ent = htab->tls_get_addr->elf.plt.plist;
8510                            ent != NULL;
8511                            ent = ent->next)
8512                         if (ent->addend == 0)
8513                           {
8514                             if (ent->plt.refcount > 0)
8515                               {
8516                                 ent->plt.refcount -= 1;
8517                                 expecting_tls_get_addr = 0;
8518                               }
8519                             break;
8520                           }
8521                     }
8522
8523                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8524                     {
8525                       struct plt_entry *ent;
8526                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8527                            ent != NULL;
8528                            ent = ent->next)
8529                         if (ent->addend == 0)
8530                           {
8531                             if (ent->plt.refcount > 0)
8532                               ent->plt.refcount -= 1;
8533                             break;
8534                           }
8535                     }
8536
8537                   if (tls_clear == 0)
8538                     continue;
8539
8540                   if ((tls_set & TLS_EXPLICIT) == 0)
8541                     {
8542                       struct got_entry *ent;
8543
8544                       /* Adjust got entry for this reloc.  */
8545                       if (h != NULL)
8546                         ent = h->got.glist;
8547                       else
8548                         ent = elf_local_got_ents (ibfd)[r_symndx];
8549
8550                       for (; ent != NULL; ent = ent->next)
8551                         if (ent->addend == rel->r_addend
8552                             && ent->owner == ibfd
8553                             && ent->tls_type == tls_type)
8554                           break;
8555                       if (ent == NULL)
8556                         abort ();
8557
8558                       if (tls_set == 0)
8559                         {
8560                           /* We managed to get rid of a got entry.  */
8561                           if (ent->got.refcount > 0)
8562                             ent->got.refcount -= 1;
8563                         }
8564                     }
8565                   else
8566                     {
8567                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8568                          we'll lose one or two dyn relocs.  */
8569                       if (!dec_dynrel_count (rel->r_info, sec, info,
8570                                              NULL, h, sym))
8571                         return FALSE;
8572
8573                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8574                         {
8575                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8576                                                  NULL, h, sym))
8577                             return FALSE;
8578                         }
8579                     }
8580
8581                   *tls_mask |= tls_set;
8582                   *tls_mask &= ~tls_clear;
8583                 }
8584
8585               if (elf_section_data (sec)->relocs != relstart)
8586                 free (relstart);
8587             }
8588
8589         if (locsyms != NULL
8590             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8591           {
8592             if (!info->keep_memory)
8593               free (locsyms);
8594             else
8595               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8596           }
8597       }
8598
8599   if (toc_ref != NULL)
8600     free (toc_ref);
8601   return TRUE;
8602 }
8603
8604 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8605    the values of any global symbols in a toc section that has been
8606    edited.  Globals in toc sections should be a rarity, so this function
8607    sets a flag if any are found in toc sections other than the one just
8608    edited, so that futher hash table traversals can be avoided.  */
8609
8610 struct adjust_toc_info
8611 {
8612   asection *toc;
8613   unsigned long *skip;
8614   bfd_boolean global_toc_syms;
8615 };
8616
8617 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8618
8619 static bfd_boolean
8620 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8621 {
8622   struct ppc_link_hash_entry *eh;
8623   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8624   unsigned long i;
8625
8626   if (h->root.type != bfd_link_hash_defined
8627       && h->root.type != bfd_link_hash_defweak)
8628     return TRUE;
8629
8630   eh = (struct ppc_link_hash_entry *) h;
8631   if (eh->adjust_done)
8632     return TRUE;
8633
8634   if (eh->elf.root.u.def.section == toc_inf->toc)
8635     {
8636       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8637         i = toc_inf->toc->rawsize >> 3;
8638       else
8639         i = eh->elf.root.u.def.value >> 3;
8640
8641       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8642         {
8643           (*_bfd_error_handler)
8644             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8645           do
8646             ++i;
8647           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8648           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8649         }
8650
8651       eh->elf.root.u.def.value -= toc_inf->skip[i];
8652       eh->adjust_done = 1;
8653     }
8654   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8655     toc_inf->global_toc_syms = TRUE;
8656
8657   return TRUE;
8658 }
8659
8660 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8661
8662 static bfd_boolean
8663 ok_lo_toc_insn (unsigned int insn)
8664 {
8665   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8666           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8667           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8668           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8669           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8670           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8671           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8672           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8673           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8674           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8675           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8676           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8677           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8678           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8679           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8680               && (insn & 3) != 1)
8681           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8682               && ((insn & 3) == 0 || (insn & 3) == 3))
8683           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8684 }
8685
8686 /* Examine all relocs referencing .toc sections in order to remove
8687    unused .toc entries.  */
8688
8689 bfd_boolean
8690 ppc64_elf_edit_toc (struct bfd_link_info *info)
8691 {
8692   bfd *ibfd;
8693   struct adjust_toc_info toc_inf;
8694   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8695
8696   htab->do_toc_opt = 1;
8697   toc_inf.global_toc_syms = TRUE;
8698   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8699     {
8700       asection *toc, *sec;
8701       Elf_Internal_Shdr *symtab_hdr;
8702       Elf_Internal_Sym *local_syms;
8703       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8704       unsigned long *skip, *drop;
8705       unsigned char *used;
8706       unsigned char *keep, last, some_unused;
8707
8708       if (!is_ppc64_elf (ibfd))
8709         continue;
8710
8711       toc = bfd_get_section_by_name (ibfd, ".toc");
8712       if (toc == NULL
8713           || toc->size == 0
8714           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8715           || discarded_section (toc))
8716         continue;
8717
8718       toc_relocs = NULL;
8719       local_syms = NULL;
8720       symtab_hdr = &elf_symtab_hdr (ibfd);
8721
8722       /* Look at sections dropped from the final link.  */
8723       skip = NULL;
8724       relstart = NULL;
8725       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8726         {
8727           if (sec->reloc_count == 0
8728               || !discarded_section (sec)
8729               || get_opd_info (sec)
8730               || (sec->flags & SEC_ALLOC) == 0
8731               || (sec->flags & SEC_DEBUGGING) != 0)
8732             continue;
8733
8734           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8735           if (relstart == NULL)
8736             goto error_ret;
8737
8738           /* Run through the relocs to see which toc entries might be
8739              unused.  */
8740           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8741             {
8742               enum elf_ppc64_reloc_type r_type;
8743               unsigned long r_symndx;
8744               asection *sym_sec;
8745               struct elf_link_hash_entry *h;
8746               Elf_Internal_Sym *sym;
8747               bfd_vma val;
8748
8749               r_type = ELF64_R_TYPE (rel->r_info);
8750               switch (r_type)
8751                 {
8752                 default:
8753                   continue;
8754
8755                 case R_PPC64_TOC16:
8756                 case R_PPC64_TOC16_LO:
8757                 case R_PPC64_TOC16_HI:
8758                 case R_PPC64_TOC16_HA:
8759                 case R_PPC64_TOC16_DS:
8760                 case R_PPC64_TOC16_LO_DS:
8761                   break;
8762                 }
8763
8764               r_symndx = ELF64_R_SYM (rel->r_info);
8765               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8766                               r_symndx, ibfd))
8767                 goto error_ret;
8768
8769               if (sym_sec != toc)
8770                 continue;
8771
8772               if (h != NULL)
8773                 val = h->root.u.def.value;
8774               else
8775                 val = sym->st_value;
8776               val += rel->r_addend;
8777
8778               if (val >= toc->size)
8779                 continue;
8780
8781               /* Anything in the toc ought to be aligned to 8 bytes.
8782                  If not, don't mark as unused.  */
8783               if (val & 7)
8784                 continue;
8785
8786               if (skip == NULL)
8787                 {
8788                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8789                   if (skip == NULL)
8790                     goto error_ret;
8791                 }
8792
8793               skip[val >> 3] = ref_from_discarded;
8794             }
8795
8796           if (elf_section_data (sec)->relocs != relstart)
8797             free (relstart);
8798         }
8799
8800       /* For largetoc loads of address constants, we can convert
8801          .  addis rx,2,addr@got@ha
8802          .  ld ry,addr@got@l(rx)
8803          to
8804          .  addis rx,2,addr@toc@ha
8805          .  addi ry,rx,addr@toc@l
8806          when addr is within 2G of the toc pointer.  This then means
8807          that the word storing "addr" in the toc is no longer needed.  */
8808
8809       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8810           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8811           && toc->reloc_count != 0)
8812         {
8813           /* Read toc relocs.  */
8814           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8815                                                   info->keep_memory);
8816           if (toc_relocs == NULL)
8817             goto error_ret;
8818
8819           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8820             {
8821               enum elf_ppc64_reloc_type r_type;
8822               unsigned long r_symndx;
8823               asection *sym_sec;
8824               struct elf_link_hash_entry *h;
8825               Elf_Internal_Sym *sym;
8826               bfd_vma val, addr;
8827
8828               r_type = ELF64_R_TYPE (rel->r_info);
8829               if (r_type != R_PPC64_ADDR64)
8830                 continue;
8831
8832               r_symndx = ELF64_R_SYM (rel->r_info);
8833               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8834                               r_symndx, ibfd))
8835                 goto error_ret;
8836
8837               if (sym_sec == NULL
8838                   || discarded_section (sym_sec))
8839                 continue;
8840
8841               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8842                 continue;
8843
8844               if (h != NULL)
8845                 {
8846                   if (h->type == STT_GNU_IFUNC)
8847                     continue;
8848                   val = h->root.u.def.value;
8849                 }
8850               else
8851                 {
8852                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8853                     continue;
8854                   val = sym->st_value;
8855                 }
8856               val += rel->r_addend;
8857               val += sym_sec->output_section->vma + sym_sec->output_offset;
8858
8859               /* We don't yet know the exact toc pointer value, but we
8860                  know it will be somewhere in the toc section.  Don't
8861                  optimize if the difference from any possible toc
8862                  pointer is outside [ff..f80008000, 7fff7fff].  */
8863               addr = toc->output_section->vma + TOC_BASE_OFF;
8864               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8865                 continue;
8866
8867               addr = toc->output_section->vma + toc->output_section->rawsize;
8868               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8869                 continue;
8870
8871               if (skip == NULL)
8872                 {
8873                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8874                   if (skip == NULL)
8875                     goto error_ret;
8876                 }
8877
8878               skip[rel->r_offset >> 3]
8879                 |= can_optimize | ((rel - toc_relocs) << 2);
8880             }
8881         }
8882
8883       if (skip == NULL)
8884         continue;
8885
8886       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8887       if (used == NULL)
8888         {
8889         error_ret:
8890           if (local_syms != NULL
8891               && symtab_hdr->contents != (unsigned char *) local_syms)
8892             free (local_syms);
8893           if (sec != NULL
8894               && relstart != NULL
8895               && elf_section_data (sec)->relocs != relstart)
8896             free (relstart);
8897           if (toc_relocs != NULL
8898               && elf_section_data (toc)->relocs != toc_relocs)
8899             free (toc_relocs);
8900           if (skip != NULL)
8901             free (skip);
8902           return FALSE;
8903         }
8904
8905       /* Now check all kept sections that might reference the toc.
8906          Check the toc itself last.  */
8907       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8908                   : ibfd->sections);
8909            sec != NULL;
8910            sec = (sec == toc ? NULL
8911                   : sec->next == NULL ? toc
8912                   : sec->next == toc && toc->next ? toc->next
8913                   : sec->next))
8914         {
8915           int repeat;
8916
8917           if (sec->reloc_count == 0
8918               || discarded_section (sec)
8919               || get_opd_info (sec)
8920               || (sec->flags & SEC_ALLOC) == 0
8921               || (sec->flags & SEC_DEBUGGING) != 0)
8922             continue;
8923
8924           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8925                                                 info->keep_memory);
8926           if (relstart == NULL)
8927             {
8928               free (used);
8929               goto error_ret;
8930             }
8931
8932           /* Mark toc entries referenced as used.  */
8933           do
8934             {
8935               repeat = 0;
8936               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8937                 {
8938                   enum elf_ppc64_reloc_type r_type;
8939                   unsigned long r_symndx;
8940                   asection *sym_sec;
8941                   struct elf_link_hash_entry *h;
8942                   Elf_Internal_Sym *sym;
8943                   bfd_vma val;
8944                   enum {no_check, check_lo, check_ha} insn_check;
8945
8946                   r_type = ELF64_R_TYPE (rel->r_info);
8947                   switch (r_type)
8948                     {
8949                     default:
8950                       insn_check = no_check;
8951                       break;
8952
8953                     case R_PPC64_GOT_TLSLD16_HA:
8954                     case R_PPC64_GOT_TLSGD16_HA:
8955                     case R_PPC64_GOT_TPREL16_HA:
8956                     case R_PPC64_GOT_DTPREL16_HA:
8957                     case R_PPC64_GOT16_HA:
8958                     case R_PPC64_TOC16_HA:
8959                       insn_check = check_ha;
8960                       break;
8961
8962                     case R_PPC64_GOT_TLSLD16_LO:
8963                     case R_PPC64_GOT_TLSGD16_LO:
8964                     case R_PPC64_GOT_TPREL16_LO_DS:
8965                     case R_PPC64_GOT_DTPREL16_LO_DS:
8966                     case R_PPC64_GOT16_LO:
8967                     case R_PPC64_GOT16_LO_DS:
8968                     case R_PPC64_TOC16_LO:
8969                     case R_PPC64_TOC16_LO_DS:
8970                       insn_check = check_lo;
8971                       break;
8972                     }
8973
8974                   if (insn_check != no_check)
8975                     {
8976                       bfd_vma off = rel->r_offset & ~3;
8977                       unsigned char buf[4];
8978                       unsigned int insn;
8979
8980                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8981                         {
8982                           free (used);
8983                           goto error_ret;
8984                         }
8985                       insn = bfd_get_32 (ibfd, buf);
8986                       if (insn_check == check_lo
8987                           ? !ok_lo_toc_insn (insn)
8988                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8989                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8990                         {
8991                           char str[12];
8992
8993                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8994                           sprintf (str, "%#08x", insn);
8995                           info->callbacks->einfo
8996                             (_("%P: %H: toc optimization is not supported for"
8997                                " %s instruction.\n"),
8998                              ibfd, sec, rel->r_offset & ~3, str);
8999                         }
9000                     }
9001
9002                   switch (r_type)
9003                     {
9004                     case R_PPC64_TOC16:
9005                     case R_PPC64_TOC16_LO:
9006                     case R_PPC64_TOC16_HI:
9007                     case R_PPC64_TOC16_HA:
9008                     case R_PPC64_TOC16_DS:
9009                     case R_PPC64_TOC16_LO_DS:
9010                       /* In case we're taking addresses of toc entries.  */
9011                     case R_PPC64_ADDR64:
9012                       break;
9013
9014                     default:
9015                       continue;
9016                     }
9017
9018                   r_symndx = ELF64_R_SYM (rel->r_info);
9019                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9020                                   r_symndx, ibfd))
9021                     {
9022                       free (used);
9023                       goto error_ret;
9024                     }
9025
9026                   if (sym_sec != toc)
9027                     continue;
9028
9029                   if (h != NULL)
9030                     val = h->root.u.def.value;
9031                   else
9032                     val = sym->st_value;
9033                   val += rel->r_addend;
9034
9035                   if (val >= toc->size)
9036                     continue;
9037
9038                   if ((skip[val >> 3] & can_optimize) != 0)
9039                     {
9040                       bfd_vma off;
9041                       unsigned char opc;
9042
9043                       switch (r_type)
9044                         {
9045                         case R_PPC64_TOC16_HA:
9046                           break;
9047
9048                         case R_PPC64_TOC16_LO_DS:
9049                           off = rel->r_offset;
9050                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9051                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9052                                                          off, 1))
9053                             {
9054                               free (used);
9055                               goto error_ret;
9056                             }
9057                           if ((opc & (0x3f << 2)) == (58u << 2))
9058                             break;
9059                           /* Fall thru */
9060
9061                         default:
9062                           /* Wrong sort of reloc, or not a ld.  We may
9063                              as well clear ref_from_discarded too.  */
9064                           skip[val >> 3] = 0;
9065                         }
9066                     }
9067
9068                   if (sec != toc)
9069                     used[val >> 3] = 1;
9070                   /* For the toc section, we only mark as used if this
9071                      entry itself isn't unused.  */
9072                   else if ((used[rel->r_offset >> 3]
9073                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9074                            && !used[val >> 3])
9075                     {
9076                       /* Do all the relocs again, to catch reference
9077                          chains.  */
9078                       repeat = 1;
9079                       used[val >> 3] = 1;
9080                     }
9081                 }
9082             }
9083           while (repeat);
9084
9085           if (elf_section_data (sec)->relocs != relstart)
9086             free (relstart);
9087         }
9088
9089       /* Merge the used and skip arrays.  Assume that TOC
9090          doublewords not appearing as either used or unused belong
9091          to to an entry more than one doubleword in size.  */
9092       for (drop = skip, keep = used, last = 0, some_unused = 0;
9093            drop < skip + (toc->size + 7) / 8;
9094            ++drop, ++keep)
9095         {
9096           if (*keep)
9097             {
9098               *drop &= ~ref_from_discarded;
9099               if ((*drop & can_optimize) != 0)
9100                 some_unused = 1;
9101               last = 0;
9102             }
9103           else if ((*drop & ref_from_discarded) != 0)
9104             {
9105               some_unused = 1;
9106               last = ref_from_discarded;
9107             }
9108           else
9109             *drop = last;
9110         }
9111
9112       free (used);
9113
9114       if (some_unused)
9115         {
9116           bfd_byte *contents, *src;
9117           unsigned long off;
9118           Elf_Internal_Sym *sym;
9119           bfd_boolean local_toc_syms = FALSE;
9120
9121           /* Shuffle the toc contents, and at the same time convert the
9122              skip array from booleans into offsets.  */
9123           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9124             goto error_ret;
9125
9126           elf_section_data (toc)->this_hdr.contents = contents;
9127
9128           for (src = contents, off = 0, drop = skip;
9129                src < contents + toc->size;
9130                src += 8, ++drop)
9131             {
9132               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9133                 off += 8;
9134               else if (off != 0)
9135                 {
9136                   *drop = off;
9137                   memcpy (src - off, src, 8);
9138                 }
9139             }
9140           *drop = off;
9141           toc->rawsize = toc->size;
9142           toc->size = src - contents - off;
9143
9144           /* Adjust addends for relocs against the toc section sym,
9145              and optimize any accesses we can.  */
9146           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9147             {
9148               if (sec->reloc_count == 0
9149                   || discarded_section (sec))
9150                 continue;
9151
9152               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9153                                                     info->keep_memory);
9154               if (relstart == NULL)
9155                 goto error_ret;
9156
9157               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9158                 {
9159                   enum elf_ppc64_reloc_type r_type;
9160                   unsigned long r_symndx;
9161                   asection *sym_sec;
9162                   struct elf_link_hash_entry *h;
9163                   bfd_vma val;
9164
9165                   r_type = ELF64_R_TYPE (rel->r_info);
9166                   switch (r_type)
9167                     {
9168                     default:
9169                       continue;
9170
9171                     case R_PPC64_TOC16:
9172                     case R_PPC64_TOC16_LO:
9173                     case R_PPC64_TOC16_HI:
9174                     case R_PPC64_TOC16_HA:
9175                     case R_PPC64_TOC16_DS:
9176                     case R_PPC64_TOC16_LO_DS:
9177                     case R_PPC64_ADDR64:
9178                       break;
9179                     }
9180
9181                   r_symndx = ELF64_R_SYM (rel->r_info);
9182                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9183                                   r_symndx, ibfd))
9184                     goto error_ret;
9185
9186                   if (sym_sec != toc)
9187                     continue;
9188
9189                   if (h != NULL)
9190                     val = h->root.u.def.value;
9191                   else
9192                     {
9193                       val = sym->st_value;
9194                       if (val != 0)
9195                         local_toc_syms = TRUE;
9196                     }
9197
9198                   val += rel->r_addend;
9199
9200                   if (val > toc->rawsize)
9201                     val = toc->rawsize;
9202                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9203                     continue;
9204                   else if ((skip[val >> 3] & can_optimize) != 0)
9205                     {
9206                       Elf_Internal_Rela *tocrel
9207                         = toc_relocs + (skip[val >> 3] >> 2);
9208                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9209
9210                       switch (r_type)
9211                         {
9212                         case R_PPC64_TOC16_HA:
9213                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9214                           break;
9215
9216                         case R_PPC64_TOC16_LO_DS:
9217                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9218                           break;
9219
9220                         default:
9221                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9222                             ppc_howto_init ();
9223                           info->callbacks->einfo
9224                             (_("%P: %H: %s references "
9225                                "optimized away TOC entry\n"),
9226                              ibfd, sec, rel->r_offset,
9227                              ppc64_elf_howto_table[r_type]->name);
9228                           bfd_set_error (bfd_error_bad_value);
9229                           goto error_ret;
9230                         }
9231                       rel->r_addend = tocrel->r_addend;
9232                       elf_section_data (sec)->relocs = relstart;
9233                       continue;
9234                     }
9235
9236                   if (h != NULL || sym->st_value != 0)
9237                     continue;
9238
9239                   rel->r_addend -= skip[val >> 3];
9240                   elf_section_data (sec)->relocs = relstart;
9241                 }
9242
9243               if (elf_section_data (sec)->relocs != relstart)
9244                 free (relstart);
9245             }
9246
9247           /* We shouldn't have local or global symbols defined in the TOC,
9248              but handle them anyway.  */
9249           if (local_syms != NULL)
9250             for (sym = local_syms;
9251                  sym < local_syms + symtab_hdr->sh_info;
9252                  ++sym)
9253               if (sym->st_value != 0
9254                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9255                 {
9256                   unsigned long i;
9257
9258                   if (sym->st_value > toc->rawsize)
9259                     i = toc->rawsize >> 3;
9260                   else
9261                     i = sym->st_value >> 3;
9262
9263                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9264                     {
9265                       if (local_toc_syms)
9266                         (*_bfd_error_handler)
9267                           (_("%s defined on removed toc entry"),
9268                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9269                       do
9270                         ++i;
9271                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9272                       sym->st_value = (bfd_vma) i << 3;
9273                     }
9274
9275                   sym->st_value -= skip[i];
9276                   symtab_hdr->contents = (unsigned char *) local_syms;
9277                 }
9278
9279           /* Adjust any global syms defined in this toc input section.  */
9280           if (toc_inf.global_toc_syms)
9281             {
9282               toc_inf.toc = toc;
9283               toc_inf.skip = skip;
9284               toc_inf.global_toc_syms = FALSE;
9285               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9286                                       &toc_inf);
9287             }
9288
9289           if (toc->reloc_count != 0)
9290             {
9291               Elf_Internal_Shdr *rel_hdr;
9292               Elf_Internal_Rela *wrel;
9293               bfd_size_type sz;
9294
9295               /* Remove unused toc relocs, and adjust those we keep.  */
9296               if (toc_relocs == NULL)
9297                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9298                                                         info->keep_memory);
9299               if (toc_relocs == NULL)
9300                 goto error_ret;
9301
9302               wrel = toc_relocs;
9303               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9304                 if ((skip[rel->r_offset >> 3]
9305                      & (ref_from_discarded | can_optimize)) == 0)
9306                   {
9307                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9308                     wrel->r_info = rel->r_info;
9309                     wrel->r_addend = rel->r_addend;
9310                     ++wrel;
9311                   }
9312                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9313                                             &local_syms, NULL, NULL))
9314                   goto error_ret;
9315
9316               elf_section_data (toc)->relocs = toc_relocs;
9317               toc->reloc_count = wrel - toc_relocs;
9318               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9319               sz = rel_hdr->sh_entsize;
9320               rel_hdr->sh_size = toc->reloc_count * sz;
9321             }
9322         }
9323       else if (toc_relocs != NULL
9324                && elf_section_data (toc)->relocs != toc_relocs)
9325         free (toc_relocs);
9326
9327       if (local_syms != NULL
9328           && symtab_hdr->contents != (unsigned char *) local_syms)
9329         {
9330           if (!info->keep_memory)
9331             free (local_syms);
9332           else
9333             symtab_hdr->contents = (unsigned char *) local_syms;
9334         }
9335       free (skip);
9336     }
9337
9338   return TRUE;
9339 }
9340
9341 /* Return true iff input section I references the TOC using
9342    instructions limited to +/-32k offsets.  */
9343
9344 bfd_boolean
9345 ppc64_elf_has_small_toc_reloc (asection *i)
9346 {
9347   return (is_ppc64_elf (i->owner)
9348           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9349 }
9350
9351 /* Allocate space for one GOT entry.  */
9352
9353 static void
9354 allocate_got (struct elf_link_hash_entry *h,
9355               struct bfd_link_info *info,
9356               struct got_entry *gent)
9357 {
9358   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9359   bfd_boolean dyn;
9360   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9361   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9362                  ? 16 : 8);
9363   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9364                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9365   asection *got = ppc64_elf_tdata (gent->owner)->got;
9366
9367   gent->got.offset = got->size;
9368   got->size += entsize;
9369
9370   dyn = htab->elf.dynamic_sections_created;
9371   if (h->type == STT_GNU_IFUNC)
9372     {
9373       htab->elf.irelplt->size += rentsize;
9374       htab->got_reli_size += rentsize;
9375     }
9376   else if ((info->shared
9377             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9378            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9379                || h->root.type != bfd_link_hash_undefweak))
9380     {
9381       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9382       relgot->size += rentsize;
9383     }
9384 }
9385
9386 /* This function merges got entries in the same toc group.  */
9387
9388 static void
9389 merge_got_entries (struct got_entry **pent)
9390 {
9391   struct got_entry *ent, *ent2;
9392
9393   for (ent = *pent; ent != NULL; ent = ent->next)
9394     if (!ent->is_indirect)
9395       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9396         if (!ent2->is_indirect
9397             && ent2->addend == ent->addend
9398             && ent2->tls_type == ent->tls_type
9399             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9400           {
9401             ent2->is_indirect = TRUE;
9402             ent2->got.ent = ent;
9403           }
9404 }
9405
9406 /* Allocate space in .plt, .got and associated reloc sections for
9407    dynamic relocs.  */
9408
9409 static bfd_boolean
9410 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9411 {
9412   struct bfd_link_info *info;
9413   struct ppc_link_hash_table *htab;
9414   asection *s;
9415   struct ppc_link_hash_entry *eh;
9416   struct elf_dyn_relocs *p;
9417   struct got_entry **pgent, *gent;
9418
9419   if (h->root.type == bfd_link_hash_indirect)
9420     return TRUE;
9421
9422   info = (struct bfd_link_info *) inf;
9423   htab = ppc_hash_table (info);
9424   if (htab == NULL)
9425     return FALSE;
9426
9427   if ((htab->elf.dynamic_sections_created
9428        && h->dynindx != -1
9429        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9430       || h->type == STT_GNU_IFUNC)
9431     {
9432       struct plt_entry *pent;
9433       bfd_boolean doneone = FALSE;
9434       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9435         if (pent->plt.refcount > 0)
9436           {
9437             if (!htab->elf.dynamic_sections_created
9438                 || h->dynindx == -1)
9439               {
9440                 s = htab->elf.iplt;
9441                 pent->plt.offset = s->size;
9442                 s->size += PLT_ENTRY_SIZE (htab);
9443                 s = htab->elf.irelplt;
9444               }
9445             else
9446               {
9447                 /* If this is the first .plt entry, make room for the special
9448                    first entry.  */
9449                 s = htab->elf.splt;
9450                 if (s->size == 0)
9451                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9452
9453                 pent->plt.offset = s->size;
9454
9455                 /* Make room for this entry.  */
9456                 s->size += PLT_ENTRY_SIZE (htab);
9457
9458                 /* Make room for the .glink code.  */
9459                 s = htab->glink;
9460                 if (s->size == 0)
9461                   s->size += GLINK_CALL_STUB_SIZE;
9462                 if (htab->opd_abi)
9463                   {
9464                     /* We need bigger stubs past index 32767.  */
9465                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9466                       s->size += 4;
9467                     s->size += 2*4;
9468                   }
9469                 else
9470                   s->size += 4;
9471
9472                 /* We also need to make an entry in the .rela.plt section.  */
9473                 s = htab->elf.srelplt;
9474               }
9475             s->size += sizeof (Elf64_External_Rela);
9476             doneone = TRUE;
9477           }
9478         else
9479           pent->plt.offset = (bfd_vma) -1;
9480       if (!doneone)
9481         {
9482           h->plt.plist = NULL;
9483           h->needs_plt = 0;
9484         }
9485     }
9486   else
9487     {
9488       h->plt.plist = NULL;
9489       h->needs_plt = 0;
9490     }
9491
9492   eh = (struct ppc_link_hash_entry *) h;
9493   /* Run through the TLS GD got entries first if we're changing them
9494      to TPREL.  */
9495   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9496     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9497       if (gent->got.refcount > 0
9498           && (gent->tls_type & TLS_GD) != 0)
9499         {
9500           /* This was a GD entry that has been converted to TPREL.  If
9501              there happens to be a TPREL entry we can use that one.  */
9502           struct got_entry *ent;
9503           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9504             if (ent->got.refcount > 0
9505                 && (ent->tls_type & TLS_TPREL) != 0
9506                 && ent->addend == gent->addend
9507                 && ent->owner == gent->owner)
9508               {
9509                 gent->got.refcount = 0;
9510                 break;
9511               }
9512
9513           /* If not, then we'll be using our own TPREL entry.  */
9514           if (gent->got.refcount != 0)
9515             gent->tls_type = TLS_TLS | TLS_TPREL;
9516         }
9517
9518   /* Remove any list entry that won't generate a word in the GOT before
9519      we call merge_got_entries.  Otherwise we risk merging to empty
9520      entries.  */
9521   pgent = &h->got.glist;
9522   while ((gent = *pgent) != NULL)
9523     if (gent->got.refcount > 0)
9524       {
9525         if ((gent->tls_type & TLS_LD) != 0
9526             && !h->def_dynamic)
9527           {
9528             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9529             *pgent = gent->next;
9530           }
9531         else
9532           pgent = &gent->next;
9533       }
9534     else
9535       *pgent = gent->next;
9536
9537   if (!htab->do_multi_toc)
9538     merge_got_entries (&h->got.glist);
9539
9540   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9541     if (!gent->is_indirect)
9542       {
9543         /* Make sure this symbol is output as a dynamic symbol.
9544            Undefined weak syms won't yet be marked as dynamic,
9545            nor will all TLS symbols.  */
9546         if (h->dynindx == -1
9547             && !h->forced_local
9548             && h->type != STT_GNU_IFUNC
9549             && htab->elf.dynamic_sections_created)
9550           {
9551             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9552               return FALSE;
9553           }
9554
9555         if (!is_ppc64_elf (gent->owner))
9556           abort ();
9557
9558         allocate_got (h, info, gent);
9559       }
9560
9561   if (eh->dyn_relocs == NULL
9562       || (!htab->elf.dynamic_sections_created
9563           && h->type != STT_GNU_IFUNC))
9564     return TRUE;
9565
9566   /* In the shared -Bsymbolic case, discard space allocated for
9567      dynamic pc-relative relocs against symbols which turn out to be
9568      defined in regular objects.  For the normal shared case, discard
9569      space for relocs that have become local due to symbol visibility
9570      changes.  */
9571
9572   if (info->shared)
9573     {
9574       /* Relocs that use pc_count are those that appear on a call insn,
9575          or certain REL relocs (see must_be_dyn_reloc) that can be
9576          generated via assembly.  We want calls to protected symbols to
9577          resolve directly to the function rather than going via the plt.
9578          If people want function pointer comparisons to work as expected
9579          then they should avoid writing weird assembly.  */
9580       if (SYMBOL_CALLS_LOCAL (info, h))
9581         {
9582           struct elf_dyn_relocs **pp;
9583
9584           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9585             {
9586               p->count -= p->pc_count;
9587               p->pc_count = 0;
9588               if (p->count == 0)
9589                 *pp = p->next;
9590               else
9591                 pp = &p->next;
9592             }
9593         }
9594
9595       /* Also discard relocs on undefined weak syms with non-default
9596          visibility.  */
9597       if (eh->dyn_relocs != NULL
9598           && h->root.type == bfd_link_hash_undefweak)
9599         {
9600           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9601             eh->dyn_relocs = NULL;
9602
9603           /* Make sure this symbol is output as a dynamic symbol.
9604              Undefined weak syms won't yet be marked as dynamic.  */
9605           else if (h->dynindx == -1
9606                    && !h->forced_local)
9607             {
9608               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9609                 return FALSE;
9610             }
9611         }
9612     }
9613   else if (h->type == STT_GNU_IFUNC)
9614     {
9615       if (!h->non_got_ref)
9616         eh->dyn_relocs = NULL;
9617     }
9618   else if (ELIMINATE_COPY_RELOCS)
9619     {
9620       /* For the non-shared case, discard space for relocs against
9621          symbols which turn out to need copy relocs or are not
9622          dynamic.  */
9623
9624       if (!h->non_got_ref
9625           && !h->def_regular)
9626         {
9627           /* Make sure this symbol is output as a dynamic symbol.
9628              Undefined weak syms won't yet be marked as dynamic.  */
9629           if (h->dynindx == -1
9630               && !h->forced_local)
9631             {
9632               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9633                 return FALSE;
9634             }
9635
9636           /* If that succeeded, we know we'll be keeping all the
9637              relocs.  */
9638           if (h->dynindx != -1)
9639             goto keep;
9640         }
9641
9642       eh->dyn_relocs = NULL;
9643
9644     keep: ;
9645     }
9646
9647   /* Finally, allocate space.  */
9648   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9649     {
9650       asection *sreloc = elf_section_data (p->sec)->sreloc;
9651       if (eh->elf.type == STT_GNU_IFUNC)
9652         sreloc = htab->elf.irelplt;
9653       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9654     }
9655
9656   return TRUE;
9657 }
9658
9659 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9660    to set up space for global entry stubs.  These are put in glink,
9661    after the branch table.  */
9662
9663 static bfd_boolean
9664 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9665 {
9666   struct bfd_link_info *info;
9667   struct ppc_link_hash_table *htab;
9668   struct plt_entry *pent;
9669   asection *s;
9670
9671   if (h->root.type == bfd_link_hash_indirect)
9672     return TRUE;
9673
9674   if (!h->pointer_equality_needed)
9675     return TRUE;
9676
9677   if (h->def_regular)
9678     return TRUE;
9679
9680   info = inf;
9681   htab = ppc_hash_table (info);
9682   if (htab == NULL)
9683     return FALSE;
9684
9685   s = htab->glink;
9686   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9687     if (pent->plt.offset != (bfd_vma) -1
9688         && pent->addend == 0)
9689       {
9690         /* For ELFv2, if this symbol is not defined in a regular file
9691            and we are not generating a shared library or pie, then we
9692            need to define the symbol in the executable on a call stub.
9693            This is to avoid text relocations.  */
9694         s->size = (s->size + 15) & -16;
9695         h->root.u.def.section = s;
9696         h->root.u.def.value = s->size;
9697         s->size += 16;
9698         break;
9699       }
9700   return TRUE;
9701 }
9702
9703 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9704    read-only sections.  */
9705
9706 static bfd_boolean
9707 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9708 {
9709   if (h->root.type == bfd_link_hash_indirect)
9710     return TRUE;
9711
9712   if (readonly_dynrelocs (h))
9713     {
9714       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9715
9716       /* Not an error, just cut short the traversal.  */
9717       return FALSE;
9718     }
9719   return TRUE;
9720 }
9721
9722 /* Set the sizes of the dynamic sections.  */
9723
9724 static bfd_boolean
9725 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9726                                  struct bfd_link_info *info)
9727 {
9728   struct ppc_link_hash_table *htab;
9729   bfd *dynobj;
9730   asection *s;
9731   bfd_boolean relocs;
9732   bfd *ibfd;
9733   struct got_entry *first_tlsld;
9734
9735   htab = ppc_hash_table (info);
9736   if (htab == NULL)
9737     return FALSE;
9738
9739   dynobj = htab->elf.dynobj;
9740   if (dynobj == NULL)
9741     abort ();
9742
9743   if (htab->elf.dynamic_sections_created)
9744     {
9745       /* Set the contents of the .interp section to the interpreter.  */
9746       if (info->executable)
9747         {
9748           s = bfd_get_linker_section (dynobj, ".interp");
9749           if (s == NULL)
9750             abort ();
9751           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9752           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9753         }
9754     }
9755
9756   /* Set up .got offsets for local syms, and space for local dynamic
9757      relocs.  */
9758   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9759     {
9760       struct got_entry **lgot_ents;
9761       struct got_entry **end_lgot_ents;
9762       struct plt_entry **local_plt;
9763       struct plt_entry **end_local_plt;
9764       unsigned char *lgot_masks;
9765       bfd_size_type locsymcount;
9766       Elf_Internal_Shdr *symtab_hdr;
9767
9768       if (!is_ppc64_elf (ibfd))
9769         continue;
9770
9771       for (s = ibfd->sections; s != NULL; s = s->next)
9772         {
9773           struct ppc_dyn_relocs *p;
9774
9775           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9776             {
9777               if (!bfd_is_abs_section (p->sec)
9778                   && bfd_is_abs_section (p->sec->output_section))
9779                 {
9780                   /* Input section has been discarded, either because
9781                      it is a copy of a linkonce section or due to
9782                      linker script /DISCARD/, so we'll be discarding
9783                      the relocs too.  */
9784                 }
9785               else if (p->count != 0)
9786                 {
9787                   asection *srel = elf_section_data (p->sec)->sreloc;
9788                   if (p->ifunc)
9789                     srel = htab->elf.irelplt;
9790                   srel->size += p->count * sizeof (Elf64_External_Rela);
9791                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9792                     info->flags |= DF_TEXTREL;
9793                 }
9794             }
9795         }
9796
9797       lgot_ents = elf_local_got_ents (ibfd);
9798       if (!lgot_ents)
9799         continue;
9800
9801       symtab_hdr = &elf_symtab_hdr (ibfd);
9802       locsymcount = symtab_hdr->sh_info;
9803       end_lgot_ents = lgot_ents + locsymcount;
9804       local_plt = (struct plt_entry **) end_lgot_ents;
9805       end_local_plt = local_plt + locsymcount;
9806       lgot_masks = (unsigned char *) end_local_plt;
9807       s = ppc64_elf_tdata (ibfd)->got;
9808       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9809         {
9810           struct got_entry **pent, *ent;
9811
9812           pent = lgot_ents;
9813           while ((ent = *pent) != NULL)
9814             if (ent->got.refcount > 0)
9815               {
9816                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9817                   {
9818                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9819                     *pent = ent->next;
9820                   }
9821                 else
9822                   {
9823                     unsigned int ent_size = 8;
9824                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9825
9826                     ent->got.offset = s->size;
9827                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9828                       {
9829                         ent_size *= 2;
9830                         rel_size *= 2;
9831                       }
9832                     s->size += ent_size;
9833                     if ((*lgot_masks & PLT_IFUNC) != 0)
9834                       {
9835                         htab->elf.irelplt->size += rel_size;
9836                         htab->got_reli_size += rel_size;
9837                       }
9838                     else if (info->shared)
9839                       {
9840                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9841                         srel->size += rel_size;
9842                       }
9843                     pent = &ent->next;
9844                   }
9845               }
9846             else
9847               *pent = ent->next;
9848         }
9849
9850       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9851       for (; local_plt < end_local_plt; ++local_plt)
9852         {
9853           struct plt_entry *ent;
9854
9855           for (ent = *local_plt; ent != NULL; ent = ent->next)
9856             if (ent->plt.refcount > 0)
9857               {
9858                 s = htab->elf.iplt;
9859                 ent->plt.offset = s->size;
9860                 s->size += PLT_ENTRY_SIZE (htab);
9861
9862                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9863               }
9864             else
9865               ent->plt.offset = (bfd_vma) -1;
9866         }
9867     }
9868
9869   /* Allocate global sym .plt and .got entries, and space for global
9870      sym dynamic relocs.  */
9871   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9872   /* Stash the end of glink branch table.  */
9873   if (htab->glink != NULL)
9874     htab->glink->rawsize = htab->glink->size;
9875
9876   if (!htab->opd_abi && !info->shared)
9877     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9878
9879   first_tlsld = NULL;
9880   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9881     {
9882       struct got_entry *ent;
9883
9884       if (!is_ppc64_elf (ibfd))
9885         continue;
9886
9887       ent = ppc64_tlsld_got (ibfd);
9888       if (ent->got.refcount > 0)
9889         {
9890           if (!htab->do_multi_toc && first_tlsld != NULL)
9891             {
9892               ent->is_indirect = TRUE;
9893               ent->got.ent = first_tlsld;
9894             }
9895           else
9896             {
9897               if (first_tlsld == NULL)
9898                 first_tlsld = ent;
9899               s = ppc64_elf_tdata (ibfd)->got;
9900               ent->got.offset = s->size;
9901               ent->owner = ibfd;
9902               s->size += 16;
9903               if (info->shared)
9904                 {
9905                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9906                   srel->size += sizeof (Elf64_External_Rela);
9907                 }
9908             }
9909         }
9910       else
9911         ent->got.offset = (bfd_vma) -1;
9912     }
9913
9914   /* We now have determined the sizes of the various dynamic sections.
9915      Allocate memory for them.  */
9916   relocs = FALSE;
9917   for (s = dynobj->sections; s != NULL; s = s->next)
9918     {
9919       if ((s->flags & SEC_LINKER_CREATED) == 0)
9920         continue;
9921
9922       if (s == htab->brlt || s == htab->relbrlt)
9923         /* These haven't been allocated yet;  don't strip.  */
9924         continue;
9925       else if (s == htab->elf.sgot
9926                || s == htab->elf.splt
9927                || s == htab->elf.iplt
9928                || s == htab->glink
9929                || s == htab->dynbss)
9930         {
9931           /* Strip this section if we don't need it; see the
9932              comment below.  */
9933         }
9934       else if (s == htab->glink_eh_frame)
9935         {
9936           if (!bfd_is_abs_section (s->output_section))
9937             /* Not sized yet.  */
9938             continue;
9939         }
9940       else if (CONST_STRNEQ (s->name, ".rela"))
9941         {
9942           if (s->size != 0)
9943             {
9944               if (s != htab->elf.srelplt)
9945                 relocs = TRUE;
9946
9947               /* We use the reloc_count field as a counter if we need
9948                  to copy relocs into the output file.  */
9949               s->reloc_count = 0;
9950             }
9951         }
9952       else
9953         {
9954           /* It's not one of our sections, so don't allocate space.  */
9955           continue;
9956         }
9957
9958       if (s->size == 0)
9959         {
9960           /* If we don't need this section, strip it from the
9961              output file.  This is mostly to handle .rela.bss and
9962              .rela.plt.  We must create both sections in
9963              create_dynamic_sections, because they must be created
9964              before the linker maps input sections to output
9965              sections.  The linker does that before
9966              adjust_dynamic_symbol is called, and it is that
9967              function which decides whether anything needs to go
9968              into these sections.  */
9969           s->flags |= SEC_EXCLUDE;
9970           continue;
9971         }
9972
9973       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9974         continue;
9975
9976       /* Allocate memory for the section contents.  We use bfd_zalloc
9977          here in case unused entries are not reclaimed before the
9978          section's contents are written out.  This should not happen,
9979          but this way if it does we get a R_PPC64_NONE reloc in .rela
9980          sections instead of garbage.
9981          We also rely on the section contents being zero when writing
9982          the GOT.  */
9983       s->contents = bfd_zalloc (dynobj, s->size);
9984       if (s->contents == NULL)
9985         return FALSE;
9986     }
9987
9988   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9989     {
9990       if (!is_ppc64_elf (ibfd))
9991         continue;
9992
9993       s = ppc64_elf_tdata (ibfd)->got;
9994       if (s != NULL && s != htab->elf.sgot)
9995         {
9996           if (s->size == 0)
9997             s->flags |= SEC_EXCLUDE;
9998           else
9999             {
10000               s->contents = bfd_zalloc (ibfd, s->size);
10001               if (s->contents == NULL)
10002                 return FALSE;
10003             }
10004         }
10005       s = ppc64_elf_tdata (ibfd)->relgot;
10006       if (s != NULL)
10007         {
10008           if (s->size == 0)
10009             s->flags |= SEC_EXCLUDE;
10010           else
10011             {
10012               s->contents = bfd_zalloc (ibfd, s->size);
10013               if (s->contents == NULL)
10014                 return FALSE;
10015               relocs = TRUE;
10016               s->reloc_count = 0;
10017             }
10018         }
10019     }
10020
10021   if (htab->elf.dynamic_sections_created)
10022     {
10023       bfd_boolean tls_opt;
10024
10025       /* Add some entries to the .dynamic section.  We fill in the
10026          values later, in ppc64_elf_finish_dynamic_sections, but we
10027          must add the entries now so that we get the correct size for
10028          the .dynamic section.  The DT_DEBUG entry is filled in by the
10029          dynamic linker and used by the debugger.  */
10030 #define add_dynamic_entry(TAG, VAL) \
10031   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10032
10033       if (info->executable)
10034         {
10035           if (!add_dynamic_entry (DT_DEBUG, 0))
10036             return FALSE;
10037         }
10038
10039       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10040         {
10041           if (!add_dynamic_entry (DT_PLTGOT, 0)
10042               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10043               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10044               || !add_dynamic_entry (DT_JMPREL, 0)
10045               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10046             return FALSE;
10047         }
10048
10049       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10050         {
10051           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10052               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10053             return FALSE;
10054         }
10055
10056       tls_opt = (!htab->params->no_tls_get_addr_opt
10057                  && htab->tls_get_addr_fd != NULL
10058                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10059       if (tls_opt || !htab->opd_abi)
10060         {
10061           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10062             return FALSE;
10063         }
10064
10065       if (relocs)
10066         {
10067           if (!add_dynamic_entry (DT_RELA, 0)
10068               || !add_dynamic_entry (DT_RELASZ, 0)
10069               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10070             return FALSE;
10071
10072           /* If any dynamic relocs apply to a read-only section,
10073              then we need a DT_TEXTREL entry.  */
10074           if ((info->flags & DF_TEXTREL) == 0)
10075             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10076
10077           if ((info->flags & DF_TEXTREL) != 0)
10078             {
10079               if (!add_dynamic_entry (DT_TEXTREL, 0))
10080                 return FALSE;
10081             }
10082         }
10083     }
10084 #undef add_dynamic_entry
10085
10086   return TRUE;
10087 }
10088
10089 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10090
10091 static bfd_boolean
10092 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10093 {
10094   if (h->plt.plist != NULL
10095       && !h->def_regular
10096       && !h->pointer_equality_needed)
10097     return FALSE;
10098
10099   return _bfd_elf_hash_symbol (h);
10100 }
10101
10102 /* Determine the type of stub needed, if any, for a call.  */
10103
10104 static inline enum ppc_stub_type
10105 ppc_type_of_stub (asection *input_sec,
10106                   const Elf_Internal_Rela *rel,
10107                   struct ppc_link_hash_entry **hash,
10108                   struct plt_entry **plt_ent,
10109                   bfd_vma destination,
10110                   unsigned long local_off)
10111 {
10112   struct ppc_link_hash_entry *h = *hash;
10113   bfd_vma location;
10114   bfd_vma branch_offset;
10115   bfd_vma max_branch_offset;
10116   enum elf_ppc64_reloc_type r_type;
10117
10118   if (h != NULL)
10119     {
10120       struct plt_entry *ent;
10121       struct ppc_link_hash_entry *fdh = h;
10122       if (h->oh != NULL
10123           && h->oh->is_func_descriptor)
10124         {
10125           fdh = ppc_follow_link (h->oh);
10126           *hash = fdh;
10127         }
10128
10129       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10130         if (ent->addend == rel->r_addend
10131             && ent->plt.offset != (bfd_vma) -1)
10132           {
10133             *plt_ent = ent;
10134             return ppc_stub_plt_call;
10135           }
10136
10137       /* Here, we know we don't have a plt entry.  If we don't have a
10138          either a defined function descriptor or a defined entry symbol
10139          in a regular object file, then it is pointless trying to make
10140          any other type of stub.  */
10141       if (!is_static_defined (&fdh->elf)
10142           && !is_static_defined (&h->elf))
10143         return ppc_stub_none;
10144     }
10145   else if (elf_local_got_ents (input_sec->owner) != NULL)
10146     {
10147       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10148       struct plt_entry **local_plt = (struct plt_entry **)
10149         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10150       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10151
10152       if (local_plt[r_symndx] != NULL)
10153         {
10154           struct plt_entry *ent;
10155
10156           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10157             if (ent->addend == rel->r_addend
10158                 && ent->plt.offset != (bfd_vma) -1)
10159               {
10160                 *plt_ent = ent;
10161                 return ppc_stub_plt_call;
10162               }
10163         }
10164     }
10165
10166   /* Determine where the call point is.  */
10167   location = (input_sec->output_offset
10168               + input_sec->output_section->vma
10169               + rel->r_offset);
10170
10171   branch_offset = destination - location;
10172   r_type = ELF64_R_TYPE (rel->r_info);
10173
10174   /* Determine if a long branch stub is needed.  */
10175   max_branch_offset = 1 << 25;
10176   if (r_type != R_PPC64_REL24)
10177     max_branch_offset = 1 << 15;
10178
10179   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10180     /* We need a stub.  Figure out whether a long_branch or plt_branch
10181        is needed later.  */
10182     return ppc_stub_long_branch;
10183
10184   return ppc_stub_none;
10185 }
10186
10187 /* With power7 weakly ordered memory model, it is possible for ld.so
10188    to update a plt entry in one thread and have another thread see a
10189    stale zero toc entry.  To avoid this we need some sort of acquire
10190    barrier in the call stub.  One solution is to make the load of the
10191    toc word seem to appear to depend on the load of the function entry
10192    word.  Another solution is to test for r2 being zero, and branch to
10193    the appropriate glink entry if so.
10194
10195    .    fake dep barrier        compare
10196    .    ld 12,xxx(2)            ld 12,xxx(2)
10197    .    mtctr 12                mtctr 12
10198    .    xor 11,12,12            ld 2,xxx+8(2)
10199    .    add 2,2,11              cmpldi 2,0
10200    .    ld 2,xxx+8(2)           bnectr+
10201    .    bctr                    b <glink_entry>
10202
10203    The solution involving the compare turns out to be faster, so
10204    that's what we use unless the branch won't reach.  */
10205
10206 #define ALWAYS_USE_FAKE_DEP 0
10207 #define ALWAYS_EMIT_R2SAVE 0
10208
10209 #define PPC_LO(v) ((v) & 0xffff)
10210 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10211 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10212
10213 static inline unsigned int
10214 plt_stub_size (struct ppc_link_hash_table *htab,
10215                struct ppc_stub_hash_entry *stub_entry,
10216                bfd_vma off)
10217 {
10218   unsigned size = 12;
10219
10220   if (ALWAYS_EMIT_R2SAVE
10221       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10222     size += 4;
10223   if (PPC_HA (off) != 0)
10224     size += 4;
10225   if (htab->opd_abi)
10226     {
10227       size += 4;
10228       if (htab->params->plt_static_chain)
10229         size += 4;
10230       if (htab->params->plt_thread_safe
10231           && htab->elf.dynamic_sections_created
10232           && stub_entry->h != NULL
10233           && stub_entry->h->elf.dynindx != -1)
10234         size += 8;
10235       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10236         size += 4;
10237     }
10238   if (stub_entry->h != NULL
10239       && (stub_entry->h == htab->tls_get_addr_fd
10240           || stub_entry->h == htab->tls_get_addr)
10241       && !htab->params->no_tls_get_addr_opt)
10242     size += 13 * 4;
10243   return size;
10244 }
10245
10246 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10247    then return the padding needed to do so.  */
10248 static inline unsigned int
10249 plt_stub_pad (struct ppc_link_hash_table *htab,
10250               struct ppc_stub_hash_entry *stub_entry,
10251               bfd_vma plt_off)
10252 {
10253   int stub_align = 1 << htab->params->plt_stub_align;
10254   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10255   bfd_vma stub_off = stub_entry->stub_sec->size;
10256
10257   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10258       > ((stub_size - 1) & -stub_align))
10259     return stub_align - (stub_off & (stub_align - 1));
10260   return 0;
10261 }
10262
10263 /* Build a .plt call stub.  */
10264
10265 static inline bfd_byte *
10266 build_plt_stub (struct ppc_link_hash_table *htab,
10267                 struct ppc_stub_hash_entry *stub_entry,
10268                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10269 {
10270   bfd *obfd = htab->params->stub_bfd;
10271   bfd_boolean plt_load_toc = htab->opd_abi;
10272   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10273   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10274                                  && htab->elf.dynamic_sections_created
10275                                  && stub_entry->h != NULL
10276                                  && stub_entry->h->elf.dynindx != -1);
10277   bfd_boolean use_fake_dep = plt_thread_safe;
10278   bfd_vma cmp_branch_off = 0;
10279
10280   if (!ALWAYS_USE_FAKE_DEP
10281       && plt_load_toc
10282       && plt_thread_safe
10283       && !((stub_entry->h == htab->tls_get_addr_fd
10284             || stub_entry->h == htab->tls_get_addr)
10285            && !htab->params->no_tls_get_addr_opt))
10286     {
10287       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10288       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10289                           / PLT_ENTRY_SIZE (htab));
10290       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10291       bfd_vma to, from;
10292
10293       if (pltindex > 32768)
10294         glinkoff += (pltindex - 32768) * 4;
10295       to = (glinkoff
10296             + htab->glink->output_offset
10297             + htab->glink->output_section->vma);
10298       from = (p - stub_entry->stub_sec->contents
10299               + 4 * (ALWAYS_EMIT_R2SAVE
10300                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10301               + 4 * (PPC_HA (offset) != 0)
10302               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10303                      != PPC_HA (offset))
10304               + 4 * (plt_static_chain != 0)
10305               + 20
10306               + stub_entry->stub_sec->output_offset
10307               + stub_entry->stub_sec->output_section->vma);
10308       cmp_branch_off = to - from;
10309       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10310     }
10311
10312   if (PPC_HA (offset) != 0)
10313     {
10314       if (r != NULL)
10315         {
10316           if (ALWAYS_EMIT_R2SAVE
10317               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10318             r[0].r_offset += 4;
10319           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10320           r[1].r_offset = r[0].r_offset + 4;
10321           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10322           r[1].r_addend = r[0].r_addend;
10323           if (plt_load_toc)
10324             {
10325               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10326                 {
10327                   r[2].r_offset = r[1].r_offset + 4;
10328                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10329                   r[2].r_addend = r[0].r_addend;
10330                 }
10331               else
10332                 {
10333                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10334                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10335                   r[2].r_addend = r[0].r_addend + 8;
10336                   if (plt_static_chain)
10337                     {
10338                       r[3].r_offset = r[2].r_offset + 4;
10339                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10340                       r[3].r_addend = r[0].r_addend + 16;
10341                     }
10342                 }
10343             }
10344         }
10345       if (ALWAYS_EMIT_R2SAVE
10346           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10347         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10348       if (plt_load_toc)
10349         {
10350           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10351           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10352         }
10353       else
10354         {
10355           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10356           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10357         }
10358       if (plt_load_toc
10359           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10360         {
10361           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10362           offset = 0;
10363         }
10364       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10365       if (plt_load_toc)
10366         {
10367           if (use_fake_dep)
10368             {
10369               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10370               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10371             }
10372           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10373           if (plt_static_chain)
10374             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10375         }
10376     }
10377   else
10378     {
10379       if (r != NULL)
10380         {
10381           if (ALWAYS_EMIT_R2SAVE
10382               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10383             r[0].r_offset += 4;
10384           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10385           if (plt_load_toc)
10386             {
10387               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10388                 {
10389                   r[1].r_offset = r[0].r_offset + 4;
10390                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10391                   r[1].r_addend = r[0].r_addend;
10392                 }
10393               else
10394                 {
10395                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10396                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10397                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10398                   if (plt_static_chain)
10399                     {
10400                       r[2].r_offset = r[1].r_offset + 4;
10401                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10402                       r[2].r_addend = r[0].r_addend + 8;
10403                     }
10404                 }
10405             }
10406         }
10407       if (ALWAYS_EMIT_R2SAVE
10408           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10409         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10410       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10411       if (plt_load_toc
10412           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10413         {
10414           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10415           offset = 0;
10416         }
10417       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10418       if (plt_load_toc)
10419         {
10420           if (use_fake_dep)
10421             {
10422               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10423               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10424             }
10425           if (plt_static_chain)
10426             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10427           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10428         }
10429     }
10430   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10431     {
10432       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10433       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10434       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10435     }
10436   else
10437     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10438   return p;
10439 }
10440
10441 /* Build a special .plt call stub for __tls_get_addr.  */
10442
10443 #define LD_R11_0R3      0xe9630000
10444 #define LD_R12_0R3      0xe9830000
10445 #define MR_R0_R3        0x7c601b78
10446 #define CMPDI_R11_0     0x2c2b0000
10447 #define ADD_R3_R12_R13  0x7c6c6a14
10448 #define BEQLR           0x4d820020
10449 #define MR_R3_R0        0x7c030378
10450 #define STD_R11_0R1     0xf9610000
10451 #define BCTRL           0x4e800421
10452 #define LD_R11_0R1      0xe9610000
10453 #define MTLR_R11        0x7d6803a6
10454
10455 static inline bfd_byte *
10456 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10457                          struct ppc_stub_hash_entry *stub_entry,
10458                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10459 {
10460   bfd *obfd = htab->params->stub_bfd;
10461
10462   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10463   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10464   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10465   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10466   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10467   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10468   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10469   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10470   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10471
10472   if (r != NULL)
10473     r[0].r_offset += 9 * 4;
10474   p = build_plt_stub (htab, stub_entry, p, offset, r);
10475   bfd_put_32 (obfd, BCTRL, p - 4);
10476
10477   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10478   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10479   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10480   bfd_put_32 (obfd, BLR, p),                    p += 4;
10481
10482   return p;
10483 }
10484
10485 static Elf_Internal_Rela *
10486 get_relocs (asection *sec, int count)
10487 {
10488   Elf_Internal_Rela *relocs;
10489   struct bfd_elf_section_data *elfsec_data;
10490
10491   elfsec_data = elf_section_data (sec);
10492   relocs = elfsec_data->relocs;
10493   if (relocs == NULL)
10494     {
10495       bfd_size_type relsize;
10496       relsize = sec->reloc_count * sizeof (*relocs);
10497       relocs = bfd_alloc (sec->owner, relsize);
10498       if (relocs == NULL)
10499         return NULL;
10500       elfsec_data->relocs = relocs;
10501       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10502                                           sizeof (Elf_Internal_Shdr));
10503       if (elfsec_data->rela.hdr == NULL)
10504         return NULL;
10505       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10506                                         * sizeof (Elf64_External_Rela));
10507       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10508       sec->reloc_count = 0;
10509     }
10510   relocs += sec->reloc_count;
10511   sec->reloc_count += count;
10512   return relocs;
10513 }
10514
10515 static bfd_vma
10516 get_r2off (struct bfd_link_info *info,
10517            struct ppc_stub_hash_entry *stub_entry)
10518 {
10519   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10520   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10521
10522   if (r2off == 0)
10523     {
10524       /* Support linking -R objects.  Get the toc pointer from the
10525          opd entry.  */
10526       char buf[8];
10527       if (!htab->opd_abi)
10528         return r2off;
10529       asection *opd = stub_entry->h->elf.root.u.def.section;
10530       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10531
10532       if (strcmp (opd->name, ".opd") != 0
10533           || opd->reloc_count != 0)
10534         {
10535           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10536                                   stub_entry->h->elf.root.root.string);
10537           bfd_set_error (bfd_error_bad_value);
10538           return 0;
10539         }
10540       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10541         return 0;
10542       r2off = bfd_get_64 (opd->owner, buf);
10543       r2off -= elf_gp (info->output_bfd);
10544     }
10545   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10546   return r2off;
10547 }
10548
10549 static bfd_boolean
10550 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10551 {
10552   struct ppc_stub_hash_entry *stub_entry;
10553   struct ppc_branch_hash_entry *br_entry;
10554   struct bfd_link_info *info;
10555   struct ppc_link_hash_table *htab;
10556   bfd_byte *loc;
10557   bfd_byte *p;
10558   bfd_vma dest, off;
10559   int size;
10560   Elf_Internal_Rela *r;
10561   asection *plt;
10562
10563   /* Massage our args to the form they really have.  */
10564   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10565   info = in_arg;
10566
10567   htab = ppc_hash_table (info);
10568   if (htab == NULL)
10569     return FALSE;
10570
10571   /* Make a note of the offset within the stubs for this entry.  */
10572   stub_entry->stub_offset = stub_entry->stub_sec->size;
10573   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10574
10575   htab->stub_count[stub_entry->stub_type - 1] += 1;
10576   switch (stub_entry->stub_type)
10577     {
10578     case ppc_stub_long_branch:
10579     case ppc_stub_long_branch_r2off:
10580       /* Branches are relative.  This is where we are going to.  */
10581       dest = (stub_entry->target_value
10582               + stub_entry->target_section->output_offset
10583               + stub_entry->target_section->output_section->vma);
10584       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10585       off = dest;
10586
10587       /* And this is where we are coming from.  */
10588       off -= (stub_entry->stub_offset
10589               + stub_entry->stub_sec->output_offset
10590               + stub_entry->stub_sec->output_section->vma);
10591
10592       size = 4;
10593       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10594         {
10595           bfd_vma r2off = get_r2off (info, stub_entry);
10596
10597           if (r2off == 0)
10598             {
10599               htab->stub_error = TRUE;
10600               return FALSE;
10601             }
10602           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10603           loc += 4;
10604           size = 12;
10605           if (PPC_HA (r2off) != 0)
10606             {
10607               size = 16;
10608               bfd_put_32 (htab->params->stub_bfd,
10609                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10610               loc += 4;
10611             }
10612           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10613           loc += 4;
10614           off -= size - 4;
10615         }
10616       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10617
10618       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10619         {
10620           info->callbacks->einfo
10621             (_("%P: long branch stub `%s' offset overflow\n"),
10622              stub_entry->root.string);
10623           htab->stub_error = TRUE;
10624           return FALSE;
10625         }
10626
10627       if (info->emitrelocations)
10628         {
10629           r = get_relocs (stub_entry->stub_sec, 1);
10630           if (r == NULL)
10631             return FALSE;
10632           r->r_offset = loc - stub_entry->stub_sec->contents;
10633           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10634           r->r_addend = dest;
10635           if (stub_entry->h != NULL)
10636             {
10637               struct elf_link_hash_entry **hashes;
10638               unsigned long symndx;
10639               struct ppc_link_hash_entry *h;
10640
10641               hashes = elf_sym_hashes (htab->params->stub_bfd);
10642               if (hashes == NULL)
10643                 {
10644                   bfd_size_type hsize;
10645
10646                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10647                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10648                   if (hashes == NULL)
10649                     return FALSE;
10650                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10651                   htab->stub_globals = 1;
10652                 }
10653               symndx = htab->stub_globals++;
10654               h = stub_entry->h;
10655               hashes[symndx] = &h->elf;
10656               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10657               if (h->oh != NULL && h->oh->is_func)
10658                 h = ppc_follow_link (h->oh);
10659               if (h->elf.root.u.def.section != stub_entry->target_section)
10660                 /* H is an opd symbol.  The addend must be zero.  */
10661                 r->r_addend = 0;
10662               else
10663                 {
10664                   off = (h->elf.root.u.def.value
10665                          + h->elf.root.u.def.section->output_offset
10666                          + h->elf.root.u.def.section->output_section->vma);
10667                   r->r_addend -= off;
10668                 }
10669             }
10670         }
10671       break;
10672
10673     case ppc_stub_plt_branch:
10674     case ppc_stub_plt_branch_r2off:
10675       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10676                                          stub_entry->root.string + 9,
10677                                          FALSE, FALSE);
10678       if (br_entry == NULL)
10679         {
10680           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10681                                   stub_entry->root.string);
10682           htab->stub_error = TRUE;
10683           return FALSE;
10684         }
10685
10686       dest = (stub_entry->target_value
10687               + stub_entry->target_section->output_offset
10688               + stub_entry->target_section->output_section->vma);
10689       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10690         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10691
10692       bfd_put_64 (htab->brlt->owner, dest,
10693                   htab->brlt->contents + br_entry->offset);
10694
10695       if (br_entry->iter == htab->stub_iteration)
10696         {
10697           br_entry->iter = 0;
10698
10699           if (htab->relbrlt != NULL)
10700             {
10701               /* Create a reloc for the branch lookup table entry.  */
10702               Elf_Internal_Rela rela;
10703               bfd_byte *rl;
10704
10705               rela.r_offset = (br_entry->offset
10706                                + htab->brlt->output_offset
10707                                + htab->brlt->output_section->vma);
10708               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10709               rela.r_addend = dest;
10710
10711               rl = htab->relbrlt->contents;
10712               rl += (htab->relbrlt->reloc_count++
10713                      * sizeof (Elf64_External_Rela));
10714               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10715             }
10716           else if (info->emitrelocations)
10717             {
10718               r = get_relocs (htab->brlt, 1);
10719               if (r == NULL)
10720                 return FALSE;
10721               /* brlt, being SEC_LINKER_CREATED does not go through the
10722                  normal reloc processing.  Symbols and offsets are not
10723                  translated from input file to output file form, so
10724                  set up the offset per the output file.  */
10725               r->r_offset = (br_entry->offset
10726                              + htab->brlt->output_offset
10727                              + htab->brlt->output_section->vma);
10728               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10729               r->r_addend = dest;
10730             }
10731         }
10732
10733       dest = (br_entry->offset
10734               + htab->brlt->output_offset
10735               + htab->brlt->output_section->vma);
10736
10737       off = (dest
10738              - elf_gp (htab->brlt->output_section->owner)
10739              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10740
10741       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10742         {
10743           info->callbacks->einfo
10744             (_("%P: linkage table error against `%T'\n"),
10745              stub_entry->root.string);
10746           bfd_set_error (bfd_error_bad_value);
10747           htab->stub_error = TRUE;
10748           return FALSE;
10749         }
10750
10751       if (info->emitrelocations)
10752         {
10753           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10754           if (r == NULL)
10755             return FALSE;
10756           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10757           if (bfd_big_endian (info->output_bfd))
10758             r[0].r_offset += 2;
10759           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10760             r[0].r_offset += 4;
10761           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10762           r[0].r_addend = dest;
10763           if (PPC_HA (off) != 0)
10764             {
10765               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10766               r[1].r_offset = r[0].r_offset + 4;
10767               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10768               r[1].r_addend = r[0].r_addend;
10769             }
10770         }
10771
10772       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10773         {
10774           if (PPC_HA (off) != 0)
10775             {
10776               size = 16;
10777               bfd_put_32 (htab->params->stub_bfd,
10778                           ADDIS_R12_R2 | PPC_HA (off), loc);
10779               loc += 4;
10780               bfd_put_32 (htab->params->stub_bfd,
10781                           LD_R12_0R12 | PPC_LO (off), loc);
10782             }
10783           else
10784             {
10785               size = 12;
10786               bfd_put_32 (htab->params->stub_bfd,
10787                           LD_R12_0R2 | PPC_LO (off), loc);
10788             }
10789         }
10790       else
10791         {
10792           bfd_vma r2off = get_r2off (info, stub_entry);
10793
10794           if (r2off == 0 && htab->opd_abi)
10795             {
10796               htab->stub_error = TRUE;
10797               return FALSE;
10798             }
10799
10800           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10801           loc += 4;
10802           size = 16;
10803           if (PPC_HA (off) != 0)
10804             {
10805               size += 4;
10806               bfd_put_32 (htab->params->stub_bfd,
10807                           ADDIS_R12_R2 | PPC_HA (off), loc);
10808               loc += 4;
10809               bfd_put_32 (htab->params->stub_bfd,
10810                           LD_R12_0R12 | PPC_LO (off), loc);
10811             }
10812           else
10813             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10814
10815           if (PPC_HA (r2off) != 0)
10816             {
10817               size += 4;
10818               loc += 4;
10819               bfd_put_32 (htab->params->stub_bfd,
10820                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10821             }
10822           if (PPC_LO (r2off) != 0)
10823             {
10824               size += 4;
10825               loc += 4;
10826               bfd_put_32 (htab->params->stub_bfd,
10827                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10828             }
10829         }
10830       loc += 4;
10831       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10832       loc += 4;
10833       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10834       break;
10835
10836     case ppc_stub_plt_call:
10837     case ppc_stub_plt_call_r2save:
10838       if (stub_entry->h != NULL
10839           && stub_entry->h->is_func_descriptor
10840           && stub_entry->h->oh != NULL)
10841         {
10842           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10843
10844           /* If the old-ABI "dot-symbol" is undefined make it weak so
10845              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10846              FIXME: We used to define the symbol on one of the call
10847              stubs instead, which is why we test symbol section id
10848              against htab->top_id in various places.  Likely all
10849              these checks could now disappear.  */
10850           if (fh->elf.root.type == bfd_link_hash_undefined)
10851             fh->elf.root.type = bfd_link_hash_undefweak;
10852           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10853           fh->was_undefined = 0;
10854         }
10855
10856       /* Now build the stub.  */
10857       dest = stub_entry->plt_ent->plt.offset & ~1;
10858       if (dest >= (bfd_vma) -2)
10859         abort ();
10860
10861       plt = htab->elf.splt;
10862       if (!htab->elf.dynamic_sections_created
10863           || stub_entry->h == NULL
10864           || stub_entry->h->elf.dynindx == -1)
10865         plt = htab->elf.iplt;
10866
10867       dest += plt->output_offset + plt->output_section->vma;
10868
10869       if (stub_entry->h == NULL
10870           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10871         {
10872           Elf_Internal_Rela rela;
10873           bfd_byte *rl;
10874
10875           rela.r_offset = dest;
10876           if (htab->opd_abi)
10877             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10878           else
10879             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10880           rela.r_addend = (stub_entry->target_value
10881                            + stub_entry->target_section->output_offset
10882                            + stub_entry->target_section->output_section->vma);
10883
10884           rl = (htab->elf.irelplt->contents
10885                 + (htab->elf.irelplt->reloc_count++
10886                    * sizeof (Elf64_External_Rela)));
10887           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10888           stub_entry->plt_ent->plt.offset |= 1;
10889         }
10890
10891       off = (dest
10892              - elf_gp (plt->output_section->owner)
10893              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10894
10895       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10896         {
10897           info->callbacks->einfo
10898             (_("%P: linkage table error against `%T'\n"),
10899              stub_entry->h != NULL
10900              ? stub_entry->h->elf.root.root.string
10901              : "<local sym>");
10902           bfd_set_error (bfd_error_bad_value);
10903           htab->stub_error = TRUE;
10904           return FALSE;
10905         }
10906
10907       if (htab->params->plt_stub_align != 0)
10908         {
10909           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10910
10911           stub_entry->stub_sec->size += pad;
10912           stub_entry->stub_offset = stub_entry->stub_sec->size;
10913           loc += pad;
10914         }
10915
10916       r = NULL;
10917       if (info->emitrelocations)
10918         {
10919           r = get_relocs (stub_entry->stub_sec,
10920                           ((PPC_HA (off) != 0)
10921                            + (htab->opd_abi
10922                               ? 2 + (htab->params->plt_static_chain
10923                                      && PPC_HA (off + 16) == PPC_HA (off))
10924                               : 1)));
10925           if (r == NULL)
10926             return FALSE;
10927           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10928           if (bfd_big_endian (info->output_bfd))
10929             r[0].r_offset += 2;
10930           r[0].r_addend = dest;
10931         }
10932       if (stub_entry->h != NULL
10933           && (stub_entry->h == htab->tls_get_addr_fd
10934               || stub_entry->h == htab->tls_get_addr)
10935           && !htab->params->no_tls_get_addr_opt)
10936         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10937       else
10938         p = build_plt_stub (htab, stub_entry, loc, off, r);
10939       size = p - loc;
10940       break;
10941
10942     default:
10943       BFD_FAIL ();
10944       return FALSE;
10945     }
10946
10947   stub_entry->stub_sec->size += size;
10948
10949   if (htab->params->emit_stub_syms)
10950     {
10951       struct elf_link_hash_entry *h;
10952       size_t len1, len2;
10953       char *name;
10954       const char *const stub_str[] = { "long_branch",
10955                                        "long_branch_r2off",
10956                                        "plt_branch",
10957                                        "plt_branch_r2off",
10958                                        "plt_call",
10959                                        "plt_call" };
10960
10961       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10962       len2 = strlen (stub_entry->root.string);
10963       name = bfd_malloc (len1 + len2 + 2);
10964       if (name == NULL)
10965         return FALSE;
10966       memcpy (name, stub_entry->root.string, 9);
10967       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10968       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10969       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10970       if (h == NULL)
10971         return FALSE;
10972       if (h->root.type == bfd_link_hash_new)
10973         {
10974           h->root.type = bfd_link_hash_defined;
10975           h->root.u.def.section = stub_entry->stub_sec;
10976           h->root.u.def.value = stub_entry->stub_offset;
10977           h->ref_regular = 1;
10978           h->def_regular = 1;
10979           h->ref_regular_nonweak = 1;
10980           h->forced_local = 1;
10981           h->non_elf = 0;
10982           h->root.linker_def = 1;
10983         }
10984     }
10985
10986   return TRUE;
10987 }
10988
10989 /* As above, but don't actually build the stub.  Just bump offset so
10990    we know stub section sizes, and select plt_branch stubs where
10991    long_branch stubs won't do.  */
10992
10993 static bfd_boolean
10994 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10995 {
10996   struct ppc_stub_hash_entry *stub_entry;
10997   struct bfd_link_info *info;
10998   struct ppc_link_hash_table *htab;
10999   bfd_vma off;
11000   int size;
11001
11002   /* Massage our args to the form they really have.  */
11003   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11004   info = in_arg;
11005
11006   htab = ppc_hash_table (info);
11007   if (htab == NULL)
11008     return FALSE;
11009
11010   if (stub_entry->stub_type == ppc_stub_plt_call
11011       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11012     {
11013       asection *plt;
11014       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11015       if (off >= (bfd_vma) -2)
11016         abort ();
11017       plt = htab->elf.splt;
11018       if (!htab->elf.dynamic_sections_created
11019           || stub_entry->h == NULL
11020           || stub_entry->h->elf.dynindx == -1)
11021         plt = htab->elf.iplt;
11022       off += (plt->output_offset
11023               + plt->output_section->vma
11024               - elf_gp (plt->output_section->owner)
11025               - htab->stub_group[stub_entry->id_sec->id].toc_off);
11026
11027       size = plt_stub_size (htab, stub_entry, off);
11028       if (htab->params->plt_stub_align)
11029         size += plt_stub_pad (htab, stub_entry, off);
11030       if (info->emitrelocations)
11031         {
11032           stub_entry->stub_sec->reloc_count
11033             += ((PPC_HA (off) != 0)
11034                 + (htab->opd_abi
11035                    ? 2 + (htab->params->plt_static_chain
11036                           && PPC_HA (off + 16) == PPC_HA (off))
11037                    : 1));
11038           stub_entry->stub_sec->flags |= SEC_RELOC;
11039         }
11040     }
11041   else
11042     {
11043       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11044          variants.  */
11045       bfd_vma r2off = 0;
11046       bfd_vma local_off = 0;
11047
11048       off = (stub_entry->target_value
11049              + stub_entry->target_section->output_offset
11050              + stub_entry->target_section->output_section->vma);
11051       off -= (stub_entry->stub_sec->size
11052               + stub_entry->stub_sec->output_offset
11053               + stub_entry->stub_sec->output_section->vma);
11054
11055       /* Reset the stub type from the plt variant in case we now
11056          can reach with a shorter stub.  */
11057       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11058         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11059
11060       size = 4;
11061       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11062         {
11063           r2off = get_r2off (info, stub_entry);
11064           if (r2off == 0 && htab->opd_abi)
11065             {
11066               htab->stub_error = TRUE;
11067               return FALSE;
11068             }
11069           size = 12;
11070           if (PPC_HA (r2off) != 0)
11071             size = 16;
11072           off -= size - 4;
11073         }
11074
11075       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11076
11077       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11078          Do the same for -R objects without function descriptors.  */
11079       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11080           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11081               && r2off == 0))
11082         {
11083           struct ppc_branch_hash_entry *br_entry;
11084
11085           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11086                                              stub_entry->root.string + 9,
11087                                              TRUE, FALSE);
11088           if (br_entry == NULL)
11089             {
11090               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11091                                       stub_entry->root.string);
11092               htab->stub_error = TRUE;
11093               return FALSE;
11094             }
11095
11096           if (br_entry->iter != htab->stub_iteration)
11097             {
11098               br_entry->iter = htab->stub_iteration;
11099               br_entry->offset = htab->brlt->size;
11100               htab->brlt->size += 8;
11101
11102               if (htab->relbrlt != NULL)
11103                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11104               else if (info->emitrelocations)
11105                 {
11106                   htab->brlt->reloc_count += 1;
11107                   htab->brlt->flags |= SEC_RELOC;
11108                 }
11109             }
11110
11111           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11112           off = (br_entry->offset
11113                  + htab->brlt->output_offset
11114                  + htab->brlt->output_section->vma
11115                  - elf_gp (htab->brlt->output_section->owner)
11116                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11117
11118           if (info->emitrelocations)
11119             {
11120               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11121               stub_entry->stub_sec->flags |= SEC_RELOC;
11122             }
11123
11124           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11125             {
11126               size = 12;
11127               if (PPC_HA (off) != 0)
11128                 size = 16;
11129             }
11130           else
11131             {
11132               size = 16;
11133               if (PPC_HA (off) != 0)
11134                 size += 4;
11135
11136               if (PPC_HA (r2off) != 0)
11137                 size += 4;
11138               if (PPC_LO (r2off) != 0)
11139                 size += 4;
11140             }
11141         }
11142       else if (info->emitrelocations)
11143         {
11144           stub_entry->stub_sec->reloc_count += 1;
11145           stub_entry->stub_sec->flags |= SEC_RELOC;
11146         }
11147     }
11148
11149   stub_entry->stub_sec->size += size;
11150   return TRUE;
11151 }
11152
11153 /* Set up various things so that we can make a list of input sections
11154    for each output section included in the link.  Returns -1 on error,
11155    0 when no stubs will be needed, and 1 on success.  */
11156
11157 int
11158 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11159 {
11160   bfd *input_bfd;
11161   int top_id, top_index, id;
11162   asection *section;
11163   asection **input_list;
11164   bfd_size_type amt;
11165   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11166
11167   if (htab == NULL)
11168     return -1;
11169
11170   /* Find the top input section id.  */
11171   for (input_bfd = info->input_bfds, top_id = 3;
11172        input_bfd != NULL;
11173        input_bfd = input_bfd->link.next)
11174     {
11175       for (section = input_bfd->sections;
11176            section != NULL;
11177            section = section->next)
11178         {
11179           if (top_id < section->id)
11180             top_id = section->id;
11181         }
11182     }
11183
11184   htab->top_id = top_id;
11185   amt = sizeof (struct map_stub) * (top_id + 1);
11186   htab->stub_group = bfd_zmalloc (amt);
11187   if (htab->stub_group == NULL)
11188     return -1;
11189
11190   /* Set toc_off for com, und, abs and ind sections.  */
11191   for (id = 0; id < 3; id++)
11192     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11193
11194   /* We can't use output_bfd->section_count here to find the top output
11195      section index as some sections may have been removed, and
11196      strip_excluded_output_sections doesn't renumber the indices.  */
11197   for (section = info->output_bfd->sections, top_index = 0;
11198        section != NULL;
11199        section = section->next)
11200     {
11201       if (top_index < section->index)
11202         top_index = section->index;
11203     }
11204
11205   htab->top_index = top_index;
11206   amt = sizeof (asection *) * (top_index + 1);
11207   input_list = bfd_zmalloc (amt);
11208   htab->input_list = input_list;
11209   if (input_list == NULL)
11210     return -1;
11211
11212   return 1;
11213 }
11214
11215 /* Set up for first pass at multitoc partitioning.  */
11216
11217 void
11218 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11219 {
11220   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11221
11222   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11223   htab->toc_bfd = NULL;
11224   htab->toc_first_sec = NULL;
11225 }
11226
11227 /* The linker repeatedly calls this function for each TOC input section
11228    and linker generated GOT section.  Group input bfds such that the toc
11229    within a group is less than 64k in size.  */
11230
11231 bfd_boolean
11232 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11233 {
11234   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11235   bfd_vma addr, off, limit;
11236
11237   if (htab == NULL)
11238     return FALSE;
11239
11240   if (!htab->second_toc_pass)
11241     {
11242       /* Keep track of the first .toc or .got section for this input bfd.  */
11243       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11244
11245       if (new_bfd)
11246         {
11247           htab->toc_bfd = isec->owner;
11248           htab->toc_first_sec = isec;
11249         }
11250
11251       addr = isec->output_offset + isec->output_section->vma;
11252       off = addr - htab->toc_curr;
11253       limit = 0x80008000;
11254       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11255         limit = 0x10000;
11256       if (off + isec->size > limit)
11257         {
11258           addr = (htab->toc_first_sec->output_offset
11259                   + htab->toc_first_sec->output_section->vma);
11260           htab->toc_curr = addr;
11261           htab->toc_curr &= -TOC_BASE_ALIGN;
11262         }
11263
11264       /* toc_curr is the base address of this toc group.  Set elf_gp
11265          for the input section to be the offset relative to the
11266          output toc base plus 0x8000.  Making the input elf_gp an
11267          offset allows us to move the toc as a whole without
11268          recalculating input elf_gp.  */
11269       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11270       off += TOC_BASE_OFF;
11271
11272       /* Die if someone uses a linker script that doesn't keep input
11273          file .toc and .got together.  */
11274       if (new_bfd
11275           && elf_gp (isec->owner) != 0
11276           && elf_gp (isec->owner) != off)
11277         return FALSE;
11278
11279       elf_gp (isec->owner) = off;
11280       return TRUE;
11281     }
11282
11283   /* During the second pass toc_first_sec points to the start of
11284      a toc group, and toc_curr is used to track the old elf_gp.
11285      We use toc_bfd to ensure we only look at each bfd once.  */
11286   if (htab->toc_bfd == isec->owner)
11287     return TRUE;
11288   htab->toc_bfd = isec->owner;
11289
11290   if (htab->toc_first_sec == NULL
11291       || htab->toc_curr != elf_gp (isec->owner))
11292     {
11293       htab->toc_curr = elf_gp (isec->owner);
11294       htab->toc_first_sec = isec;
11295     }
11296   addr = (htab->toc_first_sec->output_offset
11297           + htab->toc_first_sec->output_section->vma);
11298   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11299   elf_gp (isec->owner) = off;
11300
11301   return TRUE;
11302 }
11303
11304 /* Called via elf_link_hash_traverse to merge GOT entries for global
11305    symbol H.  */
11306
11307 static bfd_boolean
11308 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11309 {
11310   if (h->root.type == bfd_link_hash_indirect)
11311     return TRUE;
11312
11313   merge_got_entries (&h->got.glist);
11314
11315   return TRUE;
11316 }
11317
11318 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11319    symbol H.  */
11320
11321 static bfd_boolean
11322 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11323 {
11324   struct got_entry *gent;
11325
11326   if (h->root.type == bfd_link_hash_indirect)
11327     return TRUE;
11328
11329   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11330     if (!gent->is_indirect)
11331       allocate_got (h, (struct bfd_link_info *) inf, gent);
11332   return TRUE;
11333 }
11334
11335 /* Called on the first multitoc pass after the last call to
11336    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11337    entries.  */
11338
11339 bfd_boolean
11340 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11341 {
11342   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11343   struct bfd *ibfd, *ibfd2;
11344   bfd_boolean done_something;
11345
11346   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11347
11348   if (!htab->do_multi_toc)
11349     return FALSE;
11350
11351   /* Merge global sym got entries within a toc group.  */
11352   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11353
11354   /* And tlsld_got.  */
11355   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11356     {
11357       struct got_entry *ent, *ent2;
11358
11359       if (!is_ppc64_elf (ibfd))
11360         continue;
11361
11362       ent = ppc64_tlsld_got (ibfd);
11363       if (!ent->is_indirect
11364           && ent->got.offset != (bfd_vma) -1)
11365         {
11366           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11367             {
11368               if (!is_ppc64_elf (ibfd2))
11369                 continue;
11370
11371               ent2 = ppc64_tlsld_got (ibfd2);
11372               if (!ent2->is_indirect
11373                   && ent2->got.offset != (bfd_vma) -1
11374                   && elf_gp (ibfd2) == elf_gp (ibfd))
11375                 {
11376                   ent2->is_indirect = TRUE;
11377                   ent2->got.ent = ent;
11378                 }
11379             }
11380         }
11381     }
11382
11383   /* Zap sizes of got sections.  */
11384   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11385   htab->elf.irelplt->size -= htab->got_reli_size;
11386   htab->got_reli_size = 0;
11387
11388   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11389     {
11390       asection *got, *relgot;
11391
11392       if (!is_ppc64_elf (ibfd))
11393         continue;
11394
11395       got = ppc64_elf_tdata (ibfd)->got;
11396       if (got != NULL)
11397         {
11398           got->rawsize = got->size;
11399           got->size = 0;
11400           relgot = ppc64_elf_tdata (ibfd)->relgot;
11401           relgot->rawsize = relgot->size;
11402           relgot->size = 0;
11403         }
11404     }
11405
11406   /* Now reallocate the got, local syms first.  We don't need to
11407      allocate section contents again since we never increase size.  */
11408   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11409     {
11410       struct got_entry **lgot_ents;
11411       struct got_entry **end_lgot_ents;
11412       struct plt_entry **local_plt;
11413       struct plt_entry **end_local_plt;
11414       unsigned char *lgot_masks;
11415       bfd_size_type locsymcount;
11416       Elf_Internal_Shdr *symtab_hdr;
11417       asection *s;
11418
11419       if (!is_ppc64_elf (ibfd))
11420         continue;
11421
11422       lgot_ents = elf_local_got_ents (ibfd);
11423       if (!lgot_ents)
11424         continue;
11425
11426       symtab_hdr = &elf_symtab_hdr (ibfd);
11427       locsymcount = symtab_hdr->sh_info;
11428       end_lgot_ents = lgot_ents + locsymcount;
11429       local_plt = (struct plt_entry **) end_lgot_ents;
11430       end_local_plt = local_plt + locsymcount;
11431       lgot_masks = (unsigned char *) end_local_plt;
11432       s = ppc64_elf_tdata (ibfd)->got;
11433       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11434         {
11435           struct got_entry *ent;
11436
11437           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11438             {
11439               unsigned int ent_size = 8;
11440               unsigned int rel_size = sizeof (Elf64_External_Rela);
11441
11442               ent->got.offset = s->size;
11443               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11444                 {
11445                   ent_size *= 2;
11446                   rel_size *= 2;
11447                 }
11448               s->size += ent_size;
11449               if ((*lgot_masks & PLT_IFUNC) != 0)
11450                 {
11451                   htab->elf.irelplt->size += rel_size;
11452                   htab->got_reli_size += rel_size;
11453                 }
11454               else if (info->shared)
11455                 {
11456                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11457                   srel->size += rel_size;
11458                 }
11459             }
11460         }
11461     }
11462
11463   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11464
11465   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11466     {
11467       struct got_entry *ent;
11468
11469       if (!is_ppc64_elf (ibfd))
11470         continue;
11471
11472       ent = ppc64_tlsld_got (ibfd);
11473       if (!ent->is_indirect
11474           && ent->got.offset != (bfd_vma) -1)
11475         {
11476           asection *s = ppc64_elf_tdata (ibfd)->got;
11477           ent->got.offset = s->size;
11478           s->size += 16;
11479           if (info->shared)
11480             {
11481               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11482               srel->size += sizeof (Elf64_External_Rela);
11483             }
11484         }
11485     }
11486
11487   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11488   if (!done_something)
11489     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11490       {
11491         asection *got;
11492
11493         if (!is_ppc64_elf (ibfd))
11494           continue;
11495
11496         got = ppc64_elf_tdata (ibfd)->got;
11497         if (got != NULL)
11498           {
11499             done_something = got->rawsize != got->size;
11500             if (done_something)
11501               break;
11502           }
11503       }
11504
11505   if (done_something)
11506     (*htab->params->layout_sections_again) ();
11507
11508   /* Set up for second pass over toc sections to recalculate elf_gp
11509      on input sections.  */
11510   htab->toc_bfd = NULL;
11511   htab->toc_first_sec = NULL;
11512   htab->second_toc_pass = TRUE;
11513   return done_something;
11514 }
11515
11516 /* Called after second pass of multitoc partitioning.  */
11517
11518 void
11519 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11520 {
11521   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11522
11523   /* After the second pass, toc_curr tracks the TOC offset used
11524      for code sections below in ppc64_elf_next_input_section.  */
11525   htab->toc_curr = TOC_BASE_OFF;
11526 }
11527
11528 /* No toc references were found in ISEC.  If the code in ISEC makes no
11529    calls, then there's no need to use toc adjusting stubs when branching
11530    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11531    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11532    needed, and 2 if a cyclical call-graph was found but no other reason
11533    for a stub was detected.  If called from the top level, a return of
11534    2 means the same as a return of 0.  */
11535
11536 static int
11537 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11538 {
11539   int ret;
11540
11541   /* Mark this section as checked.  */
11542   isec->call_check_done = 1;
11543
11544   /* We know none of our code bearing sections will need toc stubs.  */
11545   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11546     return 0;
11547
11548   if (isec->size == 0)
11549     return 0;
11550
11551   if (isec->output_section == NULL)
11552     return 0;
11553
11554   ret = 0;
11555   if (isec->reloc_count != 0)
11556     {
11557       Elf_Internal_Rela *relstart, *rel;
11558       Elf_Internal_Sym *local_syms;
11559       struct ppc_link_hash_table *htab;
11560
11561       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11562                                             info->keep_memory);
11563       if (relstart == NULL)
11564         return -1;
11565
11566       /* Look for branches to outside of this section.  */
11567       local_syms = NULL;
11568       htab = ppc_hash_table (info);
11569       if (htab == NULL)
11570         return -1;
11571
11572       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11573         {
11574           enum elf_ppc64_reloc_type r_type;
11575           unsigned long r_symndx;
11576           struct elf_link_hash_entry *h;
11577           struct ppc_link_hash_entry *eh;
11578           Elf_Internal_Sym *sym;
11579           asection *sym_sec;
11580           struct _opd_sec_data *opd;
11581           bfd_vma sym_value;
11582           bfd_vma dest;
11583
11584           r_type = ELF64_R_TYPE (rel->r_info);
11585           if (r_type != R_PPC64_REL24
11586               && r_type != R_PPC64_REL14
11587               && r_type != R_PPC64_REL14_BRTAKEN
11588               && r_type != R_PPC64_REL14_BRNTAKEN)
11589             continue;
11590
11591           r_symndx = ELF64_R_SYM (rel->r_info);
11592           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11593                           isec->owner))
11594             {
11595               ret = -1;
11596               break;
11597             }
11598
11599           /* Calls to dynamic lib functions go through a plt call stub
11600              that uses r2.  */
11601           eh = (struct ppc_link_hash_entry *) h;
11602           if (eh != NULL
11603               && (eh->elf.plt.plist != NULL
11604                   || (eh->oh != NULL
11605                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11606             {
11607               ret = 1;
11608               break;
11609             }
11610
11611           if (sym_sec == NULL)
11612             /* Ignore other undefined symbols.  */
11613             continue;
11614
11615           /* Assume branches to other sections not included in the
11616              link need stubs too, to cover -R and absolute syms.  */
11617           if (sym_sec->output_section == NULL)
11618             {
11619               ret = 1;
11620               break;
11621             }
11622
11623           if (h == NULL)
11624             sym_value = sym->st_value;
11625           else
11626             {
11627               if (h->root.type != bfd_link_hash_defined
11628                   && h->root.type != bfd_link_hash_defweak)
11629                 abort ();
11630               sym_value = h->root.u.def.value;
11631             }
11632           sym_value += rel->r_addend;
11633
11634           /* If this branch reloc uses an opd sym, find the code section.  */
11635           opd = get_opd_info (sym_sec);
11636           if (opd != NULL)
11637             {
11638               if (h == NULL && opd->adjust != NULL)
11639                 {
11640                   long adjust;
11641
11642                   adjust = opd->adjust[OPD_NDX (sym_value)];
11643                   if (adjust == -1)
11644                     /* Assume deleted functions won't ever be called.  */
11645                     continue;
11646                   sym_value += adjust;
11647                 }
11648
11649               dest = opd_entry_value (sym_sec, sym_value,
11650                                       &sym_sec, NULL, FALSE);
11651               if (dest == (bfd_vma) -1)
11652                 continue;
11653             }
11654           else
11655             dest = (sym_value
11656                     + sym_sec->output_offset
11657                     + sym_sec->output_section->vma);
11658
11659           /* Ignore branch to self.  */
11660           if (sym_sec == isec)
11661             continue;
11662
11663           /* If the called function uses the toc, we need a stub.  */
11664           if (sym_sec->has_toc_reloc
11665               || sym_sec->makes_toc_func_call)
11666             {
11667               ret = 1;
11668               break;
11669             }
11670
11671           /* Assume any branch that needs a long branch stub might in fact
11672              need a plt_branch stub.  A plt_branch stub uses r2.  */
11673           else if (dest - (isec->output_offset
11674                            + isec->output_section->vma
11675                            + rel->r_offset) + (1 << 25)
11676                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11677                                                              ? h->other
11678                                                              : sym->st_other))
11679             {
11680               ret = 1;
11681               break;
11682             }
11683
11684           /* If calling back to a section in the process of being
11685              tested, we can't say for sure that no toc adjusting stubs
11686              are needed, so don't return zero.  */
11687           else if (sym_sec->call_check_in_progress)
11688             ret = 2;
11689
11690           /* Branches to another section that itself doesn't have any TOC
11691              references are OK.  Recursively call ourselves to check.  */
11692           else if (!sym_sec->call_check_done)
11693             {
11694               int recur;
11695
11696               /* Mark current section as indeterminate, so that other
11697                  sections that call back to current won't be marked as
11698                  known.  */
11699               isec->call_check_in_progress = 1;
11700               recur = toc_adjusting_stub_needed (info, sym_sec);
11701               isec->call_check_in_progress = 0;
11702
11703               if (recur != 0)
11704                 {
11705                   ret = recur;
11706                   if (recur != 2)
11707                     break;
11708                 }
11709             }
11710         }
11711
11712       if (local_syms != NULL
11713           && (elf_symtab_hdr (isec->owner).contents
11714               != (unsigned char *) local_syms))
11715         free (local_syms);
11716       if (elf_section_data (isec)->relocs != relstart)
11717         free (relstart);
11718     }
11719
11720   if ((ret & 1) == 0
11721       && isec->map_head.s != NULL
11722       && (strcmp (isec->output_section->name, ".init") == 0
11723           || strcmp (isec->output_section->name, ".fini") == 0))
11724     {
11725       if (isec->map_head.s->has_toc_reloc
11726           || isec->map_head.s->makes_toc_func_call)
11727         ret = 1;
11728       else if (!isec->map_head.s->call_check_done)
11729         {
11730           int recur;
11731           isec->call_check_in_progress = 1;
11732           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11733           isec->call_check_in_progress = 0;
11734           if (recur != 0)
11735             ret = recur;
11736         }
11737     }
11738
11739   if (ret == 1)
11740     isec->makes_toc_func_call = 1;
11741
11742   return ret;
11743 }
11744
11745 /* The linker repeatedly calls this function for each input section,
11746    in the order that input sections are linked into output sections.
11747    Build lists of input sections to determine groupings between which
11748    we may insert linker stubs.  */
11749
11750 bfd_boolean
11751 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11752 {
11753   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11754
11755   if (htab == NULL)
11756     return FALSE;
11757
11758   if ((isec->output_section->flags & SEC_CODE) != 0
11759       && isec->output_section->index <= htab->top_index)
11760     {
11761       asection **list = htab->input_list + isec->output_section->index;
11762       /* Steal the link_sec pointer for our list.  */
11763 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11764       /* This happens to make the list in reverse order,
11765          which is what we want.  */
11766       PREV_SEC (isec) = *list;
11767       *list = isec;
11768     }
11769
11770   if (htab->multi_toc_needed)
11771     {
11772       /* Analyse sections that aren't already flagged as needing a
11773          valid toc pointer.  Exclude .fixup for the linux kernel.
11774          .fixup contains branches, but only back to the function that
11775          hit an exception.  */
11776       if (!(isec->has_toc_reloc
11777             || (isec->flags & SEC_CODE) == 0
11778             || strcmp (isec->name, ".fixup") == 0
11779             || isec->call_check_done))
11780         {
11781           if (toc_adjusting_stub_needed (info, isec) < 0)
11782             return FALSE;
11783         }
11784       /* Make all sections use the TOC assigned for this object file.
11785          This will be wrong for pasted sections;  We fix that in
11786          check_pasted_section().  */
11787       if (elf_gp (isec->owner) != 0)
11788         htab->toc_curr = elf_gp (isec->owner);
11789     }
11790
11791   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11792   return TRUE;
11793 }
11794
11795 /* Check that all .init and .fini sections use the same toc, if they
11796    have toc relocs.  */
11797
11798 static bfd_boolean
11799 check_pasted_section (struct bfd_link_info *info, const char *name)
11800 {
11801   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11802
11803   if (o != NULL)
11804     {
11805       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11806       bfd_vma toc_off = 0;
11807       asection *i;
11808
11809       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11810         if (i->has_toc_reloc)
11811           {
11812             if (toc_off == 0)
11813               toc_off = htab->stub_group[i->id].toc_off;
11814             else if (toc_off != htab->stub_group[i->id].toc_off)
11815               return FALSE;
11816           }
11817
11818       if (toc_off == 0)
11819         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11820           if (i->makes_toc_func_call)
11821             {
11822               toc_off = htab->stub_group[i->id].toc_off;
11823               break;
11824             }
11825
11826       /* Make sure the whole pasted function uses the same toc offset.  */
11827       if (toc_off != 0)
11828         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11829           htab->stub_group[i->id].toc_off = toc_off;
11830     }
11831   return TRUE;
11832 }
11833
11834 bfd_boolean
11835 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11836 {
11837   return (check_pasted_section (info, ".init")
11838           & check_pasted_section (info, ".fini"));
11839 }
11840
11841 /* See whether we can group stub sections together.  Grouping stub
11842    sections may result in fewer stubs.  More importantly, we need to
11843    put all .init* and .fini* stubs at the beginning of the .init or
11844    .fini output sections respectively, because glibc splits the
11845    _init and _fini functions into multiple parts.  Putting a stub in
11846    the middle of a function is not a good idea.  */
11847
11848 static void
11849 group_sections (struct ppc_link_hash_table *htab,
11850                 bfd_size_type stub_group_size,
11851                 bfd_boolean stubs_always_before_branch)
11852 {
11853   asection **list;
11854   bfd_size_type stub14_group_size;
11855   bfd_boolean suppress_size_errors;
11856
11857   suppress_size_errors = FALSE;
11858   stub14_group_size = stub_group_size >> 10;
11859   if (stub_group_size == 1)
11860     {
11861       /* Default values.  */
11862       if (stubs_always_before_branch)
11863         {
11864           stub_group_size = 0x1e00000;
11865           stub14_group_size = 0x7800;
11866         }
11867       else
11868         {
11869           stub_group_size = 0x1c00000;
11870           stub14_group_size = 0x7000;
11871         }
11872       suppress_size_errors = TRUE;
11873     }
11874
11875   list = htab->input_list + htab->top_index;
11876   do
11877     {
11878       asection *tail = *list;
11879       while (tail != NULL)
11880         {
11881           asection *curr;
11882           asection *prev;
11883           bfd_size_type total;
11884           bfd_boolean big_sec;
11885           bfd_vma curr_toc;
11886
11887           curr = tail;
11888           total = tail->size;
11889           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11890                              && ppc64_elf_section_data (tail)->has_14bit_branch
11891                              ? stub14_group_size : stub_group_size);
11892           if (big_sec && !suppress_size_errors)
11893             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11894                                      tail->owner, tail);
11895           curr_toc = htab->stub_group[tail->id].toc_off;
11896
11897           while ((prev = PREV_SEC (curr)) != NULL
11898                  && ((total += curr->output_offset - prev->output_offset)
11899                      < (ppc64_elf_section_data (prev) != NULL
11900                         && ppc64_elf_section_data (prev)->has_14bit_branch
11901                         ? stub14_group_size : stub_group_size))
11902                  && htab->stub_group[prev->id].toc_off == curr_toc)
11903             curr = prev;
11904
11905           /* OK, the size from the start of CURR to the end is less
11906              than stub_group_size and thus can be handled by one stub
11907              section.  (or the tail section is itself larger than
11908              stub_group_size, in which case we may be toast.)  We
11909              should really be keeping track of the total size of stubs
11910              added here, as stubs contribute to the final output
11911              section size.  That's a little tricky, and this way will
11912              only break if stubs added make the total size more than
11913              2^25, ie. for the default stub_group_size, if stubs total
11914              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11915           do
11916             {
11917               prev = PREV_SEC (tail);
11918               /* Set up this stub group.  */
11919               htab->stub_group[tail->id].link_sec = curr;
11920             }
11921           while (tail != curr && (tail = prev) != NULL);
11922
11923           /* But wait, there's more!  Input sections up to stub_group_size
11924              bytes before the stub section can be handled by it too.
11925              Don't do this if we have a really large section after the
11926              stubs, as adding more stubs increases the chance that
11927              branches may not reach into the stub section.  */
11928           if (!stubs_always_before_branch && !big_sec)
11929             {
11930               total = 0;
11931               while (prev != NULL
11932                      && ((total += tail->output_offset - prev->output_offset)
11933                          < (ppc64_elf_section_data (prev) != NULL
11934                             && ppc64_elf_section_data (prev)->has_14bit_branch
11935                             ? stub14_group_size : stub_group_size))
11936                      && htab->stub_group[prev->id].toc_off == curr_toc)
11937                 {
11938                   tail = prev;
11939                   prev = PREV_SEC (tail);
11940                   htab->stub_group[tail->id].link_sec = curr;
11941                 }
11942             }
11943           tail = prev;
11944         }
11945     }
11946   while (list-- != htab->input_list);
11947   free (htab->input_list);
11948 #undef PREV_SEC
11949 }
11950
11951 static const unsigned char glink_eh_frame_cie[] =
11952 {
11953   0, 0, 0, 16,                          /* length.  */
11954   0, 0, 0, 0,                           /* id.  */
11955   1,                                    /* CIE version.  */
11956   'z', 'R', 0,                          /* Augmentation string.  */
11957   4,                                    /* Code alignment.  */
11958   0x78,                                 /* Data alignment.  */
11959   65,                                   /* RA reg.  */
11960   1,                                    /* Augmentation size.  */
11961   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11962   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
11963   0, 0, 0, 0
11964 };
11965
11966 /* Stripping output sections is normally done before dynamic section
11967    symbols have been allocated.  This function is called later, and
11968    handles cases like htab->brlt which is mapped to its own output
11969    section.  */
11970
11971 static void
11972 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11973 {
11974   if (isec->size == 0
11975       && isec->output_section->size == 0
11976       && !(isec->output_section->flags & SEC_KEEP)
11977       && !bfd_section_removed_from_list (info->output_bfd,
11978                                          isec->output_section)
11979       && elf_section_data (isec->output_section)->dynindx == 0)
11980     {
11981       isec->output_section->flags |= SEC_EXCLUDE;
11982       bfd_section_list_remove (info->output_bfd, isec->output_section);
11983       info->output_bfd->section_count--;
11984     }
11985 }
11986
11987 /* Determine and set the size of the stub section for a final link.
11988
11989    The basic idea here is to examine all the relocations looking for
11990    PC-relative calls to a target that is unreachable with a "bl"
11991    instruction.  */
11992
11993 bfd_boolean
11994 ppc64_elf_size_stubs (struct bfd_link_info *info)
11995 {
11996   bfd_size_type stub_group_size;
11997   bfd_boolean stubs_always_before_branch;
11998   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11999
12000   if (htab == NULL)
12001     return FALSE;
12002
12003   if (htab->params->plt_thread_safe == -1 && !info->executable)
12004     htab->params->plt_thread_safe = 1;
12005   if (!htab->opd_abi)
12006     htab->params->plt_thread_safe = 0;
12007   else if (htab->params->plt_thread_safe == -1)
12008     {
12009       static const char *const thread_starter[] =
12010         {
12011           "pthread_create",
12012           /* libstdc++ */
12013           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12014           /* librt */
12015           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12016           "mq_notify", "create_timer",
12017           /* libanl */
12018           "getaddrinfo_a",
12019           /* libgomp */
12020           "GOMP_parallel",
12021           "GOMP_parallel_start",
12022           "GOMP_parallel_loop_static",
12023           "GOMP_parallel_loop_static_start",
12024           "GOMP_parallel_loop_dynamic",
12025           "GOMP_parallel_loop_dynamic_start",
12026           "GOMP_parallel_loop_guided",
12027           "GOMP_parallel_loop_guided_start",
12028           "GOMP_parallel_loop_runtime",
12029           "GOMP_parallel_loop_runtime_start",
12030           "GOMP_parallel_sections",
12031           "GOMP_parallel_sections_start",
12032           /* libgo */
12033           "__go_go",
12034         };
12035       unsigned i;
12036
12037       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
12038         {
12039           struct elf_link_hash_entry *h;
12040           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12041                                     FALSE, FALSE, TRUE);
12042           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12043           if (htab->params->plt_thread_safe)
12044             break;
12045         }
12046     }
12047   stubs_always_before_branch = htab->params->group_size < 0;
12048   if (htab->params->group_size < 0)
12049     stub_group_size = -htab->params->group_size;
12050   else
12051     stub_group_size = htab->params->group_size;
12052
12053   group_sections (htab, stub_group_size, stubs_always_before_branch);
12054
12055   while (1)
12056     {
12057       bfd *input_bfd;
12058       unsigned int bfd_indx;
12059       asection *stub_sec;
12060
12061       htab->stub_iteration += 1;
12062
12063       for (input_bfd = info->input_bfds, bfd_indx = 0;
12064            input_bfd != NULL;
12065            input_bfd = input_bfd->link.next, bfd_indx++)
12066         {
12067           Elf_Internal_Shdr *symtab_hdr;
12068           asection *section;
12069           Elf_Internal_Sym *local_syms = NULL;
12070
12071           if (!is_ppc64_elf (input_bfd))
12072             continue;
12073
12074           /* We'll need the symbol table in a second.  */
12075           symtab_hdr = &elf_symtab_hdr (input_bfd);
12076           if (symtab_hdr->sh_info == 0)
12077             continue;
12078
12079           /* Walk over each section attached to the input bfd.  */
12080           for (section = input_bfd->sections;
12081                section != NULL;
12082                section = section->next)
12083             {
12084               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12085
12086               /* If there aren't any relocs, then there's nothing more
12087                  to do.  */
12088               if ((section->flags & SEC_RELOC) == 0
12089                   || (section->flags & SEC_ALLOC) == 0
12090                   || (section->flags & SEC_LOAD) == 0
12091                   || (section->flags & SEC_CODE) == 0
12092                   || section->reloc_count == 0)
12093                 continue;
12094
12095               /* If this section is a link-once section that will be
12096                  discarded, then don't create any stubs.  */
12097               if (section->output_section == NULL
12098                   || section->output_section->owner != info->output_bfd)
12099                 continue;
12100
12101               /* Get the relocs.  */
12102               internal_relocs
12103                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12104                                              info->keep_memory);
12105               if (internal_relocs == NULL)
12106                 goto error_ret_free_local;
12107
12108               /* Now examine each relocation.  */
12109               irela = internal_relocs;
12110               irelaend = irela + section->reloc_count;
12111               for (; irela < irelaend; irela++)
12112                 {
12113                   enum elf_ppc64_reloc_type r_type;
12114                   unsigned int r_indx;
12115                   enum ppc_stub_type stub_type;
12116                   struct ppc_stub_hash_entry *stub_entry;
12117                   asection *sym_sec, *code_sec;
12118                   bfd_vma sym_value, code_value;
12119                   bfd_vma destination;
12120                   unsigned long local_off;
12121                   bfd_boolean ok_dest;
12122                   struct ppc_link_hash_entry *hash;
12123                   struct ppc_link_hash_entry *fdh;
12124                   struct elf_link_hash_entry *h;
12125                   Elf_Internal_Sym *sym;
12126                   char *stub_name;
12127                   const asection *id_sec;
12128                   struct _opd_sec_data *opd;
12129                   struct plt_entry *plt_ent;
12130
12131                   r_type = ELF64_R_TYPE (irela->r_info);
12132                   r_indx = ELF64_R_SYM (irela->r_info);
12133
12134                   if (r_type >= R_PPC64_max)
12135                     {
12136                       bfd_set_error (bfd_error_bad_value);
12137                       goto error_ret_free_internal;
12138                     }
12139
12140                   /* Only look for stubs on branch instructions.  */
12141                   if (r_type != R_PPC64_REL24
12142                       && r_type != R_PPC64_REL14
12143                       && r_type != R_PPC64_REL14_BRTAKEN
12144                       && r_type != R_PPC64_REL14_BRNTAKEN)
12145                     continue;
12146
12147                   /* Now determine the call target, its name, value,
12148                      section.  */
12149                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12150                                   r_indx, input_bfd))
12151                     goto error_ret_free_internal;
12152                   hash = (struct ppc_link_hash_entry *) h;
12153
12154                   ok_dest = FALSE;
12155                   fdh = NULL;
12156                   sym_value = 0;
12157                   if (hash == NULL)
12158                     {
12159                       sym_value = sym->st_value;
12160                       ok_dest = TRUE;
12161                     }
12162                   else if (hash->elf.root.type == bfd_link_hash_defined
12163                            || hash->elf.root.type == bfd_link_hash_defweak)
12164                     {
12165                       sym_value = hash->elf.root.u.def.value;
12166                       if (sym_sec->output_section != NULL)
12167                         ok_dest = TRUE;
12168                     }
12169                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12170                            || hash->elf.root.type == bfd_link_hash_undefined)
12171                     {
12172                       /* Recognise an old ABI func code entry sym, and
12173                          use the func descriptor sym instead if it is
12174                          defined.  */
12175                       if (hash->elf.root.root.string[0] == '.'
12176                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12177                         {
12178                           if (fdh->elf.root.type == bfd_link_hash_defined
12179                               || fdh->elf.root.type == bfd_link_hash_defweak)
12180                             {
12181                               sym_sec = fdh->elf.root.u.def.section;
12182                               sym_value = fdh->elf.root.u.def.value;
12183                               if (sym_sec->output_section != NULL)
12184                                 ok_dest = TRUE;
12185                             }
12186                           else
12187                             fdh = NULL;
12188                         }
12189                     }
12190                   else
12191                     {
12192                       bfd_set_error (bfd_error_bad_value);
12193                       goto error_ret_free_internal;
12194                     }
12195
12196                   destination = 0;
12197                   local_off = 0;
12198                   if (ok_dest)
12199                     {
12200                       sym_value += irela->r_addend;
12201                       destination = (sym_value
12202                                      + sym_sec->output_offset
12203                                      + sym_sec->output_section->vma);
12204                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12205                                                             ? hash->elf.other
12206                                                             : sym->st_other);
12207                     }
12208
12209                   code_sec = sym_sec;
12210                   code_value = sym_value;
12211                   opd = get_opd_info (sym_sec);
12212                   if (opd != NULL)
12213                     {
12214                       bfd_vma dest;
12215
12216                       if (hash == NULL && opd->adjust != NULL)
12217                         {
12218                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12219                           if (adjust == -1)
12220                             continue;
12221                           code_value += adjust;
12222                           sym_value += adjust;
12223                         }
12224                       dest = opd_entry_value (sym_sec, sym_value,
12225                                               &code_sec, &code_value, FALSE);
12226                       if (dest != (bfd_vma) -1)
12227                         {
12228                           destination = dest;
12229                           if (fdh != NULL)
12230                             {
12231                               /* Fixup old ABI sym to point at code
12232                                  entry.  */
12233                               hash->elf.root.type = bfd_link_hash_defweak;
12234                               hash->elf.root.u.def.section = code_sec;
12235                               hash->elf.root.u.def.value = code_value;
12236                             }
12237                         }
12238                     }
12239
12240                   /* Determine what (if any) linker stub is needed.  */
12241                   plt_ent = NULL;
12242                   stub_type = ppc_type_of_stub (section, irela, &hash,
12243                                                 &plt_ent, destination,
12244                                                 local_off);
12245
12246                   if (stub_type != ppc_stub_plt_call)
12247                     {
12248                       /* Check whether we need a TOC adjusting stub.
12249                          Since the linker pastes together pieces from
12250                          different object files when creating the
12251                          _init and _fini functions, it may be that a
12252                          call to what looks like a local sym is in
12253                          fact a call needing a TOC adjustment.  */
12254                       if (code_sec != NULL
12255                           && code_sec->output_section != NULL
12256                           && (htab->stub_group[code_sec->id].toc_off
12257                               != htab->stub_group[section->id].toc_off)
12258                           && (code_sec->has_toc_reloc
12259                               || code_sec->makes_toc_func_call))
12260                         stub_type = ppc_stub_long_branch_r2off;
12261                     }
12262
12263                   if (stub_type == ppc_stub_none)
12264                     continue;
12265
12266                   /* __tls_get_addr calls might be eliminated.  */
12267                   if (stub_type != ppc_stub_plt_call
12268                       && hash != NULL
12269                       && (hash == htab->tls_get_addr
12270                           || hash == htab->tls_get_addr_fd)
12271                       && section->has_tls_reloc
12272                       && irela != internal_relocs)
12273                     {
12274                       /* Get tls info.  */
12275                       unsigned char *tls_mask;
12276
12277                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12278                                          irela - 1, input_bfd))
12279                         goto error_ret_free_internal;
12280                       if (*tls_mask != 0)
12281                         continue;
12282                     }
12283
12284                   if (stub_type == ppc_stub_plt_call
12285                       && irela + 1 < irelaend
12286                       && irela[1].r_offset == irela->r_offset + 4
12287                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12288                     {
12289                       if (!tocsave_find (htab, INSERT,
12290                                          &local_syms, irela + 1, input_bfd))
12291                         goto error_ret_free_internal;
12292                     }
12293                   else if (stub_type == ppc_stub_plt_call)
12294                     stub_type = ppc_stub_plt_call_r2save;
12295
12296                   /* Support for grouping stub sections.  */
12297                   id_sec = htab->stub_group[section->id].link_sec;
12298
12299                   /* Get the name of this stub.  */
12300                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12301                   if (!stub_name)
12302                     goto error_ret_free_internal;
12303
12304                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12305                                                      stub_name, FALSE, FALSE);
12306                   if (stub_entry != NULL)
12307                     {
12308                       /* The proper stub has already been created.  */
12309                       free (stub_name);
12310                       if (stub_type == ppc_stub_plt_call_r2save)
12311                         stub_entry->stub_type = stub_type;
12312                       continue;
12313                     }
12314
12315                   stub_entry = ppc_add_stub (stub_name, section, info);
12316                   if (stub_entry == NULL)
12317                     {
12318                       free (stub_name);
12319                     error_ret_free_internal:
12320                       if (elf_section_data (section)->relocs == NULL)
12321                         free (internal_relocs);
12322                     error_ret_free_local:
12323                       if (local_syms != NULL
12324                           && (symtab_hdr->contents
12325                               != (unsigned char *) local_syms))
12326                         free (local_syms);
12327                       return FALSE;
12328                     }
12329
12330                   stub_entry->stub_type = stub_type;
12331                   if (stub_type != ppc_stub_plt_call
12332                       && stub_type != ppc_stub_plt_call_r2save)
12333                     {
12334                       stub_entry->target_value = code_value;
12335                       stub_entry->target_section = code_sec;
12336                     }
12337                   else
12338                     {
12339                       stub_entry->target_value = sym_value;
12340                       stub_entry->target_section = sym_sec;
12341                     }
12342                   stub_entry->h = hash;
12343                   stub_entry->plt_ent = plt_ent;
12344                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12345
12346                   if (stub_entry->h != NULL)
12347                     htab->stub_globals += 1;
12348                 }
12349
12350               /* We're done with the internal relocs, free them.  */
12351               if (elf_section_data (section)->relocs != internal_relocs)
12352                 free (internal_relocs);
12353             }
12354
12355           if (local_syms != NULL
12356               && symtab_hdr->contents != (unsigned char *) local_syms)
12357             {
12358               if (!info->keep_memory)
12359                 free (local_syms);
12360               else
12361                 symtab_hdr->contents = (unsigned char *) local_syms;
12362             }
12363         }
12364
12365       /* We may have added some stubs.  Find out the new size of the
12366          stub sections.  */
12367       for (stub_sec = htab->params->stub_bfd->sections;
12368            stub_sec != NULL;
12369            stub_sec = stub_sec->next)
12370         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12371           {
12372             stub_sec->rawsize = stub_sec->size;
12373             stub_sec->size = 0;
12374             stub_sec->reloc_count = 0;
12375             stub_sec->flags &= ~SEC_RELOC;
12376           }
12377
12378       htab->brlt->size = 0;
12379       htab->brlt->reloc_count = 0;
12380       htab->brlt->flags &= ~SEC_RELOC;
12381       if (htab->relbrlt != NULL)
12382         htab->relbrlt->size = 0;
12383
12384       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12385
12386       if (info->emitrelocations
12387           && htab->glink != NULL && htab->glink->size != 0)
12388         {
12389           htab->glink->reloc_count = 1;
12390           htab->glink->flags |= SEC_RELOC;
12391         }
12392
12393       if (htab->glink_eh_frame != NULL
12394           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12395           && htab->glink_eh_frame->output_section->size != 0)
12396         {
12397           size_t size = 0, align;
12398
12399           for (stub_sec = htab->params->stub_bfd->sections;
12400                stub_sec != NULL;
12401                stub_sec = stub_sec->next)
12402             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12403               size += 24;
12404           if (htab->glink != NULL && htab->glink->size != 0)
12405             size += 24;
12406           if (size != 0)
12407             size += sizeof (glink_eh_frame_cie);
12408           align = 1;
12409           align <<= htab->glink_eh_frame->output_section->alignment_power;
12410           align -= 1;
12411           size = (size + align) & ~align;
12412           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12413           htab->glink_eh_frame->size = size;
12414         }
12415
12416       if (htab->params->plt_stub_align != 0)
12417         for (stub_sec = htab->params->stub_bfd->sections;
12418              stub_sec != NULL;
12419              stub_sec = stub_sec->next)
12420           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12421             stub_sec->size = ((stub_sec->size
12422                                + (1 << htab->params->plt_stub_align) - 1)
12423                               & (-1 << htab->params->plt_stub_align));
12424
12425       for (stub_sec = htab->params->stub_bfd->sections;
12426            stub_sec != NULL;
12427            stub_sec = stub_sec->next)
12428         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12429             && stub_sec->rawsize != stub_sec->size)
12430           break;
12431
12432       /* Exit from this loop when no stubs have been added, and no stubs
12433          have changed size.  */
12434       if (stub_sec == NULL
12435           && (htab->glink_eh_frame == NULL
12436               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12437         break;
12438
12439       /* Ask the linker to do its stuff.  */
12440       (*htab->params->layout_sections_again) ();
12441     }
12442
12443   if (htab->glink_eh_frame != NULL
12444       && htab->glink_eh_frame->size != 0)
12445     {
12446       bfd_vma val;
12447       bfd_byte *p, *last_fde;
12448       size_t last_fde_len, size, align, pad;
12449       asection *stub_sec;
12450
12451       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12452       if (p == NULL)
12453         return FALSE;
12454       htab->glink_eh_frame->contents = p;
12455       last_fde = p;
12456
12457       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12458       /* CIE length (rewrite in case little-endian).  */
12459       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12460       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12461       p += sizeof (glink_eh_frame_cie);
12462
12463       for (stub_sec = htab->params->stub_bfd->sections;
12464            stub_sec != NULL;
12465            stub_sec = stub_sec->next)
12466         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12467           {
12468             last_fde = p;
12469             last_fde_len = 20;
12470             /* FDE length.  */
12471             bfd_put_32 (htab->elf.dynobj, 20, p);
12472             p += 4;
12473             /* CIE pointer.  */
12474             val = p - htab->glink_eh_frame->contents;
12475             bfd_put_32 (htab->elf.dynobj, val, p);
12476             p += 4;
12477             /* Offset to stub section, written later.  */
12478             p += 4;
12479             /* stub section size.  */
12480             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12481             p += 4;
12482             /* Augmentation.  */
12483             p += 1;
12484             /* Pad.  */
12485             p += 7;
12486           }
12487       if (htab->glink != NULL && htab->glink->size != 0)
12488         {
12489           last_fde = p;
12490           last_fde_len = 20;
12491           /* FDE length.  */
12492           bfd_put_32 (htab->elf.dynobj, 20, p);
12493           p += 4;
12494           /* CIE pointer.  */
12495           val = p - htab->glink_eh_frame->contents;
12496           bfd_put_32 (htab->elf.dynobj, val, p);
12497           p += 4;
12498           /* Offset to .glink, written later.  */
12499           p += 4;
12500           /* .glink size.  */
12501           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12502           p += 4;
12503           /* Augmentation.  */
12504           p += 1;
12505
12506           *p++ = DW_CFA_advance_loc + 1;
12507           *p++ = DW_CFA_register;
12508           *p++ = 65;
12509           *p++ = 12;
12510           *p++ = DW_CFA_advance_loc + 4;
12511           *p++ = DW_CFA_restore_extended;
12512           *p++ = 65;
12513         }
12514       /* Subsume any padding into the last FDE if user .eh_frame
12515          sections are aligned more than glink_eh_frame.  Otherwise any
12516          zero padding will be seen as a terminator.  */
12517       size = p - htab->glink_eh_frame->contents;
12518       align = 1;
12519       align <<= htab->glink_eh_frame->output_section->alignment_power;
12520       align -= 1;
12521       pad = ((size + align) & ~align) - size;
12522       htab->glink_eh_frame->size = size + pad;
12523       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12524     }
12525
12526   maybe_strip_output (info, htab->brlt);
12527   if (htab->glink_eh_frame != NULL)
12528     maybe_strip_output (info, htab->glink_eh_frame);
12529
12530   return TRUE;
12531 }
12532
12533 /* Called after we have determined section placement.  If sections
12534    move, we'll be called again.  Provide a value for TOCstart.  */
12535
12536 bfd_vma
12537 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12538 {
12539   asection *s;
12540   bfd_vma TOCstart, adjust;
12541
12542   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12543      order.  The TOC starts where the first of these sections starts.  */
12544   s = bfd_get_section_by_name (obfd, ".got");
12545   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12546     s = bfd_get_section_by_name (obfd, ".toc");
12547   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12548     s = bfd_get_section_by_name (obfd, ".tocbss");
12549   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12550     s = bfd_get_section_by_name (obfd, ".plt");
12551   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12552     {
12553       /* This may happen for
12554          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12555          .toc directive
12556          o  bad linker script
12557          o --gc-sections and empty TOC sections
12558
12559          FIXME: Warn user?  */
12560
12561       /* Look for a likely section.  We probably won't even be
12562          using TOCstart.  */
12563       for (s = obfd->sections; s != NULL; s = s->next)
12564         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12565                          | SEC_EXCLUDE))
12566             == (SEC_ALLOC | SEC_SMALL_DATA))
12567           break;
12568       if (s == NULL)
12569         for (s = obfd->sections; s != NULL; s = s->next)
12570           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12571               == (SEC_ALLOC | SEC_SMALL_DATA))
12572             break;
12573       if (s == NULL)
12574         for (s = obfd->sections; s != NULL; s = s->next)
12575           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12576               == SEC_ALLOC)
12577             break;
12578       if (s == NULL)
12579         for (s = obfd->sections; s != NULL; s = s->next)
12580           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12581             break;
12582     }
12583
12584   TOCstart = 0;
12585   if (s != NULL)
12586     TOCstart = s->output_section->vma + s->output_offset;
12587
12588   /* Force alignment.  */
12589   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12590   TOCstart -= adjust;
12591   _bfd_set_gp_value (obfd, TOCstart);
12592
12593   if (info != NULL && s != NULL)
12594     {
12595       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12596
12597       if (htab != NULL)
12598         {
12599           if (htab->elf.hgot != NULL)
12600             {
12601               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12602               htab->elf.hgot->root.u.def.section = s;
12603             }
12604         }
12605       else
12606         {
12607           struct bfd_link_hash_entry *bh = NULL;
12608           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12609                                             s, TOC_BASE_OFF - adjust,
12610                                             NULL, FALSE, FALSE, &bh);
12611         }
12612     }
12613   return TOCstart;
12614 }
12615
12616 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12617    write out any global entry stubs.  */
12618
12619 static bfd_boolean
12620 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12621 {
12622   struct bfd_link_info *info;
12623   struct ppc_link_hash_table *htab;
12624   struct plt_entry *pent;
12625   asection *s;
12626
12627   if (h->root.type == bfd_link_hash_indirect)
12628     return TRUE;
12629
12630   if (!h->pointer_equality_needed)
12631     return TRUE;
12632
12633   if (h->def_regular)
12634     return TRUE;
12635
12636   info = inf;
12637   htab = ppc_hash_table (info);
12638   if (htab == NULL)
12639     return FALSE;
12640
12641   s = htab->glink;
12642   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12643     if (pent->plt.offset != (bfd_vma) -1
12644         && pent->addend == 0)
12645       {
12646         bfd_byte *p;
12647         asection *plt;
12648         bfd_vma off;
12649
12650         p = s->contents + h->root.u.def.value;
12651         plt = htab->elf.splt;
12652         if (!htab->elf.dynamic_sections_created
12653             || h->dynindx == -1)
12654           plt = htab->elf.iplt;
12655         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12656         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12657
12658         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12659           {
12660             info->callbacks->einfo
12661               (_("%P: linkage table error against `%T'\n"),
12662                h->root.root.string);
12663             bfd_set_error (bfd_error_bad_value);
12664             htab->stub_error = TRUE;
12665           }
12666
12667         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12668         if (htab->params->emit_stub_syms)
12669           {
12670             size_t len = strlen (h->root.root.string);
12671             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12672
12673             if (name == NULL)
12674               return FALSE;
12675
12676             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12677             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12678             if (h == NULL)
12679               return FALSE;
12680             if (h->root.type == bfd_link_hash_new)
12681               {
12682                 h->root.type = bfd_link_hash_defined;
12683                 h->root.u.def.section = s;
12684                 h->root.u.def.value = p - s->contents;
12685                 h->ref_regular = 1;
12686                 h->def_regular = 1;
12687                 h->ref_regular_nonweak = 1;
12688                 h->forced_local = 1;
12689                 h->non_elf = 0;
12690                 h->root.linker_def = 1;
12691               }
12692           }
12693
12694         if (PPC_HA (off) != 0)
12695           {
12696             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12697             p += 4;
12698           }
12699         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12700         p += 4;
12701         bfd_put_32 (s->owner, MTCTR_R12, p);
12702         p += 4;
12703         bfd_put_32 (s->owner, BCTR, p);
12704         break;
12705       }
12706   return TRUE;
12707 }
12708
12709 /* Build all the stubs associated with the current output file.
12710    The stubs are kept in a hash table attached to the main linker
12711    hash table.  This function is called via gldelf64ppc_finish.  */
12712
12713 bfd_boolean
12714 ppc64_elf_build_stubs (struct bfd_link_info *info,
12715                        char **stats)
12716 {
12717   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12718   asection *stub_sec;
12719   bfd_byte *p;
12720   int stub_sec_count = 0;
12721
12722   if (htab == NULL)
12723     return FALSE;
12724
12725   /* Allocate memory to hold the linker stubs.  */
12726   for (stub_sec = htab->params->stub_bfd->sections;
12727        stub_sec != NULL;
12728        stub_sec = stub_sec->next)
12729     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12730         && stub_sec->size != 0)
12731       {
12732         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12733         if (stub_sec->contents == NULL)
12734           return FALSE;
12735         /* We want to check that built size is the same as calculated
12736            size.  rawsize is a convenient location to use.  */
12737         stub_sec->rawsize = stub_sec->size;
12738         stub_sec->size = 0;
12739       }
12740
12741   if (htab->glink != NULL && htab->glink->size != 0)
12742     {
12743       unsigned int indx;
12744       bfd_vma plt0;
12745
12746       /* Build the .glink plt call stub.  */
12747       if (htab->params->emit_stub_syms)
12748         {
12749           struct elf_link_hash_entry *h;
12750           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12751                                     TRUE, FALSE, FALSE);
12752           if (h == NULL)
12753             return FALSE;
12754           if (h->root.type == bfd_link_hash_new)
12755             {
12756               h->root.type = bfd_link_hash_defined;
12757               h->root.u.def.section = htab->glink;
12758               h->root.u.def.value = 8;
12759               h->ref_regular = 1;
12760               h->def_regular = 1;
12761               h->ref_regular_nonweak = 1;
12762               h->forced_local = 1;
12763               h->non_elf = 0;
12764               h->root.linker_def = 1;
12765             }
12766         }
12767       plt0 = (htab->elf.splt->output_section->vma
12768               + htab->elf.splt->output_offset
12769               - 16);
12770       if (info->emitrelocations)
12771         {
12772           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12773           if (r == NULL)
12774             return FALSE;
12775           r->r_offset = (htab->glink->output_offset
12776                          + htab->glink->output_section->vma);
12777           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12778           r->r_addend = plt0;
12779         }
12780       p = htab->glink->contents;
12781       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12782       bfd_put_64 (htab->glink->owner, plt0, p);
12783       p += 8;
12784       if (htab->opd_abi)
12785         {
12786           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12787           p += 4;
12788           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12789           p += 4;
12790           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12791           p += 4;
12792           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12793           p += 4;
12794           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12795           p += 4;
12796           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12797           p += 4;
12798           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12799           p += 4;
12800           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12801           p += 4;
12802           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12803           p += 4;
12804           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12805           p += 4;
12806         }
12807       else
12808         {
12809           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12810           p += 4;
12811           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12812           p += 4;
12813           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12814           p += 4;
12815           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12816           p += 4;
12817           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12818           p += 4;
12819           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12820           p += 4;
12821           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12822           p += 4;
12823           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12824           p += 4;
12825           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12826           p += 4;
12827           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12828           p += 4;
12829           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12830           p += 4;
12831           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12832           p += 4;
12833         }
12834       bfd_put_32 (htab->glink->owner, BCTR, p);
12835       p += 4;
12836       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12837         {
12838           bfd_put_32 (htab->glink->owner, NOP, p);
12839           p += 4;
12840         }
12841
12842       /* Build the .glink lazy link call stubs.  */
12843       indx = 0;
12844       while (p < htab->glink->contents + htab->glink->rawsize)
12845         {
12846           if (htab->opd_abi)
12847             {
12848               if (indx < 0x8000)
12849                 {
12850                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12851                   p += 4;
12852                 }
12853               else
12854                 {
12855                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12856                   p += 4;
12857                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12858                               p);
12859                   p += 4;
12860                 }
12861             }
12862           bfd_put_32 (htab->glink->owner,
12863                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12864           indx++;
12865           p += 4;
12866         }
12867
12868       /* Build .glink global entry stubs.  */
12869       if (htab->glink->size > htab->glink->rawsize)
12870         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12871     }
12872
12873   if (htab->brlt != NULL && htab->brlt->size != 0)
12874     {
12875       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12876                                          htab->brlt->size);
12877       if (htab->brlt->contents == NULL)
12878         return FALSE;
12879     }
12880   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12881     {
12882       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12883                                             htab->relbrlt->size);
12884       if (htab->relbrlt->contents == NULL)
12885         return FALSE;
12886     }
12887
12888   /* Build the stubs as directed by the stub hash table.  */
12889   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12890
12891   if (htab->relbrlt != NULL)
12892     htab->relbrlt->reloc_count = 0;
12893
12894   if (htab->params->plt_stub_align != 0)
12895     for (stub_sec = htab->params->stub_bfd->sections;
12896          stub_sec != NULL;
12897          stub_sec = stub_sec->next)
12898       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12899         stub_sec->size = ((stub_sec->size
12900                            + (1 << htab->params->plt_stub_align) - 1)
12901                           & (-1 << htab->params->plt_stub_align));
12902
12903   for (stub_sec = htab->params->stub_bfd->sections;
12904        stub_sec != NULL;
12905        stub_sec = stub_sec->next)
12906     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12907       {
12908         stub_sec_count += 1;
12909         if (stub_sec->rawsize != stub_sec->size)
12910           break;
12911       }
12912
12913   /* Note that the glink_eh_frame check here is not only testing that
12914      the generated size matched the calculated size but also that
12915      bfd_elf_discard_info didn't make any changes to the section.  */
12916   if (stub_sec != NULL
12917       || (htab->glink_eh_frame != NULL
12918           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12919     {
12920       htab->stub_error = TRUE;
12921       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12922     }
12923
12924   if (htab->stub_error)
12925     return FALSE;
12926
12927   if (stats != NULL)
12928     {
12929       *stats = bfd_malloc (500);
12930       if (*stats == NULL)
12931         return FALSE;
12932
12933       sprintf (*stats, _("linker stubs in %u group%s\n"
12934                          "  branch       %lu\n"
12935                          "  toc adjust   %lu\n"
12936                          "  long branch  %lu\n"
12937                          "  long toc adj %lu\n"
12938                          "  plt call     %lu\n"
12939                          "  plt call toc %lu\n"
12940                          "  global entry %lu"),
12941                stub_sec_count,
12942                stub_sec_count == 1 ? "" : "s",
12943                htab->stub_count[ppc_stub_long_branch - 1],
12944                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12945                htab->stub_count[ppc_stub_plt_branch - 1],
12946                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12947                htab->stub_count[ppc_stub_plt_call - 1],
12948                htab->stub_count[ppc_stub_plt_call_r2save - 1],
12949                htab->stub_count[ppc_stub_global_entry - 1]);
12950     }
12951   return TRUE;
12952 }
12953
12954 /* This function undoes the changes made by add_symbol_adjust.  */
12955
12956 static bfd_boolean
12957 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12958 {
12959   struct ppc_link_hash_entry *eh;
12960
12961   if (h->root.type == bfd_link_hash_indirect)
12962     return TRUE;
12963
12964   eh = (struct ppc_link_hash_entry *) h;
12965   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12966     return TRUE;
12967
12968   eh->elf.root.type = bfd_link_hash_undefined;
12969   return TRUE;
12970 }
12971
12972 void
12973 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12974 {
12975   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12976
12977   if (htab != NULL)
12978     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12979 }
12980
12981 /* What to do when ld finds relocations against symbols defined in
12982    discarded sections.  */
12983
12984 static unsigned int
12985 ppc64_elf_action_discarded (asection *sec)
12986 {
12987   if (strcmp (".opd", sec->name) == 0)
12988     return 0;
12989
12990   if (strcmp (".toc", sec->name) == 0)
12991     return 0;
12992
12993   if (strcmp (".toc1", sec->name) == 0)
12994     return 0;
12995
12996   return _bfd_elf_default_action_discarded (sec);
12997 }
12998
12999 /* The RELOCATE_SECTION function is called by the ELF backend linker
13000    to handle the relocations for a section.
13001
13002    The relocs are always passed as Rela structures; if the section
13003    actually uses Rel structures, the r_addend field will always be
13004    zero.
13005
13006    This function is responsible for adjust the section contents as
13007    necessary, and (if using Rela relocs and generating a
13008    relocatable output file) adjusting the reloc addend as
13009    necessary.
13010
13011    This function does not have to worry about setting the reloc
13012    address or the reloc symbol index.
13013
13014    LOCAL_SYMS is a pointer to the swapped in local symbols.
13015
13016    LOCAL_SECTIONS is an array giving the section in the input file
13017    corresponding to the st_shndx field of each local symbol.
13018
13019    The global hash table entry for the global symbols can be found
13020    via elf_sym_hashes (input_bfd).
13021
13022    When generating relocatable output, this function must handle
13023    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13024    going to be the section symbol corresponding to the output
13025    section, which means that the addend must be adjusted
13026    accordingly.  */
13027
13028 static bfd_boolean
13029 ppc64_elf_relocate_section (bfd *output_bfd,
13030                             struct bfd_link_info *info,
13031                             bfd *input_bfd,
13032                             asection *input_section,
13033                             bfd_byte *contents,
13034                             Elf_Internal_Rela *relocs,
13035                             Elf_Internal_Sym *local_syms,
13036                             asection **local_sections)
13037 {
13038   struct ppc_link_hash_table *htab;
13039   Elf_Internal_Shdr *symtab_hdr;
13040   struct elf_link_hash_entry **sym_hashes;
13041   Elf_Internal_Rela *rel;
13042   Elf_Internal_Rela *relend;
13043   Elf_Internal_Rela outrel;
13044   bfd_byte *loc;
13045   struct got_entry **local_got_ents;
13046   bfd_vma TOCstart;
13047   bfd_boolean ret = TRUE;
13048   bfd_boolean is_opd;
13049   /* Assume 'at' branch hints.  */
13050   bfd_boolean is_isa_v2 = TRUE;
13051   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13052
13053   /* Initialize howto table if needed.  */
13054   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13055     ppc_howto_init ();
13056
13057   htab = ppc_hash_table (info);
13058   if (htab == NULL)
13059     return FALSE;
13060
13061   /* Don't relocate stub sections.  */
13062   if (input_section->owner == htab->params->stub_bfd)
13063     return TRUE;
13064
13065   BFD_ASSERT (is_ppc64_elf (input_bfd));
13066
13067   local_got_ents = elf_local_got_ents (input_bfd);
13068   TOCstart = elf_gp (output_bfd);
13069   symtab_hdr = &elf_symtab_hdr (input_bfd);
13070   sym_hashes = elf_sym_hashes (input_bfd);
13071   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13072
13073   rel = relocs;
13074   relend = relocs + input_section->reloc_count;
13075   for (; rel < relend; rel++)
13076     {
13077       enum elf_ppc64_reloc_type r_type;
13078       bfd_vma addend;
13079       bfd_reloc_status_type r;
13080       Elf_Internal_Sym *sym;
13081       asection *sec;
13082       struct elf_link_hash_entry *h_elf;
13083       struct ppc_link_hash_entry *h;
13084       struct ppc_link_hash_entry *fdh;
13085       const char *sym_name;
13086       unsigned long r_symndx, toc_symndx;
13087       bfd_vma toc_addend;
13088       unsigned char tls_mask, tls_gd, tls_type;
13089       unsigned char sym_type;
13090       bfd_vma relocation;
13091       bfd_boolean unresolved_reloc;
13092       bfd_boolean warned;
13093       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13094       unsigned int insn;
13095       unsigned int mask;
13096       struct ppc_stub_hash_entry *stub_entry;
13097       bfd_vma max_br_offset;
13098       bfd_vma from;
13099       const Elf_Internal_Rela orig_rel = *rel;
13100       reloc_howto_type *howto;
13101       struct reloc_howto_struct alt_howto;
13102
13103       r_type = ELF64_R_TYPE (rel->r_info);
13104       r_symndx = ELF64_R_SYM (rel->r_info);
13105
13106       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13107          symbol of the previous ADDR64 reloc.  The symbol gives us the
13108          proper TOC base to use.  */
13109       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13110           && rel != relocs
13111           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
13112           && is_opd)
13113         r_symndx = ELF64_R_SYM (rel[-1].r_info);
13114
13115       sym = NULL;
13116       sec = NULL;
13117       h_elf = NULL;
13118       sym_name = NULL;
13119       unresolved_reloc = FALSE;
13120       warned = FALSE;
13121
13122       if (r_symndx < symtab_hdr->sh_info)
13123         {
13124           /* It's a local symbol.  */
13125           struct _opd_sec_data *opd;
13126
13127           sym = local_syms + r_symndx;
13128           sec = local_sections[r_symndx];
13129           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13130           sym_type = ELF64_ST_TYPE (sym->st_info);
13131           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13132           opd = get_opd_info (sec);
13133           if (opd != NULL && opd->adjust != NULL)
13134             {
13135               long adjust = opd->adjust[OPD_NDX (sym->st_value
13136                                                  + rel->r_addend)];
13137               if (adjust == -1)
13138                 relocation = 0;
13139               else
13140                 {
13141                   /* If this is a relocation against the opd section sym
13142                      and we have edited .opd, adjust the reloc addend so
13143                      that ld -r and ld --emit-relocs output is correct.
13144                      If it is a reloc against some other .opd symbol,
13145                      then the symbol value will be adjusted later.  */
13146                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13147                     rel->r_addend += adjust;
13148                   else
13149                     relocation += adjust;
13150                 }
13151             }
13152         }
13153       else
13154         {
13155           bfd_boolean ignored;
13156
13157           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13158                                    r_symndx, symtab_hdr, sym_hashes,
13159                                    h_elf, sec, relocation,
13160                                    unresolved_reloc, warned, ignored);
13161           sym_name = h_elf->root.root.string;
13162           sym_type = h_elf->type;
13163           if (sec != NULL
13164               && sec->owner == output_bfd
13165               && strcmp (sec->name, ".opd") == 0)
13166             {
13167               /* This is a symbol defined in a linker script.  All
13168                  such are defined in output sections, even those
13169                  defined by simple assignment from a symbol defined in
13170                  an input section.  Transfer the symbol to an
13171                  appropriate input .opd section, so that a branch to
13172                  this symbol will be mapped to the location specified
13173                  by the opd entry.  */
13174               struct bfd_link_order *lo;
13175               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13176                 if (lo->type == bfd_indirect_link_order)
13177                   {
13178                     asection *isec = lo->u.indirect.section;
13179                     if (h_elf->root.u.def.value >= isec->output_offset
13180                         && h_elf->root.u.def.value < (isec->output_offset
13181                                                       + isec->size))
13182                       {
13183                         h_elf->root.u.def.value -= isec->output_offset;
13184                         h_elf->root.u.def.section = isec;
13185                         sec = isec;
13186                         break;
13187                       }
13188                   }
13189             }
13190         }
13191       h = (struct ppc_link_hash_entry *) h_elf;
13192
13193       if (sec != NULL && discarded_section (sec))
13194         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13195                                          rel, 1, relend,
13196                                          ppc64_elf_howto_table[r_type], 0,
13197                                          contents);
13198
13199       if (info->relocatable)
13200         continue;
13201
13202       if (h != NULL && &h->elf == htab->elf.hgot)
13203         {
13204           relocation = (TOCstart
13205                         + htab->stub_group[input_section->id].toc_off);
13206           sec = bfd_abs_section_ptr;
13207           unresolved_reloc = FALSE;
13208         }
13209
13210       /* TLS optimizations.  Replace instruction sequences and relocs
13211          based on information we collected in tls_optimize.  We edit
13212          RELOCS so that --emit-relocs will output something sensible
13213          for the final instruction stream.  */
13214       tls_mask = 0;
13215       tls_gd = 0;
13216       toc_symndx = 0;
13217       if (h != NULL)
13218         tls_mask = h->tls_mask;
13219       else if (local_got_ents != NULL)
13220         {
13221           struct plt_entry **local_plt = (struct plt_entry **)
13222             (local_got_ents + symtab_hdr->sh_info);
13223           unsigned char *lgot_masks = (unsigned char *)
13224             (local_plt + symtab_hdr->sh_info);
13225           tls_mask = lgot_masks[r_symndx];
13226         }
13227       if (tls_mask == 0
13228           && (r_type == R_PPC64_TLS
13229               || r_type == R_PPC64_TLSGD
13230               || r_type == R_PPC64_TLSLD))
13231         {
13232           /* Check for toc tls entries.  */
13233           unsigned char *toc_tls;
13234
13235           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13236                              &local_syms, rel, input_bfd))
13237             return FALSE;
13238
13239           if (toc_tls)
13240             tls_mask = *toc_tls;
13241         }
13242
13243       /* Check that tls relocs are used with tls syms, and non-tls
13244          relocs are used with non-tls syms.  */
13245       if (r_symndx != STN_UNDEF
13246           && r_type != R_PPC64_NONE
13247           && (h == NULL
13248               || h->elf.root.type == bfd_link_hash_defined
13249               || h->elf.root.type == bfd_link_hash_defweak)
13250           && (IS_PPC64_TLS_RELOC (r_type)
13251               != (sym_type == STT_TLS
13252                   || (sym_type == STT_SECTION
13253                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13254         {
13255           if (tls_mask != 0
13256               && (r_type == R_PPC64_TLS
13257                   || r_type == R_PPC64_TLSGD
13258                   || r_type == R_PPC64_TLSLD))
13259             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13260             ;
13261           else
13262             info->callbacks->einfo
13263               (!IS_PPC64_TLS_RELOC (r_type)
13264                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13265                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13266                input_bfd, input_section, rel->r_offset,
13267                ppc64_elf_howto_table[r_type]->name,
13268                sym_name);
13269         }
13270
13271       /* Ensure reloc mapping code below stays sane.  */
13272       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13273           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13274           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13275           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13276           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13277           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13278           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13279           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13280           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13281           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13282         abort ();
13283
13284       switch (r_type)
13285         {
13286         default:
13287           break;
13288
13289         case R_PPC64_LO_DS_OPT:
13290           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13291           if ((insn & (0x3f << 26)) != 58u << 26)
13292             abort ();
13293           insn += (14u << 26) - (58u << 26);
13294           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13295           r_type = R_PPC64_TOC16_LO;
13296           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13297           break;
13298
13299         case R_PPC64_TOC16:
13300         case R_PPC64_TOC16_LO:
13301         case R_PPC64_TOC16_DS:
13302         case R_PPC64_TOC16_LO_DS:
13303           {
13304             /* Check for toc tls entries.  */
13305             unsigned char *toc_tls;
13306             int retval;
13307
13308             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13309                                    &local_syms, rel, input_bfd);
13310             if (retval == 0)
13311               return FALSE;
13312
13313             if (toc_tls)
13314               {
13315                 tls_mask = *toc_tls;
13316                 if (r_type == R_PPC64_TOC16_DS
13317                     || r_type == R_PPC64_TOC16_LO_DS)
13318                   {
13319                     if (tls_mask != 0
13320                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13321                       goto toctprel;
13322                   }
13323                 else
13324                   {
13325                     /* If we found a GD reloc pair, then we might be
13326                        doing a GD->IE transition.  */
13327                     if (retval == 2)
13328                       {
13329                         tls_gd = TLS_TPRELGD;
13330                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13331                           goto tls_ldgd_opt;
13332                       }
13333                     else if (retval == 3)
13334                       {
13335                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13336                           goto tls_ldgd_opt;
13337                       }
13338                   }
13339               }
13340           }
13341           break;
13342
13343         case R_PPC64_GOT_TPREL16_HI:
13344         case R_PPC64_GOT_TPREL16_HA:
13345           if (tls_mask != 0
13346               && (tls_mask & TLS_TPREL) == 0)
13347             {
13348               rel->r_offset -= d_offset;
13349               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13350               r_type = R_PPC64_NONE;
13351               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13352             }
13353           break;
13354
13355         case R_PPC64_GOT_TPREL16_DS:
13356         case R_PPC64_GOT_TPREL16_LO_DS:
13357           if (tls_mask != 0
13358               && (tls_mask & TLS_TPREL) == 0)
13359             {
13360             toctprel:
13361               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13362               insn &= 31 << 21;
13363               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13364               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13365               r_type = R_PPC64_TPREL16_HA;
13366               if (toc_symndx != 0)
13367                 {
13368                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13369                   rel->r_addend = toc_addend;
13370                   /* We changed the symbol.  Start over in order to
13371                      get h, sym, sec etc. right.  */
13372                   rel--;
13373                   continue;
13374                 }
13375               else
13376                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13377             }
13378           break;
13379
13380         case R_PPC64_TLS:
13381           if (tls_mask != 0
13382               && (tls_mask & TLS_TPREL) == 0)
13383             {
13384               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13385               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13386               if (insn == 0)
13387                 abort ();
13388               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13389               /* Was PPC64_TLS which sits on insn boundary, now
13390                  PPC64_TPREL16_LO which is at low-order half-word.  */
13391               rel->r_offset += d_offset;
13392               r_type = R_PPC64_TPREL16_LO;
13393               if (toc_symndx != 0)
13394                 {
13395                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13396                   rel->r_addend = toc_addend;
13397                   /* We changed the symbol.  Start over in order to
13398                      get h, sym, sec etc. right.  */
13399                   rel--;
13400                   continue;
13401                 }
13402               else
13403                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13404             }
13405           break;
13406
13407         case R_PPC64_GOT_TLSGD16_HI:
13408         case R_PPC64_GOT_TLSGD16_HA:
13409           tls_gd = TLS_TPRELGD;
13410           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13411             goto tls_gdld_hi;
13412           break;
13413
13414         case R_PPC64_GOT_TLSLD16_HI:
13415         case R_PPC64_GOT_TLSLD16_HA:
13416           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13417             {
13418             tls_gdld_hi:
13419               if ((tls_mask & tls_gd) != 0)
13420                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13421                           + R_PPC64_GOT_TPREL16_DS);
13422               else
13423                 {
13424                   rel->r_offset -= d_offset;
13425                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13426                   r_type = R_PPC64_NONE;
13427                 }
13428               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13429             }
13430           break;
13431
13432         case R_PPC64_GOT_TLSGD16:
13433         case R_PPC64_GOT_TLSGD16_LO:
13434           tls_gd = TLS_TPRELGD;
13435           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13436             goto tls_ldgd_opt;
13437           break;
13438
13439         case R_PPC64_GOT_TLSLD16:
13440         case R_PPC64_GOT_TLSLD16_LO:
13441           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13442             {
13443               unsigned int insn1, insn2, insn3;
13444               bfd_vma offset;
13445
13446             tls_ldgd_opt:
13447               offset = (bfd_vma) -1;
13448               /* If not using the newer R_PPC64_TLSGD/LD to mark
13449                  __tls_get_addr calls, we must trust that the call
13450                  stays with its arg setup insns, ie. that the next
13451                  reloc is the __tls_get_addr call associated with
13452                  the current reloc.  Edit both insns.  */
13453               if (input_section->has_tls_get_addr_call
13454                   && rel + 1 < relend
13455                   && branch_reloc_hash_match (input_bfd, rel + 1,
13456                                               htab->tls_get_addr,
13457                                               htab->tls_get_addr_fd))
13458                 offset = rel[1].r_offset;
13459               /* We read the low GOT_TLS (or TOC16) insn because we
13460                  need to keep the destination reg.  It may be
13461                  something other than the usual r3, and moved to r3
13462                  before the call by intervening code.  */
13463               insn1 = bfd_get_32 (output_bfd,
13464                                   contents + rel->r_offset - d_offset);
13465               if ((tls_mask & tls_gd) != 0)
13466                 {
13467                   /* IE */
13468                   insn1 &= (0x1f << 21) | (0x1f << 16);
13469                   insn1 |= 58 << 26;    /* ld */
13470                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13471                   if (offset != (bfd_vma) -1)
13472                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13473                   if ((tls_mask & TLS_EXPLICIT) == 0)
13474                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13475                               + R_PPC64_GOT_TPREL16_DS);
13476                   else
13477                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13478                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13479                 }
13480               else
13481                 {
13482                   /* LE */
13483                   insn1 &= 0x1f << 21;
13484                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13485                   insn2 = 0x38630000;   /* addi 3,3,0 */
13486                   if (tls_gd == 0)
13487                     {
13488                       /* Was an LD reloc.  */
13489                       if (toc_symndx)
13490                         sec = local_sections[toc_symndx];
13491                       for (r_symndx = 0;
13492                            r_symndx < symtab_hdr->sh_info;
13493                            r_symndx++)
13494                         if (local_sections[r_symndx] == sec)
13495                           break;
13496                       if (r_symndx >= symtab_hdr->sh_info)
13497                         r_symndx = STN_UNDEF;
13498                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13499                       if (r_symndx != STN_UNDEF)
13500                         rel->r_addend -= (local_syms[r_symndx].st_value
13501                                           + sec->output_offset
13502                                           + sec->output_section->vma);
13503                     }
13504                   else if (toc_symndx != 0)
13505                     {
13506                       r_symndx = toc_symndx;
13507                       rel->r_addend = toc_addend;
13508                     }
13509                   r_type = R_PPC64_TPREL16_HA;
13510                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13511                   if (offset != (bfd_vma) -1)
13512                     {
13513                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13514                                                     R_PPC64_TPREL16_LO);
13515                       rel[1].r_offset = offset + d_offset;
13516                       rel[1].r_addend = rel->r_addend;
13517                     }
13518                 }
13519               bfd_put_32 (output_bfd, insn1,
13520                           contents + rel->r_offset - d_offset);
13521               if (offset != (bfd_vma) -1)
13522                 {
13523                   insn3 = bfd_get_32 (output_bfd,
13524                                       contents + offset + 4);
13525                   if (insn3 == NOP
13526                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13527                     {
13528                       rel[1].r_offset += 4;
13529                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13530                       insn2 = NOP;
13531                     }
13532                   bfd_put_32 (output_bfd, insn2, contents + offset);
13533                 }
13534               if ((tls_mask & tls_gd) == 0
13535                   && (tls_gd == 0 || toc_symndx != 0))
13536                 {
13537                   /* We changed the symbol.  Start over in order
13538                      to get h, sym, sec etc. right.  */
13539                   rel--;
13540                   continue;
13541                 }
13542             }
13543           break;
13544
13545         case R_PPC64_TLSGD:
13546           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13547             {
13548               unsigned int insn2, insn3;
13549               bfd_vma offset = rel->r_offset;
13550
13551               if ((tls_mask & TLS_TPRELGD) != 0)
13552                 {
13553                   /* IE */
13554                   r_type = R_PPC64_NONE;
13555                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13556                 }
13557               else
13558                 {
13559                   /* LE */
13560                   if (toc_symndx != 0)
13561                     {
13562                       r_symndx = toc_symndx;
13563                       rel->r_addend = toc_addend;
13564                     }
13565                   r_type = R_PPC64_TPREL16_LO;
13566                   rel->r_offset = offset + d_offset;
13567                   insn2 = 0x38630000;   /* addi 3,3,0 */
13568                 }
13569               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13570               /* Zap the reloc on the _tls_get_addr call too.  */
13571               BFD_ASSERT (offset == rel[1].r_offset);
13572               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13573               insn3 = bfd_get_32 (output_bfd,
13574                                   contents + offset + 4);
13575               if (insn3 == NOP
13576                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13577                 {
13578                   rel->r_offset += 4;
13579                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13580                   insn2 = NOP;
13581                 }
13582               bfd_put_32 (output_bfd, insn2, contents + offset);
13583               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13584                 {
13585                   rel--;
13586                   continue;
13587                 }
13588             }
13589           break;
13590
13591         case R_PPC64_TLSLD:
13592           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13593             {
13594               unsigned int insn2, insn3;
13595               bfd_vma offset = rel->r_offset;
13596
13597               if (toc_symndx)
13598                 sec = local_sections[toc_symndx];
13599               for (r_symndx = 0;
13600                    r_symndx < symtab_hdr->sh_info;
13601                    r_symndx++)
13602                 if (local_sections[r_symndx] == sec)
13603                   break;
13604               if (r_symndx >= symtab_hdr->sh_info)
13605                 r_symndx = STN_UNDEF;
13606               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13607               if (r_symndx != STN_UNDEF)
13608                 rel->r_addend -= (local_syms[r_symndx].st_value
13609                                   + sec->output_offset
13610                                   + sec->output_section->vma);
13611
13612               r_type = R_PPC64_TPREL16_LO;
13613               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13614               rel->r_offset = offset + d_offset;
13615               /* Zap the reloc on the _tls_get_addr call too.  */
13616               BFD_ASSERT (offset == rel[1].r_offset);
13617               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13618               insn2 = 0x38630000;       /* addi 3,3,0 */
13619               insn3 = bfd_get_32 (output_bfd,
13620                                   contents + offset + 4);
13621               if (insn3 == NOP
13622                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13623                 {
13624                   rel->r_offset += 4;
13625                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13626                   insn2 = NOP;
13627                 }
13628               bfd_put_32 (output_bfd, insn2, contents + offset);
13629               rel--;
13630               continue;
13631             }
13632           break;
13633
13634         case R_PPC64_DTPMOD64:
13635           if (rel + 1 < relend
13636               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13637               && rel[1].r_offset == rel->r_offset + 8)
13638             {
13639               if ((tls_mask & TLS_GD) == 0)
13640                 {
13641                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13642                   if ((tls_mask & TLS_TPRELGD) != 0)
13643                     r_type = R_PPC64_TPREL64;
13644                   else
13645                     {
13646                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13647                       r_type = R_PPC64_NONE;
13648                     }
13649                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13650                 }
13651             }
13652           else
13653             {
13654               if ((tls_mask & TLS_LD) == 0)
13655                 {
13656                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13657                   r_type = R_PPC64_NONE;
13658                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13659                 }
13660             }
13661           break;
13662
13663         case R_PPC64_TPREL64:
13664           if ((tls_mask & TLS_TPREL) == 0)
13665             {
13666               r_type = R_PPC64_NONE;
13667               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13668             }
13669           break;
13670
13671         case R_PPC64_REL16_HA:
13672           /* If we are generating a non-PIC executable, edit
13673              .  0:      addis 2,12,.TOC.-0b@ha
13674              .          addi 2,2,.TOC.-0b@l
13675              used by ELFv2 global entry points to set up r2, to
13676              .          lis 2,.TOC.@ha
13677              .          addi 2,2,.TOC.@l
13678              if .TOC. is in range.  */
13679           if (!info->shared
13680               && !info->traditional_format
13681               && h != NULL && &h->elf == htab->elf.hgot
13682               && rel + 1 < relend
13683               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13684               && rel[1].r_offset == rel->r_offset + 4
13685               && rel[1].r_addend == rel->r_addend + 4
13686               && relocation + 0x80008000 <= 0xffffffff)
13687             {
13688               unsigned int insn1, insn2;
13689               bfd_vma offset = rel->r_offset - d_offset;
13690               insn1 = bfd_get_32 (output_bfd, contents + offset);
13691               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13692               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13693                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13694                 {
13695                   r_type = R_PPC64_ADDR16_HA;
13696                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13697                   rel->r_addend -= d_offset;
13698                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13699                   rel[1].r_addend -= d_offset + 4;
13700                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13701                 }
13702             }
13703           break;
13704         }
13705
13706       /* Handle other relocations that tweak non-addend part of insn.  */
13707       insn = 0;
13708       max_br_offset = 1 << 25;
13709       addend = rel->r_addend;
13710       reloc_dest = DEST_NORMAL;
13711       switch (r_type)
13712         {
13713         default:
13714           break;
13715
13716         case R_PPC64_TOCSAVE:
13717           if (relocation + addend == (rel->r_offset
13718                                       + input_section->output_offset
13719                                       + input_section->output_section->vma)
13720               && tocsave_find (htab, NO_INSERT,
13721                                &local_syms, rel, input_bfd))
13722             {
13723               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13724               if (insn == NOP
13725                   || insn == CROR_151515 || insn == CROR_313131)
13726                 bfd_put_32 (input_bfd,
13727                             STD_R2_0R1 + STK_TOC (htab),
13728                             contents + rel->r_offset);
13729             }
13730           break;
13731
13732           /* Branch taken prediction relocations.  */
13733         case R_PPC64_ADDR14_BRTAKEN:
13734         case R_PPC64_REL14_BRTAKEN:
13735           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13736           /* Fall thru.  */
13737
13738           /* Branch not taken prediction relocations.  */
13739         case R_PPC64_ADDR14_BRNTAKEN:
13740         case R_PPC64_REL14_BRNTAKEN:
13741           insn |= bfd_get_32 (output_bfd,
13742                               contents + rel->r_offset) & ~(0x01 << 21);
13743           /* Fall thru.  */
13744
13745         case R_PPC64_REL14:
13746           max_br_offset = 1 << 15;
13747           /* Fall thru.  */
13748
13749         case R_PPC64_REL24:
13750           /* Calls to functions with a different TOC, such as calls to
13751              shared objects, need to alter the TOC pointer.  This is
13752              done using a linkage stub.  A REL24 branching to these
13753              linkage stubs needs to be followed by a nop, as the nop
13754              will be replaced with an instruction to restore the TOC
13755              base pointer.  */
13756           fdh = h;
13757           if (h != NULL
13758               && h->oh != NULL
13759               && h->oh->is_func_descriptor)
13760             fdh = ppc_follow_link (h->oh);
13761           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13762                                            htab);
13763           if (stub_entry != NULL
13764               && (stub_entry->stub_type == ppc_stub_plt_call
13765                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13766                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13767                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13768             {
13769               bfd_boolean can_plt_call = FALSE;
13770
13771               /* All of these stubs will modify r2, so there must be a
13772                  branch and link followed by a nop.  The nop is
13773                  replaced by an insn to restore r2.  */
13774               if (rel->r_offset + 8 <= input_section->size)
13775                 {
13776                   unsigned long br;
13777
13778                   br = bfd_get_32 (input_bfd,
13779                                    contents + rel->r_offset);
13780                   if ((br & 1) != 0)
13781                     {
13782                       unsigned long nop;
13783
13784                       nop = bfd_get_32 (input_bfd,
13785                                         contents + rel->r_offset + 4);
13786                       if (nop == NOP
13787                           || nop == CROR_151515 || nop == CROR_313131)
13788                         {
13789                           if (h != NULL
13790                               && (h == htab->tls_get_addr_fd
13791                                   || h == htab->tls_get_addr)
13792                               && !htab->params->no_tls_get_addr_opt)
13793                             {
13794                               /* Special stub used, leave nop alone.  */
13795                             }
13796                           else
13797                             bfd_put_32 (input_bfd,
13798                                         LD_R2_0R1 + STK_TOC (htab),
13799                                         contents + rel->r_offset + 4);
13800                           can_plt_call = TRUE;
13801                         }
13802                     }
13803                 }
13804
13805               if (!can_plt_call && h != NULL)
13806                 {
13807                   const char *name = h->elf.root.root.string;
13808
13809                   if (*name == '.')
13810                     ++name;
13811
13812                   if (strncmp (name, "__libc_start_main", 17) == 0
13813                       && (name[17] == 0 || name[17] == '@'))
13814                     {
13815                       /* Allow crt1 branch to go via a toc adjusting
13816                          stub.  Other calls that never return could do
13817                          the same, if we could detect such.  */
13818                       can_plt_call = TRUE;
13819                     }
13820                 }
13821
13822               if (!can_plt_call)
13823                 {
13824                   /* g++ as of 20130507 emits self-calls without a
13825                      following nop.  This is arguably wrong since we
13826                      have conflicting information.  On the one hand a
13827                      global symbol and on the other a local call
13828                      sequence, but don't error for this special case.
13829                      It isn't possible to cheaply verify we have
13830                      exactly such a call.  Allow all calls to the same
13831                      section.  */
13832                   asection *code_sec = sec;
13833
13834                   if (get_opd_info (sec) != NULL)
13835                     {
13836                       bfd_vma off = (relocation + addend
13837                                      - sec->output_section->vma
13838                                      - sec->output_offset);
13839
13840                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13841                     }
13842                   if (code_sec == input_section)
13843                     can_plt_call = TRUE;
13844                 }
13845
13846               if (!can_plt_call)
13847                 {
13848                   if (stub_entry->stub_type == ppc_stub_plt_call
13849                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13850                     info->callbacks->einfo
13851                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13852                          "recompile with -fPIC\n"),
13853                        input_bfd, input_section, rel->r_offset, sym_name);
13854                   else
13855                     info->callbacks->einfo
13856                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13857                          "(-mcmodel=small toc adjust stub)\n"),
13858                        input_bfd, input_section, rel->r_offset, sym_name);
13859
13860                   bfd_set_error (bfd_error_bad_value);
13861                   ret = FALSE;
13862                 }
13863
13864               if (can_plt_call
13865                   && (stub_entry->stub_type == ppc_stub_plt_call
13866                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13867                 unresolved_reloc = FALSE;
13868             }
13869
13870           if ((stub_entry == NULL
13871                || stub_entry->stub_type == ppc_stub_long_branch
13872                || stub_entry->stub_type == ppc_stub_plt_branch)
13873               && get_opd_info (sec) != NULL)
13874             {
13875               /* The branch destination is the value of the opd entry. */
13876               bfd_vma off = (relocation + addend
13877                              - sec->output_section->vma
13878                              - sec->output_offset);
13879               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13880               if (dest != (bfd_vma) -1)
13881                 {
13882                   relocation = dest;
13883                   addend = 0;
13884                   reloc_dest = DEST_OPD;
13885                 }
13886             }
13887
13888           /* If the branch is out of reach we ought to have a long
13889              branch stub.  */
13890           from = (rel->r_offset
13891                   + input_section->output_offset
13892                   + input_section->output_section->vma);
13893
13894           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13895                                                   ? fdh->elf.other
13896                                                   : sym->st_other);
13897
13898           if (stub_entry != NULL
13899               && (stub_entry->stub_type == ppc_stub_long_branch
13900                   || stub_entry->stub_type == ppc_stub_plt_branch)
13901               && (r_type == R_PPC64_ADDR14_BRTAKEN
13902                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13903                   || (relocation + addend - from + max_br_offset
13904                       < 2 * max_br_offset)))
13905             /* Don't use the stub if this branch is in range.  */
13906             stub_entry = NULL;
13907
13908           if (stub_entry != NULL)
13909             {
13910               /* Munge up the value and addend so that we call the stub
13911                  rather than the procedure directly.  */
13912               relocation = (stub_entry->stub_offset
13913                             + stub_entry->stub_sec->output_offset
13914                             + stub_entry->stub_sec->output_section->vma);
13915               addend = 0;
13916               reloc_dest = DEST_STUB;
13917
13918               if ((stub_entry->stub_type == ppc_stub_plt_call
13919                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13920                   && (ALWAYS_EMIT_R2SAVE
13921                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13922                   && rel + 1 < relend
13923                   && rel[1].r_offset == rel->r_offset + 4
13924                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13925                 relocation += 4;
13926             }
13927
13928           if (insn != 0)
13929             {
13930               if (is_isa_v2)
13931                 {
13932                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13933                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13934                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13935                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13936                     insn |= 0x02 << 21;
13937                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13938                     insn |= 0x08 << 21;
13939                   else
13940                     break;
13941                 }
13942               else
13943                 {
13944                   /* Invert 'y' bit if not the default.  */
13945                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13946                     insn ^= 0x01 << 21;
13947                 }
13948
13949               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13950             }
13951
13952           /* NOP out calls to undefined weak functions.
13953              We can thus call a weak function without first
13954              checking whether the function is defined.  */
13955           else if (h != NULL
13956                    && h->elf.root.type == bfd_link_hash_undefweak
13957                    && h->elf.dynindx == -1
13958                    && r_type == R_PPC64_REL24
13959                    && relocation == 0
13960                    && addend == 0)
13961             {
13962               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13963               continue;
13964             }
13965           break;
13966         }
13967
13968       /* Set `addend'.  */
13969       tls_type = 0;
13970       switch (r_type)
13971         {
13972         default:
13973           info->callbacks->einfo
13974             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13975              input_bfd, (int) r_type, sym_name);
13976
13977           bfd_set_error (bfd_error_bad_value);
13978           ret = FALSE;
13979           continue;
13980
13981         case R_PPC64_NONE:
13982         case R_PPC64_TLS:
13983         case R_PPC64_TLSGD:
13984         case R_PPC64_TLSLD:
13985         case R_PPC64_TOCSAVE:
13986         case R_PPC64_GNU_VTINHERIT:
13987         case R_PPC64_GNU_VTENTRY:
13988           continue;
13989
13990           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13991              address in the GOT as relocation value instead of the
13992              symbol's value itself.  Also, create a GOT entry for the
13993              symbol and put the symbol value there.  */
13994         case R_PPC64_GOT_TLSGD16:
13995         case R_PPC64_GOT_TLSGD16_LO:
13996         case R_PPC64_GOT_TLSGD16_HI:
13997         case R_PPC64_GOT_TLSGD16_HA:
13998           tls_type = TLS_TLS | TLS_GD;
13999           goto dogot;
14000
14001         case R_PPC64_GOT_TLSLD16:
14002         case R_PPC64_GOT_TLSLD16_LO:
14003         case R_PPC64_GOT_TLSLD16_HI:
14004         case R_PPC64_GOT_TLSLD16_HA:
14005           tls_type = TLS_TLS | TLS_LD;
14006           goto dogot;
14007
14008         case R_PPC64_GOT_TPREL16_DS:
14009         case R_PPC64_GOT_TPREL16_LO_DS:
14010         case R_PPC64_GOT_TPREL16_HI:
14011         case R_PPC64_GOT_TPREL16_HA:
14012           tls_type = TLS_TLS | TLS_TPREL;
14013           goto dogot;
14014
14015         case R_PPC64_GOT_DTPREL16_DS:
14016         case R_PPC64_GOT_DTPREL16_LO_DS:
14017         case R_PPC64_GOT_DTPREL16_HI:
14018         case R_PPC64_GOT_DTPREL16_HA:
14019           tls_type = TLS_TLS | TLS_DTPREL;
14020           goto dogot;
14021
14022         case R_PPC64_GOT16:
14023         case R_PPC64_GOT16_LO:
14024         case R_PPC64_GOT16_HI:
14025         case R_PPC64_GOT16_HA:
14026         case R_PPC64_GOT16_DS:
14027         case R_PPC64_GOT16_LO_DS:
14028         dogot:
14029           {
14030             /* Relocation is to the entry for this symbol in the global
14031                offset table.  */
14032             asection *got;
14033             bfd_vma *offp;
14034             bfd_vma off;
14035             unsigned long indx = 0;
14036             struct got_entry *ent;
14037
14038             if (tls_type == (TLS_TLS | TLS_LD)
14039                 && (h == NULL
14040                     || !h->elf.def_dynamic))
14041               ent = ppc64_tlsld_got (input_bfd);
14042             else
14043               {
14044
14045                 if (h != NULL)
14046                   {
14047                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14048                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
14049                                                           &h->elf)
14050                         || (info->shared
14051                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14052                       /* This is actually a static link, or it is a
14053                          -Bsymbolic link and the symbol is defined
14054                          locally, or the symbol was forced to be local
14055                          because of a version file.  */
14056                       ;
14057                     else
14058                       {
14059                         BFD_ASSERT (h->elf.dynindx != -1);
14060                         indx = h->elf.dynindx;
14061                         unresolved_reloc = FALSE;
14062                       }
14063                     ent = h->elf.got.glist;
14064                   }
14065                 else
14066                   {
14067                     if (local_got_ents == NULL)
14068                       abort ();
14069                     ent = local_got_ents[r_symndx];
14070                   }
14071
14072                 for (; ent != NULL; ent = ent->next)
14073                   if (ent->addend == orig_rel.r_addend
14074                       && ent->owner == input_bfd
14075                       && ent->tls_type == tls_type)
14076                     break;
14077               }
14078
14079             if (ent == NULL)
14080               abort ();
14081             if (ent->is_indirect)
14082               ent = ent->got.ent;
14083             offp = &ent->got.offset;
14084             got = ppc64_elf_tdata (ent->owner)->got;
14085             if (got == NULL)
14086               abort ();
14087
14088             /* The offset must always be a multiple of 8.  We use the
14089                least significant bit to record whether we have already
14090                processed this entry.  */
14091             off = *offp;
14092             if ((off & 1) != 0)
14093               off &= ~1;
14094             else
14095               {
14096                 /* Generate relocs for the dynamic linker, except in
14097                    the case of TLSLD where we'll use one entry per
14098                    module.  */
14099                 asection *relgot;
14100                 bfd_boolean ifunc;
14101
14102                 *offp = off | 1;
14103                 relgot = NULL;
14104                 ifunc = (h != NULL
14105                          ? h->elf.type == STT_GNU_IFUNC
14106                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14107                 if (ifunc)
14108                   relgot = htab->elf.irelplt;
14109                 else if ((info->shared || indx != 0)
14110                          && (h == NULL
14111                              || (tls_type == (TLS_TLS | TLS_LD)
14112                                  && !h->elf.def_dynamic)
14113                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14114                              || h->elf.root.type != bfd_link_hash_undefweak))
14115                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14116                 if (relgot != NULL)
14117                   {
14118                     outrel.r_offset = (got->output_section->vma
14119                                        + got->output_offset
14120                                        + off);
14121                     outrel.r_addend = addend;
14122                     if (tls_type & (TLS_LD | TLS_GD))
14123                       {
14124                         outrel.r_addend = 0;
14125                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14126                         if (tls_type == (TLS_TLS | TLS_GD))
14127                           {
14128                             loc = relgot->contents;
14129                             loc += (relgot->reloc_count++
14130                                     * sizeof (Elf64_External_Rela));
14131                             bfd_elf64_swap_reloca_out (output_bfd,
14132                                                        &outrel, loc);
14133                             outrel.r_offset += 8;
14134                             outrel.r_addend = addend;
14135                             outrel.r_info
14136                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14137                           }
14138                       }
14139                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14140                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14141                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14142                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14143                     else if (indx != 0)
14144                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14145                     else
14146                       {
14147                         if (ifunc)
14148                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14149                         else
14150                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14151
14152                         /* Write the .got section contents for the sake
14153                            of prelink.  */
14154                         loc = got->contents + off;
14155                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14156                                     loc);
14157                       }
14158
14159                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14160                       {
14161                         outrel.r_addend += relocation;
14162                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14163                           {
14164                             if (htab->elf.tls_sec == NULL)
14165                               outrel.r_addend = 0;
14166                             else
14167                               outrel.r_addend -= htab->elf.tls_sec->vma;
14168                           }
14169                       }
14170                     loc = relgot->contents;
14171                     loc += (relgot->reloc_count++
14172                             * sizeof (Elf64_External_Rela));
14173                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14174                   }
14175
14176                 /* Init the .got section contents here if we're not
14177                    emitting a reloc.  */
14178                 else
14179                   {
14180                     relocation += addend;
14181                     if (tls_type == (TLS_TLS | TLS_LD))
14182                       relocation = 1;
14183                     else if (tls_type != 0)
14184                       {
14185                         if (htab->elf.tls_sec == NULL)
14186                           relocation = 0;
14187                         else
14188                           {
14189                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14190                             if (tls_type == (TLS_TLS | TLS_TPREL))
14191                               relocation += DTP_OFFSET - TP_OFFSET;
14192                           }
14193
14194                         if (tls_type == (TLS_TLS | TLS_GD))
14195                           {
14196                             bfd_put_64 (output_bfd, relocation,
14197                                         got->contents + off + 8);
14198                             relocation = 1;
14199                           }
14200                       }
14201
14202                     bfd_put_64 (output_bfd, relocation,
14203                                 got->contents + off);
14204                   }
14205               }
14206
14207             if (off >= (bfd_vma) -2)
14208               abort ();
14209
14210             relocation = got->output_section->vma + got->output_offset + off;
14211             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14212           }
14213           break;
14214
14215         case R_PPC64_PLT16_HA:
14216         case R_PPC64_PLT16_HI:
14217         case R_PPC64_PLT16_LO:
14218         case R_PPC64_PLT32:
14219         case R_PPC64_PLT64:
14220           /* Relocation is to the entry for this symbol in the
14221              procedure linkage table.  */
14222
14223           /* Resolve a PLT reloc against a local symbol directly,
14224              without using the procedure linkage table.  */
14225           if (h == NULL)
14226             break;
14227
14228           /* It's possible that we didn't make a PLT entry for this
14229              symbol.  This happens when statically linking PIC code,
14230              or when using -Bsymbolic.  Go find a match if there is a
14231              PLT entry.  */
14232           if (htab->elf.splt != NULL)
14233             {
14234               struct plt_entry *ent;
14235               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14236                 if (ent->plt.offset != (bfd_vma) -1
14237                     && ent->addend == orig_rel.r_addend)
14238                   {
14239                     relocation = (htab->elf.splt->output_section->vma
14240                                   + htab->elf.splt->output_offset
14241                                   + ent->plt.offset);
14242                     unresolved_reloc = FALSE;
14243                     break;
14244                   }
14245             }
14246           break;
14247
14248         case R_PPC64_TOC:
14249           /* Relocation value is TOC base.  */
14250           relocation = TOCstart;
14251           if (r_symndx == STN_UNDEF)
14252             relocation += htab->stub_group[input_section->id].toc_off;
14253           else if (unresolved_reloc)
14254             ;
14255           else if (sec != NULL && sec->id <= htab->top_id)
14256             relocation += htab->stub_group[sec->id].toc_off;
14257           else
14258             unresolved_reloc = TRUE;
14259           goto dodyn;
14260
14261           /* TOC16 relocs.  We want the offset relative to the TOC base,
14262              which is the address of the start of the TOC plus 0x8000.
14263              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14264              in this order.  */
14265         case R_PPC64_TOC16:
14266         case R_PPC64_TOC16_LO:
14267         case R_PPC64_TOC16_HI:
14268         case R_PPC64_TOC16_DS:
14269         case R_PPC64_TOC16_LO_DS:
14270         case R_PPC64_TOC16_HA:
14271           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14272           break;
14273
14274           /* Relocate against the beginning of the section.  */
14275         case R_PPC64_SECTOFF:
14276         case R_PPC64_SECTOFF_LO:
14277         case R_PPC64_SECTOFF_HI:
14278         case R_PPC64_SECTOFF_DS:
14279         case R_PPC64_SECTOFF_LO_DS:
14280         case R_PPC64_SECTOFF_HA:
14281           if (sec != NULL)
14282             addend -= sec->output_section->vma;
14283           break;
14284
14285         case R_PPC64_REL16:
14286         case R_PPC64_REL16_LO:
14287         case R_PPC64_REL16_HI:
14288         case R_PPC64_REL16_HA:
14289           break;
14290
14291         case R_PPC64_REL14:
14292         case R_PPC64_REL14_BRNTAKEN:
14293         case R_PPC64_REL14_BRTAKEN:
14294         case R_PPC64_REL24:
14295           break;
14296
14297         case R_PPC64_TPREL16:
14298         case R_PPC64_TPREL16_LO:
14299         case R_PPC64_TPREL16_HI:
14300         case R_PPC64_TPREL16_HA:
14301         case R_PPC64_TPREL16_DS:
14302         case R_PPC64_TPREL16_LO_DS:
14303         case R_PPC64_TPREL16_HIGH:
14304         case R_PPC64_TPREL16_HIGHA:
14305         case R_PPC64_TPREL16_HIGHER:
14306         case R_PPC64_TPREL16_HIGHERA:
14307         case R_PPC64_TPREL16_HIGHEST:
14308         case R_PPC64_TPREL16_HIGHESTA:
14309           if (h != NULL
14310               && h->elf.root.type == bfd_link_hash_undefweak
14311               && h->elf.dynindx == -1)
14312             {
14313               /* Make this relocation against an undefined weak symbol
14314                  resolve to zero.  This is really just a tweak, since
14315                  code using weak externs ought to check that they are
14316                  defined before using them.  */
14317               bfd_byte *p = contents + rel->r_offset - d_offset;
14318
14319               insn = bfd_get_32 (output_bfd, p);
14320               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14321               if (insn != 0)
14322                 bfd_put_32 (output_bfd, insn, p);
14323               break;
14324             }
14325           if (htab->elf.tls_sec != NULL)
14326             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14327           if (info->shared)
14328             /* The TPREL16 relocs shouldn't really be used in shared
14329                libs as they will result in DT_TEXTREL being set, but
14330                support them anyway.  */
14331             goto dodyn;
14332           break;
14333
14334         case R_PPC64_DTPREL16:
14335         case R_PPC64_DTPREL16_LO:
14336         case R_PPC64_DTPREL16_HI:
14337         case R_PPC64_DTPREL16_HA:
14338         case R_PPC64_DTPREL16_DS:
14339         case R_PPC64_DTPREL16_LO_DS:
14340         case R_PPC64_DTPREL16_HIGH:
14341         case R_PPC64_DTPREL16_HIGHA:
14342         case R_PPC64_DTPREL16_HIGHER:
14343         case R_PPC64_DTPREL16_HIGHERA:
14344         case R_PPC64_DTPREL16_HIGHEST:
14345         case R_PPC64_DTPREL16_HIGHESTA:
14346           if (htab->elf.tls_sec != NULL)
14347             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14348           break;
14349
14350         case R_PPC64_ADDR64_LOCAL:
14351           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14352                                               ? h->elf.other
14353                                               : sym->st_other);
14354           break;
14355
14356         case R_PPC64_DTPMOD64:
14357           relocation = 1;
14358           addend = 0;
14359           goto dodyn;
14360
14361         case R_PPC64_TPREL64:
14362           if (htab->elf.tls_sec != NULL)
14363             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14364           goto dodyn;
14365
14366         case R_PPC64_DTPREL64:
14367           if (htab->elf.tls_sec != NULL)
14368             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14369           /* Fall thru */
14370
14371           /* Relocations that may need to be propagated if this is a
14372              dynamic object.  */
14373         case R_PPC64_REL30:
14374         case R_PPC64_REL32:
14375         case R_PPC64_REL64:
14376         case R_PPC64_ADDR14:
14377         case R_PPC64_ADDR14_BRNTAKEN:
14378         case R_PPC64_ADDR14_BRTAKEN:
14379         case R_PPC64_ADDR16:
14380         case R_PPC64_ADDR16_DS:
14381         case R_PPC64_ADDR16_HA:
14382         case R_PPC64_ADDR16_HI:
14383         case R_PPC64_ADDR16_HIGH:
14384         case R_PPC64_ADDR16_HIGHA:
14385         case R_PPC64_ADDR16_HIGHER:
14386         case R_PPC64_ADDR16_HIGHERA:
14387         case R_PPC64_ADDR16_HIGHEST:
14388         case R_PPC64_ADDR16_HIGHESTA:
14389         case R_PPC64_ADDR16_LO:
14390         case R_PPC64_ADDR16_LO_DS:
14391         case R_PPC64_ADDR24:
14392         case R_PPC64_ADDR32:
14393         case R_PPC64_ADDR64:
14394         case R_PPC64_UADDR16:
14395         case R_PPC64_UADDR32:
14396         case R_PPC64_UADDR64:
14397         dodyn:
14398           if ((input_section->flags & SEC_ALLOC) == 0)
14399             break;
14400
14401           if (NO_OPD_RELOCS && is_opd)
14402             break;
14403
14404           if ((info->shared
14405                && (h == NULL
14406                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14407                    || h->elf.root.type != bfd_link_hash_undefweak)
14408                && (must_be_dyn_reloc (info, r_type)
14409                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14410               || (ELIMINATE_COPY_RELOCS
14411                   && !info->shared
14412                   && h != NULL
14413                   && h->elf.dynindx != -1
14414                   && !h->elf.non_got_ref
14415                   && !h->elf.def_regular)
14416               || (!info->shared
14417                   && (h != NULL
14418                       ? h->elf.type == STT_GNU_IFUNC
14419                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14420             {
14421               bfd_boolean skip, relocate;
14422               asection *sreloc;
14423               bfd_vma out_off;
14424
14425               /* When generating a dynamic object, these relocations
14426                  are copied into the output file to be resolved at run
14427                  time.  */
14428
14429               skip = FALSE;
14430               relocate = FALSE;
14431
14432               out_off = _bfd_elf_section_offset (output_bfd, info,
14433                                                  input_section, rel->r_offset);
14434               if (out_off == (bfd_vma) -1)
14435                 skip = TRUE;
14436               else if (out_off == (bfd_vma) -2)
14437                 skip = TRUE, relocate = TRUE;
14438               out_off += (input_section->output_section->vma
14439                           + input_section->output_offset);
14440               outrel.r_offset = out_off;
14441               outrel.r_addend = rel->r_addend;
14442
14443               /* Optimize unaligned reloc use.  */
14444               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14445                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14446                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14447               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14448                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14449                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14450               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14451                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14452                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14453
14454               if (skip)
14455                 memset (&outrel, 0, sizeof outrel);
14456               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14457                        && !is_opd
14458                        && r_type != R_PPC64_TOC)
14459                 {
14460                   BFD_ASSERT (h->elf.dynindx != -1);
14461                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14462                 }
14463               else
14464                 {
14465                   /* This symbol is local, or marked to become local,
14466                      or this is an opd section reloc which must point
14467                      at a local function.  */
14468                   outrel.r_addend += relocation;
14469                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14470                     {
14471                       if (is_opd && h != NULL)
14472                         {
14473                           /* Lie about opd entries.  This case occurs
14474                              when building shared libraries and we
14475                              reference a function in another shared
14476                              lib.  The same thing happens for a weak
14477                              definition in an application that's
14478                              overridden by a strong definition in a
14479                              shared lib.  (I believe this is a generic
14480                              bug in binutils handling of weak syms.)
14481                              In these cases we won't use the opd
14482                              entry in this lib.  */
14483                           unresolved_reloc = FALSE;
14484                         }
14485                       if (!is_opd
14486                           && r_type == R_PPC64_ADDR64
14487                           && (h != NULL
14488                               ? h->elf.type == STT_GNU_IFUNC
14489                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14490                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14491                       else
14492                         {
14493                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14494
14495                           /* We need to relocate .opd contents for ld.so.
14496                              Prelink also wants simple and consistent rules
14497                              for relocs.  This make all RELATIVE relocs have
14498                              *r_offset equal to r_addend.  */
14499                           relocate = TRUE;
14500                         }
14501                     }
14502                   else
14503                     {
14504                       long indx = 0;
14505
14506                       if (h != NULL
14507                           ? h->elf.type == STT_GNU_IFUNC
14508                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14509                         {
14510                           info->callbacks->einfo
14511                             (_("%P: %H: %s for indirect "
14512                                "function `%T' unsupported\n"),
14513                              input_bfd, input_section, rel->r_offset,
14514                              ppc64_elf_howto_table[r_type]->name,
14515                              sym_name);
14516                           ret = FALSE;
14517                         }
14518                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14519                         ;
14520                       else if (sec == NULL || sec->owner == NULL)
14521                         {
14522                           bfd_set_error (bfd_error_bad_value);
14523                           return FALSE;
14524                         }
14525                       else
14526                         {
14527                           asection *osec;
14528
14529                           osec = sec->output_section;
14530                           indx = elf_section_data (osec)->dynindx;
14531
14532                           if (indx == 0)
14533                             {
14534                               if ((osec->flags & SEC_READONLY) == 0
14535                                   && htab->elf.data_index_section != NULL)
14536                                 osec = htab->elf.data_index_section;
14537                               else
14538                                 osec = htab->elf.text_index_section;
14539                               indx = elf_section_data (osec)->dynindx;
14540                             }
14541                           BFD_ASSERT (indx != 0);
14542
14543                           /* We are turning this relocation into one
14544                              against a section symbol, so subtract out
14545                              the output section's address but not the
14546                              offset of the input section in the output
14547                              section.  */
14548                           outrel.r_addend -= osec->vma;
14549                         }
14550
14551                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14552                     }
14553                 }
14554
14555               sreloc = elf_section_data (input_section)->sreloc;
14556               if (h != NULL
14557                   ? h->elf.type == STT_GNU_IFUNC
14558                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14559                 sreloc = htab->elf.irelplt;
14560               if (sreloc == NULL)
14561                 abort ();
14562
14563               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14564                   >= sreloc->size)
14565                 abort ();
14566               loc = sreloc->contents;
14567               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14568               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14569
14570               /* If this reloc is against an external symbol, it will
14571                  be computed at runtime, so there's no need to do
14572                  anything now.  However, for the sake of prelink ensure
14573                  that the section contents are a known value.  */
14574               if (! relocate)
14575                 {
14576                   unresolved_reloc = FALSE;
14577                   /* The value chosen here is quite arbitrary as ld.so
14578                      ignores section contents except for the special
14579                      case of .opd where the contents might be accessed
14580                      before relocation.  Choose zero, as that won't
14581                      cause reloc overflow.  */
14582                   relocation = 0;
14583                   addend = 0;
14584                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14585                      to improve backward compatibility with older
14586                      versions of ld.  */
14587                   if (r_type == R_PPC64_ADDR64)
14588                     addend = outrel.r_addend;
14589                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14590                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14591                     addend = (input_section->output_section->vma
14592                               + input_section->output_offset
14593                               + rel->r_offset);
14594                 }
14595             }
14596           break;
14597
14598         case R_PPC64_COPY:
14599         case R_PPC64_GLOB_DAT:
14600         case R_PPC64_JMP_SLOT:
14601         case R_PPC64_JMP_IREL:
14602         case R_PPC64_RELATIVE:
14603           /* We shouldn't ever see these dynamic relocs in relocatable
14604              files.  */
14605           /* Fall through.  */
14606
14607         case R_PPC64_PLTGOT16:
14608         case R_PPC64_PLTGOT16_DS:
14609         case R_PPC64_PLTGOT16_HA:
14610         case R_PPC64_PLTGOT16_HI:
14611         case R_PPC64_PLTGOT16_LO:
14612         case R_PPC64_PLTGOT16_LO_DS:
14613         case R_PPC64_PLTREL32:
14614         case R_PPC64_PLTREL64:
14615           /* These ones haven't been implemented yet.  */
14616
14617           info->callbacks->einfo
14618             (_("%P: %B: %s is not supported for `%T'\n"),
14619              input_bfd,
14620              ppc64_elf_howto_table[r_type]->name, sym_name);
14621
14622           bfd_set_error (bfd_error_invalid_operation);
14623           ret = FALSE;
14624           continue;
14625         }
14626
14627       /* Multi-instruction sequences that access the TOC can be
14628          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14629          to             nop;           addi rb,r2,x;  */
14630       switch (r_type)
14631         {
14632         default:
14633           break;
14634
14635         case R_PPC64_GOT_TLSLD16_HI:
14636         case R_PPC64_GOT_TLSGD16_HI:
14637         case R_PPC64_GOT_TPREL16_HI:
14638         case R_PPC64_GOT_DTPREL16_HI:
14639         case R_PPC64_GOT16_HI:
14640         case R_PPC64_TOC16_HI:
14641           /* These relocs would only be useful if building up an
14642              offset to later add to r2, perhaps in an indexed
14643              addressing mode instruction.  Don't try to optimize.
14644              Unfortunately, the possibility of someone building up an
14645              offset like this or even with the HA relocs, means that
14646              we need to check the high insn when optimizing the low
14647              insn.  */
14648           break;
14649
14650         case R_PPC64_GOT_TLSLD16_HA:
14651         case R_PPC64_GOT_TLSGD16_HA:
14652         case R_PPC64_GOT_TPREL16_HA:
14653         case R_PPC64_GOT_DTPREL16_HA:
14654         case R_PPC64_GOT16_HA:
14655         case R_PPC64_TOC16_HA:
14656           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14657               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14658             {
14659               bfd_byte *p = contents + (rel->r_offset & ~3);
14660               bfd_put_32 (input_bfd, NOP, p);
14661             }
14662           break;
14663
14664         case R_PPC64_GOT_TLSLD16_LO:
14665         case R_PPC64_GOT_TLSGD16_LO:
14666         case R_PPC64_GOT_TPREL16_LO_DS:
14667         case R_PPC64_GOT_DTPREL16_LO_DS:
14668         case R_PPC64_GOT16_LO:
14669         case R_PPC64_GOT16_LO_DS:
14670         case R_PPC64_TOC16_LO:
14671         case R_PPC64_TOC16_LO_DS:
14672           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14673               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14674             {
14675               bfd_byte *p = contents + (rel->r_offset & ~3);
14676               insn = bfd_get_32 (input_bfd, p);
14677               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14678                 {
14679                   /* Transform addic to addi when we change reg.  */
14680                   insn &= ~((0x3f << 26) | (0x1f << 16));
14681                   insn |= (14u << 26) | (2 << 16);
14682                 }
14683               else
14684                 {
14685                   insn &= ~(0x1f << 16);
14686                   insn |= 2 << 16;
14687                 }
14688               bfd_put_32 (input_bfd, insn, p);
14689             }
14690           break;
14691         }
14692
14693       /* Do any further special processing.  */
14694       howto = ppc64_elf_howto_table[(int) r_type];
14695       switch (r_type)
14696         {
14697         default:
14698           break;
14699
14700         case R_PPC64_REL16_HA:
14701         case R_PPC64_ADDR16_HA:
14702         case R_PPC64_ADDR16_HIGHA:
14703         case R_PPC64_ADDR16_HIGHERA:
14704         case R_PPC64_ADDR16_HIGHESTA:
14705         case R_PPC64_TOC16_HA:
14706         case R_PPC64_SECTOFF_HA:
14707         case R_PPC64_TPREL16_HA:
14708         case R_PPC64_TPREL16_HIGHA:
14709         case R_PPC64_TPREL16_HIGHERA:
14710         case R_PPC64_TPREL16_HIGHESTA:
14711         case R_PPC64_DTPREL16_HA:
14712         case R_PPC64_DTPREL16_HIGHA:
14713         case R_PPC64_DTPREL16_HIGHERA:
14714         case R_PPC64_DTPREL16_HIGHESTA:
14715           /* It's just possible that this symbol is a weak symbol
14716              that's not actually defined anywhere. In that case,
14717              'sec' would be NULL, and we should leave the symbol
14718              alone (it will be set to zero elsewhere in the link).  */
14719           if (sec == NULL)
14720             break;
14721           /* Fall thru */
14722
14723         case R_PPC64_GOT16_HA:
14724         case R_PPC64_PLTGOT16_HA:
14725         case R_PPC64_PLT16_HA:
14726         case R_PPC64_GOT_TLSGD16_HA:
14727         case R_PPC64_GOT_TLSLD16_HA:
14728         case R_PPC64_GOT_TPREL16_HA:
14729         case R_PPC64_GOT_DTPREL16_HA:
14730           /* Add 0x10000 if sign bit in 0:15 is set.
14731              Bits 0:15 are not used.  */
14732           addend += 0x8000;
14733           break;
14734
14735         case R_PPC64_ADDR16_DS:
14736         case R_PPC64_ADDR16_LO_DS:
14737         case R_PPC64_GOT16_DS:
14738         case R_PPC64_GOT16_LO_DS:
14739         case R_PPC64_PLT16_LO_DS:
14740         case R_PPC64_SECTOFF_DS:
14741         case R_PPC64_SECTOFF_LO_DS:
14742         case R_PPC64_TOC16_DS:
14743         case R_PPC64_TOC16_LO_DS:
14744         case R_PPC64_PLTGOT16_DS:
14745         case R_PPC64_PLTGOT16_LO_DS:
14746         case R_PPC64_GOT_TPREL16_DS:
14747         case R_PPC64_GOT_TPREL16_LO_DS:
14748         case R_PPC64_GOT_DTPREL16_DS:
14749         case R_PPC64_GOT_DTPREL16_LO_DS:
14750         case R_PPC64_TPREL16_DS:
14751         case R_PPC64_TPREL16_LO_DS:
14752         case R_PPC64_DTPREL16_DS:
14753         case R_PPC64_DTPREL16_LO_DS:
14754           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14755           mask = 3;
14756           /* If this reloc is against an lq insn, then the value must be
14757              a multiple of 16.  This is somewhat of a hack, but the
14758              "correct" way to do this by defining _DQ forms of all the
14759              _DS relocs bloats all reloc switches in this file.  It
14760              doesn't seem to make much sense to use any of these relocs
14761              in data, so testing the insn should be safe.  */
14762           if ((insn & (0x3f << 26)) == (56u << 26))
14763             mask = 15;
14764           if (((relocation + addend) & mask) != 0)
14765             {
14766               info->callbacks->einfo
14767                 (_("%P: %H: error: %s not a multiple of %u\n"),
14768                  input_bfd, input_section, rel->r_offset,
14769                  howto->name,
14770                  mask + 1);
14771               bfd_set_error (bfd_error_bad_value);
14772               ret = FALSE;
14773               continue;
14774             }
14775           break;
14776         }
14777
14778       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14779          because such sections are not SEC_ALLOC and thus ld.so will
14780          not process them.  */
14781       if (unresolved_reloc
14782           && !((input_section->flags & SEC_DEBUGGING) != 0
14783                && h->elf.def_dynamic)
14784           && _bfd_elf_section_offset (output_bfd, info, input_section,
14785                                       rel->r_offset) != (bfd_vma) -1)
14786         {
14787           info->callbacks->einfo
14788             (_("%P: %H: unresolvable %s against `%T'\n"),
14789              input_bfd, input_section, rel->r_offset,
14790              howto->name,
14791              h->elf.root.root.string);
14792           ret = FALSE;
14793         }
14794
14795       /* 16-bit fields in insns mostly have signed values, but a
14796          few insns have 16-bit unsigned values.  Really, we should
14797          have different reloc types.  */
14798       if (howto->complain_on_overflow != complain_overflow_dont
14799           && howto->dst_mask == 0xffff
14800           && (input_section->flags & SEC_CODE) != 0)
14801         {
14802           enum complain_overflow complain = complain_overflow_signed;
14803
14804           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14805           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14806             complain = complain_overflow_bitfield;
14807           else if (howto->rightshift == 0
14808                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14809                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14810                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14811                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14812                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14813                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14814             complain = complain_overflow_unsigned;
14815           if (howto->complain_on_overflow != complain)
14816             {
14817               alt_howto = *howto;
14818               alt_howto.complain_on_overflow = complain;
14819               howto = &alt_howto;
14820             }
14821         }
14822
14823       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14824                                     rel->r_offset, relocation, addend);
14825
14826       if (r != bfd_reloc_ok)
14827         {
14828           char *more_info = NULL;
14829           const char *reloc_name = howto->name;
14830
14831           if (reloc_dest != DEST_NORMAL)
14832             {
14833               more_info = bfd_malloc (strlen (reloc_name) + 8);
14834               if (more_info != NULL)
14835                 {
14836                   strcpy (more_info, reloc_name);
14837                   strcat (more_info, (reloc_dest == DEST_OPD
14838                                       ? " (OPD)" : " (stub)"));
14839                   reloc_name = more_info;
14840                 }
14841             }
14842
14843           if (r == bfd_reloc_overflow)
14844             {
14845               /* On code like "if (foo) foo();" don't report overflow
14846                  on a branch to zero when foo is undefined.  */
14847               if (!warned
14848                   && (reloc_dest == DEST_STUB
14849                       || !(h != NULL
14850                            && (h->elf.root.type == bfd_link_hash_undefweak
14851                                || h->elf.root.type == bfd_link_hash_undefined)
14852                            && is_branch_reloc (r_type))))
14853                 {
14854                   if (!((*info->callbacks->reloc_overflow)
14855                         (info, &h->elf.root, sym_name,
14856                          reloc_name, orig_rel.r_addend,
14857                          input_bfd, input_section, rel->r_offset)))
14858                     return FALSE;
14859                 }
14860             }
14861           else
14862             {
14863               info->callbacks->einfo
14864                 (_("%P: %H: %s against `%T': error %d\n"),
14865                  input_bfd, input_section, rel->r_offset,
14866                  reloc_name, sym_name, (int) r);
14867               ret = FALSE;
14868             }
14869           if (more_info != NULL)
14870             free (more_info);
14871         }
14872     }
14873
14874   /* If we're emitting relocations, then shortly after this function
14875      returns, reloc offsets and addends for this section will be
14876      adjusted.  Worse, reloc symbol indices will be for the output
14877      file rather than the input.  Save a copy of the relocs for
14878      opd_entry_value.  */
14879   if (is_opd && (info->emitrelocations || info->relocatable))
14880     {
14881       bfd_size_type amt;
14882       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14883       rel = bfd_alloc (input_bfd, amt);
14884       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14885       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14886       if (rel == NULL)
14887         return FALSE;
14888       memcpy (rel, relocs, amt);
14889     }
14890   return ret;
14891 }
14892
14893 /* Adjust the value of any local symbols in opd sections.  */
14894
14895 static int
14896 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14897                               const char *name ATTRIBUTE_UNUSED,
14898                               Elf_Internal_Sym *elfsym,
14899                               asection *input_sec,
14900                               struct elf_link_hash_entry *h)
14901 {
14902   struct _opd_sec_data *opd;
14903   long adjust;
14904   bfd_vma value;
14905
14906   if (h != NULL)
14907     return 1;
14908
14909   opd = get_opd_info (input_sec);
14910   if (opd == NULL || opd->adjust == NULL)
14911     return 1;
14912
14913   value = elfsym->st_value - input_sec->output_offset;
14914   if (!info->relocatable)
14915     value -= input_sec->output_section->vma;
14916
14917   adjust = opd->adjust[OPD_NDX (value)];
14918   if (adjust == -1)
14919     return 2;
14920
14921   elfsym->st_value += adjust;
14922   return 1;
14923 }
14924
14925 /* Finish up dynamic symbol handling.  We set the contents of various
14926    dynamic sections here.  */
14927
14928 static bfd_boolean
14929 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14930                                  struct bfd_link_info *info,
14931                                  struct elf_link_hash_entry *h,
14932                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14933 {
14934   struct ppc_link_hash_table *htab;
14935   struct plt_entry *ent;
14936   Elf_Internal_Rela rela;
14937   bfd_byte *loc;
14938
14939   htab = ppc_hash_table (info);
14940   if (htab == NULL)
14941     return FALSE;
14942
14943   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14944     if (ent->plt.offset != (bfd_vma) -1)
14945       {
14946         /* This symbol has an entry in the procedure linkage
14947            table.  Set it up.  */
14948         if (!htab->elf.dynamic_sections_created
14949             || h->dynindx == -1)
14950           {
14951             BFD_ASSERT (h->type == STT_GNU_IFUNC
14952                         && h->def_regular
14953                         && (h->root.type == bfd_link_hash_defined
14954                             || h->root.type == bfd_link_hash_defweak));
14955             rela.r_offset = (htab->elf.iplt->output_section->vma
14956                              + htab->elf.iplt->output_offset
14957                              + ent->plt.offset);
14958             if (htab->opd_abi)
14959               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14960             else
14961               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14962             rela.r_addend = (h->root.u.def.value
14963                              + h->root.u.def.section->output_offset
14964                              + h->root.u.def.section->output_section->vma
14965                              + ent->addend);
14966             loc = (htab->elf.irelplt->contents
14967                    + (htab->elf.irelplt->reloc_count++
14968                       * sizeof (Elf64_External_Rela)));
14969           }
14970         else
14971           {
14972             rela.r_offset = (htab->elf.splt->output_section->vma
14973                              + htab->elf.splt->output_offset
14974                              + ent->plt.offset);
14975             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14976             rela.r_addend = ent->addend;
14977             loc = (htab->elf.srelplt->contents
14978                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14979                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14980           }
14981         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14982
14983         if (!htab->opd_abi)
14984           {
14985             if (!h->def_regular)
14986               {
14987                 /* Mark the symbol as undefined, rather than as
14988                    defined in glink.  Leave the value if there were
14989                    any relocations where pointer equality matters
14990                    (this is a clue for the dynamic linker, to make
14991                    function pointer comparisons work between an
14992                    application and shared library), otherwise set it
14993                    to zero.  */
14994                 sym->st_shndx = SHN_UNDEF;
14995                 if (!h->pointer_equality_needed)
14996                   sym->st_value = 0;
14997                 else if (!h->ref_regular_nonweak)
14998                   {
14999                     /* This breaks function pointer comparisons, but
15000                        that is better than breaking tests for a NULL
15001                        function pointer.  */
15002                     sym->st_value = 0;
15003                   }
15004               }
15005           }
15006       }
15007
15008   if (h->needs_copy)
15009     {
15010       /* This symbol needs a copy reloc.  Set it up.  */
15011
15012       if (h->dynindx == -1
15013           || (h->root.type != bfd_link_hash_defined
15014               && h->root.type != bfd_link_hash_defweak)
15015           || htab->relbss == NULL)
15016         abort ();
15017
15018       rela.r_offset = (h->root.u.def.value
15019                        + h->root.u.def.section->output_section->vma
15020                        + h->root.u.def.section->output_offset);
15021       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15022       rela.r_addend = 0;
15023       loc = htab->relbss->contents;
15024       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15025       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15026     }
15027
15028   return TRUE;
15029 }
15030
15031 /* Used to decide how to sort relocs in an optimal manner for the
15032    dynamic linker, before writing them out.  */
15033
15034 static enum elf_reloc_type_class
15035 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15036                             const asection *rel_sec,
15037                             const Elf_Internal_Rela *rela)
15038 {
15039   enum elf_ppc64_reloc_type r_type;
15040   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15041
15042   if (rel_sec == htab->elf.irelplt)
15043     return reloc_class_ifunc;
15044
15045   r_type = ELF64_R_TYPE (rela->r_info);
15046   switch (r_type)
15047     {
15048     case R_PPC64_RELATIVE:
15049       return reloc_class_relative;
15050     case R_PPC64_JMP_SLOT:
15051       return reloc_class_plt;
15052     case R_PPC64_COPY:
15053       return reloc_class_copy;
15054     default:
15055       return reloc_class_normal;
15056     }
15057 }
15058
15059 /* Finish up the dynamic sections.  */
15060
15061 static bfd_boolean
15062 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15063                                    struct bfd_link_info *info)
15064 {
15065   struct ppc_link_hash_table *htab;
15066   bfd *dynobj;
15067   asection *sdyn;
15068
15069   htab = ppc_hash_table (info);
15070   if (htab == NULL)
15071     return FALSE;
15072
15073   dynobj = htab->elf.dynobj;
15074   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15075
15076   if (htab->elf.dynamic_sections_created)
15077     {
15078       Elf64_External_Dyn *dyncon, *dynconend;
15079
15080       if (sdyn == NULL || htab->elf.sgot == NULL)
15081         abort ();
15082
15083       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15084       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15085       for (; dyncon < dynconend; dyncon++)
15086         {
15087           Elf_Internal_Dyn dyn;
15088           asection *s;
15089
15090           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15091
15092           switch (dyn.d_tag)
15093             {
15094             default:
15095               continue;
15096
15097             case DT_PPC64_GLINK:
15098               s = htab->glink;
15099               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15100               /* We stupidly defined DT_PPC64_GLINK to be the start
15101                  of glink rather than the first entry point, which is
15102                  what ld.so needs, and now have a bigger stub to
15103                  support automatic multiple TOCs.  */
15104               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15105               break;
15106
15107             case DT_PPC64_OPD:
15108               s = bfd_get_section_by_name (output_bfd, ".opd");
15109               if (s == NULL)
15110                 continue;
15111               dyn.d_un.d_ptr = s->vma;
15112               break;
15113
15114             case DT_PPC64_OPT:
15115               if (htab->do_multi_toc && htab->multi_toc_needed)
15116                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15117               break;
15118
15119             case DT_PPC64_OPDSZ:
15120               s = bfd_get_section_by_name (output_bfd, ".opd");
15121               if (s == NULL)
15122                 continue;
15123               dyn.d_un.d_val = s->size;
15124               break;
15125
15126             case DT_PLTGOT:
15127               s = htab->elf.splt;
15128               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15129               break;
15130
15131             case DT_JMPREL:
15132               s = htab->elf.srelplt;
15133               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15134               break;
15135
15136             case DT_PLTRELSZ:
15137               dyn.d_un.d_val = htab->elf.srelplt->size;
15138               break;
15139
15140             case DT_RELASZ:
15141               /* Don't count procedure linkage table relocs in the
15142                  overall reloc count.  */
15143               s = htab->elf.srelplt;
15144               if (s == NULL)
15145                 continue;
15146               dyn.d_un.d_val -= s->size;
15147               break;
15148
15149             case DT_RELA:
15150               /* We may not be using the standard ELF linker script.
15151                  If .rela.plt is the first .rela section, we adjust
15152                  DT_RELA to not include it.  */
15153               s = htab->elf.srelplt;
15154               if (s == NULL)
15155                 continue;
15156               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15157                 continue;
15158               dyn.d_un.d_ptr += s->size;
15159               break;
15160             }
15161
15162           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15163         }
15164     }
15165
15166   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15167     {
15168       /* Fill in the first entry in the global offset table.
15169          We use it to hold the link-time TOCbase.  */
15170       bfd_put_64 (output_bfd,
15171                   elf_gp (output_bfd) + TOC_BASE_OFF,
15172                   htab->elf.sgot->contents);
15173
15174       /* Set .got entry size.  */
15175       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15176     }
15177
15178   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15179     {
15180       /* Set .plt entry size.  */
15181       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15182         = PLT_ENTRY_SIZE (htab);
15183     }
15184
15185   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15186      brlt ourselves if emitrelocations.  */
15187   if (htab->brlt != NULL
15188       && htab->brlt->reloc_count != 0
15189       && !_bfd_elf_link_output_relocs (output_bfd,
15190                                        htab->brlt,
15191                                        elf_section_data (htab->brlt)->rela.hdr,
15192                                        elf_section_data (htab->brlt)->relocs,
15193                                        NULL))
15194     return FALSE;
15195
15196   if (htab->glink != NULL
15197       && htab->glink->reloc_count != 0
15198       && !_bfd_elf_link_output_relocs (output_bfd,
15199                                        htab->glink,
15200                                        elf_section_data (htab->glink)->rela.hdr,
15201                                        elf_section_data (htab->glink)->relocs,
15202                                        NULL))
15203     return FALSE;
15204
15205   if (htab->glink_eh_frame != NULL
15206       && htab->glink_eh_frame->size != 0)
15207     {
15208       bfd_vma val;
15209       bfd_byte *p;
15210       asection *stub_sec;
15211
15212       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15213       for (stub_sec = htab->params->stub_bfd->sections;
15214            stub_sec != NULL;
15215            stub_sec = stub_sec->next)
15216         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15217           {
15218             /* FDE length.  */
15219             p += 4;
15220             /* CIE pointer.  */
15221             p += 4;
15222             /* Offset to stub section.  */
15223             val = (stub_sec->output_section->vma
15224                    + stub_sec->output_offset);
15225             val -= (htab->glink_eh_frame->output_section->vma
15226                     + htab->glink_eh_frame->output_offset
15227                     + (p - htab->glink_eh_frame->contents));
15228             if (val + 0x80000000 > 0xffffffff)
15229               {
15230                 info->callbacks->einfo
15231                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15232                    stub_sec->name);
15233                 return FALSE;
15234               }
15235             bfd_put_32 (dynobj, val, p);
15236             p += 4;
15237             /* stub section size.  */
15238             p += 4;
15239             /* Augmentation.  */
15240             p += 1;
15241             /* Pad.  */
15242             p += 7;
15243           }
15244       if (htab->glink != NULL && htab->glink->size != 0)
15245         {
15246           /* FDE length.  */
15247           p += 4;
15248           /* CIE pointer.  */
15249           p += 4;
15250           /* Offset to .glink.  */
15251           val = (htab->glink->output_section->vma
15252                  + htab->glink->output_offset
15253                  + 8);
15254           val -= (htab->glink_eh_frame->output_section->vma
15255                   + htab->glink_eh_frame->output_offset
15256                   + (p - htab->glink_eh_frame->contents));
15257           if (val + 0x80000000 > 0xffffffff)
15258             {
15259               info->callbacks->einfo
15260                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15261                  htab->glink->name);
15262               return FALSE;
15263             }
15264           bfd_put_32 (dynobj, val, p);
15265           p += 4;
15266           /* .glink size.  */
15267           p += 4;
15268           /* Augmentation.  */
15269           p += 1;
15270           /* Ops.  */
15271           p += 7;
15272         }
15273
15274       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15275           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15276                                                htab->glink_eh_frame,
15277                                                htab->glink_eh_frame->contents))
15278         return FALSE;
15279     }
15280
15281   /* We need to handle writing out multiple GOT sections ourselves,
15282      since we didn't add them to DYNOBJ.  We know dynobj is the first
15283      bfd.  */
15284   while ((dynobj = dynobj->link.next) != NULL)
15285     {
15286       asection *s;
15287
15288       if (!is_ppc64_elf (dynobj))
15289         continue;
15290
15291       s = ppc64_elf_tdata (dynobj)->got;
15292       if (s != NULL
15293           && s->size != 0
15294           && s->output_section != bfd_abs_section_ptr
15295           && !bfd_set_section_contents (output_bfd, s->output_section,
15296                                         s->contents, s->output_offset,
15297                                         s->size))
15298         return FALSE;
15299       s = ppc64_elf_tdata (dynobj)->relgot;
15300       if (s != NULL
15301           && s->size != 0
15302           && s->output_section != bfd_abs_section_ptr
15303           && !bfd_set_section_contents (output_bfd, s->output_section,
15304                                         s->contents, s->output_offset,
15305                                         s->size))
15306         return FALSE;
15307     }
15308
15309   return TRUE;
15310 }
15311
15312 #include "elf64-target.h"
15313
15314 /* FreeBSD support */
15315
15316 #undef  TARGET_LITTLE_SYM
15317 #undef  TARGET_LITTLE_NAME
15318
15319 #undef  TARGET_BIG_SYM
15320 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15321 #undef  TARGET_BIG_NAME
15322 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15323
15324 #undef  ELF_OSABI
15325 #define ELF_OSABI       ELFOSABI_FREEBSD
15326
15327 #undef  elf64_bed
15328 #define elf64_bed       elf64_powerpc_fbsd_bed
15329
15330 #include "elf64-target.h"
15331