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