bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   4    Written by Linus Nordberg, Swox AB <info@swox.com>,
   5    based on elf32-ppc.c by Ian Lance Taylor.
   6    Largely rewritten by Alan Modra.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24
  25 /* The 64-bit PowerPC ELF ABI may be found at
  26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  28
  29 #include "sysdep.h"
  30 #include <stdarg.h>
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/ppc64.h"
  36 #include "elf64-ppc.h"
  37 #include "dwarf2.h"
  38
  39 static bfd_reloc_status_type ppc64_elf_ha_reloc
  40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  41 static bfd_reloc_status_type ppc64_elf_branch_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  46   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  48   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  49 static bfd_reloc_status_type ppc64_elf_toc_reloc
  50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  52   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  56   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  57 static bfd_vma opd_entry_value
  58   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  59
  60 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  61 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  62 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  63 #define TARGET_BIG_NAME         "elf64-powerpc"
  64 #define ELF_ARCH                bfd_arch_powerpc
  65 #define ELF_TARGET_ID           PPC64_ELF_DATA
  66 #define ELF_MACHINE_CODE        EM_PPC64
  67 #define ELF_MAXPAGESIZE         0x10000
  68 #define ELF_COMMONPAGESIZE      0x1000
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_default_execstack 0
  80
  81 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  82 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  83 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  84 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  85 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  86 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  87 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  88 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91
  92 #define elf_backend_object_p                  ppc64_elf_object_p
  93 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  94 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  95 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  96 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  97 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  98 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  99 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
 100 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 101 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 102 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 103 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 104 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 105 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 106 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 107 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 108 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 109 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 110 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 111 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 112 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 113 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 114 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 115 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 116 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 117 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 118 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 119 #define elf_backend_special_sections          ppc64_elf_special_sections
 120 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 121
 122 /* The name of the dynamic interpreter.  This is put in the .interp
 123    section.  */
 124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 125
 126 /* The size in bytes of an entry in the procedure linkage table.  */
 127 #define PLT_ENTRY_SIZE 24
 128
 129 /* The initial size of the plt reserved for the dynamic linker.  */
 130 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 131
 132 /* TOC base pointers offset from start of TOC.  */
 133 #define TOC_BASE_OFF    0x8000
 134
 135 /* Offset of tp and dtp pointers from start of TLS block.  */
 136 #define TP_OFFSET       0x7000
 137 #define DTP_OFFSET      0x8000
 138
 139 /* .plt call stub instructions.  The normal stub is like this, but
 140    sometimes the .plt entry crosses a 64k boundary and we need to
 141    insert an addi to adjust r11.  */
 142 #define PLT_CALL_STUB_SIZE (7*4)
 143 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 144 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 145 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 146 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 147 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 148 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 149 #define BCTR            0x4e800420      /* bctr                      */
 150
 151 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 152 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 153 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 154
 155 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 156 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 157 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 158 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 159 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 160 #define BNECTR          0x4ca20420      /* bnectr+               */
 161 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 162
 163 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 164 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 165 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 166
 167 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 168
 169 /* glink call stub instructions.  We enter with the index in R0.  */
 170 #define GLINK_CALL_STUB_SIZE (16*4)
 171                                         /* 0:                           */
 172                                         /*  .quad plt0-1f               */
 173                                         /* __glink:                     */
 174 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 175 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 176                                         /* 1:                           */
 177 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 178                                         /*  ld %2,(0b-1b)(%11)          */
 179 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 180 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 181                                         /*  ld %12,0(%11)               */
 182                                         /*  ld %2,8(%11)                */
 183                                         /*  mtctr %12                   */
 184                                         /*  ld %11,16(%11)              */
 185                                         /*  bctr                        */
 186
 187 /* Pad with this.  */
 188 #define NOP             0x60000000
 189
 190 /* Some other nops.  */
 191 #define CROR_151515     0x4def7b82
 192 #define CROR_313131     0x4ffffb82
 193
 194 /* .glink entries for the first 32k functions are two instructions.  */
 195 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 196 #define B_DOT           0x48000000      /* b     .              */
 197
 198 /* After that, we need two instructions to load the index, followed by
 199    a branch.  */
 200 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 201 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 202
 203 /* Instructions used by the save and restore reg functions.  */
 204 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 205 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 206 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 207 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 208 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 209 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 210 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 211 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 212 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 213 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 214 #define BLR             0x4e800020      /* blr                  */
 215
 216 /* Since .opd is an array of descriptors and each entry will end up
 217    with identical R_PPC64_RELATIVE relocs, there is really no need to
 218    propagate .opd relocs;  The dynamic linker should be taught to
 219    relocate .opd without reloc entries.  */
 220 #ifndef NO_OPD_RELOCS
 221 #define NO_OPD_RELOCS 0
 222 #endif
 223 \f
 224 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 225
 226 /* Relocation HOWTO's.  */
 227 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 228
 229 static reloc_howto_type ppc64_elf_howto_raw[] = {
 230   /* This reloc does nothing.  */
 231   HOWTO (R_PPC64_NONE,          /* type */
 232          0,                     /* rightshift */
 233          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 234          32,                    /* bitsize */
 235          FALSE,                 /* pc_relative */
 236          0,                     /* bitpos */
 237          complain_overflow_dont, /* complain_on_overflow */
 238          bfd_elf_generic_reloc, /* special_function */
 239          "R_PPC64_NONE",        /* name */
 240          FALSE,                 /* partial_inplace */
 241          0,                     /* src_mask */
 242          0,                     /* dst_mask */
 243          FALSE),                /* pcrel_offset */
 244
 245   /* A standard 32 bit relocation.  */
 246   HOWTO (R_PPC64_ADDR32,        /* type */
 247          0,                     /* rightshift */
 248          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 249          32,                    /* bitsize */
 250          FALSE,                 /* pc_relative */
 251          0,                     /* bitpos */
 252          complain_overflow_bitfield, /* complain_on_overflow */
 253          bfd_elf_generic_reloc, /* special_function */
 254          "R_PPC64_ADDR32",      /* name */
 255          FALSE,                 /* partial_inplace */
 256          0,                     /* src_mask */
 257          0xffffffff,            /* dst_mask */
 258          FALSE),                /* pcrel_offset */
 259
 260   /* An absolute 26 bit branch; the lower two bits must be zero.
 261      FIXME: we don't check that, we just clear them.  */
 262   HOWTO (R_PPC64_ADDR24,        /* type */
 263          0,                     /* rightshift */
 264          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          26,                    /* bitsize */
 266          FALSE,                 /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_bitfield, /* complain_on_overflow */
 269          bfd_elf_generic_reloc, /* special_function */
 270          "R_PPC64_ADDR24",      /* name */
 271          FALSE,                 /* partial_inplace */
 272          0,                     /* src_mask */
 273          0x03fffffc,            /* dst_mask */
 274          FALSE),                /* pcrel_offset */
 275
 276   /* A standard 16 bit relocation.  */
 277   HOWTO (R_PPC64_ADDR16,        /* type */
 278          0,                     /* rightshift */
 279          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 280          16,                    /* bitsize */
 281          FALSE,                 /* pc_relative */
 282          0,                     /* bitpos */
 283          complain_overflow_bitfield, /* complain_on_overflow */
 284          bfd_elf_generic_reloc, /* special_function */
 285          "R_PPC64_ADDR16",      /* name */
 286          FALSE,                 /* partial_inplace */
 287          0,                     /* src_mask */
 288          0xffff,                /* dst_mask */
 289          FALSE),                /* pcrel_offset */
 290
 291   /* A 16 bit relocation without overflow.  */
 292   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 293          0,                     /* rightshift */
 294          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          16,                    /* bitsize */
 296          FALSE,                 /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_dont,/* complain_on_overflow */
 299          bfd_elf_generic_reloc, /* special_function */
 300          "R_PPC64_ADDR16_LO",   /* name */
 301          FALSE,                 /* partial_inplace */
 302          0,                     /* src_mask */
 303          0xffff,                /* dst_mask */
 304          FALSE),                /* pcrel_offset */
 305
 306   /* Bits 16-31 of an address.  */
 307   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 308          16,                    /* rightshift */
 309          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          16,                    /* bitsize */
 311          FALSE,                 /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_signed, /* complain_on_overflow */
 314          bfd_elf_generic_reloc, /* special_function */
 315          "R_PPC64_ADDR16_HI",   /* name */
 316          FALSE,                 /* partial_inplace */
 317          0,                     /* src_mask */
 318          0xffff,                /* dst_mask */
 319          FALSE),                /* pcrel_offset */
 320
 321   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 322      bits, treated as a signed number, is negative.  */
 323   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 324          16,                    /* rightshift */
 325          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          16,                    /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_signed, /* complain_on_overflow */
 330          ppc64_elf_ha_reloc,    /* special_function */
 331          "R_PPC64_ADDR16_HA",   /* name */
 332          FALSE,                 /* partial_inplace */
 333          0,                     /* src_mask */
 334          0xffff,                /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* An absolute 16 bit branch; the lower two bits must be zero.
 338      FIXME: we don't check that, we just clear them.  */
 339   HOWTO (R_PPC64_ADDR14,        /* type */
 340          0,                     /* rightshift */
 341          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_bitfield, /* complain_on_overflow */
 346          ppc64_elf_branch_reloc, /* special_function */
 347          "R_PPC64_ADDR14",      /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0x0000fffc,            /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* An absolute 16 bit branch, for which bit 10 should be set to
 354      indicate that the branch is expected to be taken.  The lower two
 355      bits must be zero.  */
 356   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 357          0,                     /* rightshift */
 358          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 359          16,                    /* bitsize */
 360          FALSE,                 /* pc_relative */
 361          0,                     /* bitpos */
 362          complain_overflow_bitfield, /* complain_on_overflow */
 363          ppc64_elf_brtaken_reloc, /* special_function */
 364          "R_PPC64_ADDR14_BRTAKEN",/* name */
 365          FALSE,                 /* partial_inplace */
 366          0,                     /* src_mask */
 367          0x0000fffc,            /* dst_mask */
 368          FALSE),                /* pcrel_offset */
 369
 370   /* An absolute 16 bit branch, for which bit 10 should be set to
 371      indicate that the branch is not expected to be taken.  The lower
 372      two bits must be zero.  */
 373   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 374          0,                     /* rightshift */
 375          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 376          16,                    /* bitsize */
 377          FALSE,                 /* pc_relative */
 378          0,                     /* bitpos */
 379          complain_overflow_bitfield, /* complain_on_overflow */
 380          ppc64_elf_brtaken_reloc, /* special_function */
 381          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 382          FALSE,                 /* partial_inplace */
 383          0,                     /* src_mask */
 384          0x0000fffc,            /* dst_mask */
 385          FALSE),                /* pcrel_offset */
 386
 387   /* A relative 26 bit branch; the lower two bits must be zero.  */
 388   HOWTO (R_PPC64_REL24,         /* type */
 389          0,                     /* rightshift */
 390          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 391          26,                    /* bitsize */
 392          TRUE,                  /* pc_relative */
 393          0,                     /* bitpos */
 394          complain_overflow_signed, /* complain_on_overflow */
 395          ppc64_elf_branch_reloc, /* special_function */
 396          "R_PPC64_REL24",       /* name */
 397          FALSE,                 /* partial_inplace */
 398          0,                     /* src_mask */
 399          0x03fffffc,            /* dst_mask */
 400          TRUE),                 /* pcrel_offset */
 401
 402   /* A relative 16 bit branch; the lower two bits must be zero.  */
 403   HOWTO (R_PPC64_REL14,         /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          16,                    /* bitsize */
 407          TRUE,                  /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_branch_reloc, /* special_function */
 411          "R_PPC64_REL14",       /* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x0000fffc,            /* dst_mask */
 415          TRUE),                 /* pcrel_offset */
 416
 417   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 418      the branch is expected to be taken.  The lower two bits must be
 419      zero.  */
 420   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 421          0,                     /* rightshift */
 422          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 423          16,                    /* bitsize */
 424          TRUE,                  /* pc_relative */
 425          0,                     /* bitpos */
 426          complain_overflow_signed, /* complain_on_overflow */
 427          ppc64_elf_brtaken_reloc, /* special_function */
 428          "R_PPC64_REL14_BRTAKEN", /* name */
 429          FALSE,                 /* partial_inplace */
 430          0,                     /* src_mask */
 431          0x0000fffc,            /* dst_mask */
 432          TRUE),                 /* pcrel_offset */
 433
 434   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 435      the branch is not expected to be taken.  The lower two bits must
 436      be zero.  */
 437   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 438          0,                     /* rightshift */
 439          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 440          16,                    /* bitsize */
 441          TRUE,                  /* pc_relative */
 442          0,                     /* bitpos */
 443          complain_overflow_signed, /* complain_on_overflow */
 444          ppc64_elf_brtaken_reloc, /* special_function */
 445          "R_PPC64_REL14_BRNTAKEN",/* name */
 446          FALSE,                 /* partial_inplace */
 447          0,                     /* src_mask */
 448          0x0000fffc,            /* dst_mask */
 449          TRUE),                 /* pcrel_offset */
 450
 451   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 452      symbol.  */
 453   HOWTO (R_PPC64_GOT16,         /* type */
 454          0,                     /* rightshift */
 455          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          16,                    /* bitsize */
 457          FALSE,                 /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_signed, /* complain_on_overflow */
 460          ppc64_elf_unhandled_reloc, /* special_function */
 461          "R_PPC64_GOT16",       /* name */
 462          FALSE,                 /* partial_inplace */
 463          0,                     /* src_mask */
 464          0xffff,                /* dst_mask */
 465          FALSE),                /* pcrel_offset */
 466
 467   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 468      the symbol.  */
 469   HOWTO (R_PPC64_GOT16_LO,      /* type */
 470          0,                     /* rightshift */
 471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          16,                    /* bitsize */
 473          FALSE,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_dont, /* complain_on_overflow */
 476          ppc64_elf_unhandled_reloc, /* special_function */
 477          "R_PPC64_GOT16_LO",    /* name */
 478          FALSE,                 /* partial_inplace */
 479          0,                     /* src_mask */
 480          0xffff,                /* dst_mask */
 481          FALSE),                /* pcrel_offset */
 482
 483   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 484      the symbol.  */
 485   HOWTO (R_PPC64_GOT16_HI,      /* type */
 486          16,                    /* rightshift */
 487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 488          16,                    /* bitsize */
 489          FALSE,                 /* pc_relative */
 490          0,                     /* bitpos */
 491          complain_overflow_signed,/* complain_on_overflow */
 492          ppc64_elf_unhandled_reloc, /* special_function */
 493          "R_PPC64_GOT16_HI",    /* name */
 494          FALSE,                 /* partial_inplace */
 495          0,                     /* src_mask */
 496          0xffff,                /* dst_mask */
 497          FALSE),                /* pcrel_offset */
 498
 499   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 500      the symbol.  */
 501   HOWTO (R_PPC64_GOT16_HA,      /* type */
 502          16,                    /* rightshift */
 503          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 504          16,                    /* bitsize */
 505          FALSE,                 /* pc_relative */
 506          0,                     /* bitpos */
 507          complain_overflow_signed,/* complain_on_overflow */
 508          ppc64_elf_unhandled_reloc, /* special_function */
 509          "R_PPC64_GOT16_HA",    /* name */
 510          FALSE,                 /* partial_inplace */
 511          0,                     /* src_mask */
 512          0xffff,                /* dst_mask */
 513          FALSE),                /* pcrel_offset */
 514
 515   /* This is used only by the dynamic linker.  The symbol should exist
 516      both in the object being run and in some shared library.  The
 517      dynamic linker copies the data addressed by the symbol from the
 518      shared library into the object, because the object being
 519      run has to have the data at some particular address.  */
 520   HOWTO (R_PPC64_COPY,          /* type */
 521          0,                     /* rightshift */
 522          0,                     /* this one is variable size */
 523          0,                     /* bitsize */
 524          FALSE,                 /* pc_relative */
 525          0,                     /* bitpos */
 526          complain_overflow_dont, /* complain_on_overflow */
 527          ppc64_elf_unhandled_reloc, /* special_function */
 528          "R_PPC64_COPY",        /* name */
 529          FALSE,                 /* partial_inplace */
 530          0,                     /* src_mask */
 531          0,                     /* dst_mask */
 532          FALSE),                /* pcrel_offset */
 533
 534   /* Like R_PPC64_ADDR64, but used when setting global offset table
 535      entries.  */
 536   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 537          0,                     /* rightshift */
 538          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 539          64,                    /* bitsize */
 540          FALSE,                 /* pc_relative */
 541          0,                     /* bitpos */
 542          complain_overflow_dont, /* complain_on_overflow */
 543          ppc64_elf_unhandled_reloc,  /* special_function */
 544          "R_PPC64_GLOB_DAT",    /* name */
 545          FALSE,                 /* partial_inplace */
 546          0,                     /* src_mask */
 547          ONES (64),             /* dst_mask */
 548          FALSE),                /* pcrel_offset */
 549
 550   /* Created by the link editor.  Marks a procedure linkage table
 551      entry for a symbol.  */
 552   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 553          0,                     /* rightshift */
 554          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 555          0,                     /* bitsize */
 556          FALSE,                 /* pc_relative */
 557          0,                     /* bitpos */
 558          complain_overflow_dont, /* complain_on_overflow */
 559          ppc64_elf_unhandled_reloc, /* special_function */
 560          "R_PPC64_JMP_SLOT",    /* name */
 561          FALSE,                 /* partial_inplace */
 562          0,                     /* src_mask */
 563          0,                     /* dst_mask */
 564          FALSE),                /* pcrel_offset */
 565
 566   /* Used only by the dynamic linker.  When the object is run, this
 567      doubleword64 is set to the load address of the object, plus the
 568      addend.  */
 569   HOWTO (R_PPC64_RELATIVE,      /* type */
 570          0,                     /* rightshift */
 571          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 572          64,                    /* bitsize */
 573          FALSE,                 /* pc_relative */
 574          0,                     /* bitpos */
 575          complain_overflow_dont, /* complain_on_overflow */
 576          bfd_elf_generic_reloc, /* special_function */
 577          "R_PPC64_RELATIVE",    /* name */
 578          FALSE,                 /* partial_inplace */
 579          0,                     /* src_mask */
 580          ONES (64),             /* dst_mask */
 581          FALSE),                /* pcrel_offset */
 582
 583   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 584   HOWTO (R_PPC64_UADDR32,       /* type */
 585          0,                     /* rightshift */
 586          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 587          32,                    /* bitsize */
 588          FALSE,                 /* pc_relative */
 589          0,                     /* bitpos */
 590          complain_overflow_bitfield, /* complain_on_overflow */
 591          bfd_elf_generic_reloc, /* special_function */
 592          "R_PPC64_UADDR32",     /* name */
 593          FALSE,                 /* partial_inplace */
 594          0,                     /* src_mask */
 595          0xffffffff,            /* dst_mask */
 596          FALSE),                /* pcrel_offset */
 597
 598   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 599   HOWTO (R_PPC64_UADDR16,       /* type */
 600          0,                     /* rightshift */
 601          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 602          16,                    /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_bitfield, /* complain_on_overflow */
 606          bfd_elf_generic_reloc, /* special_function */
 607          "R_PPC64_UADDR16",     /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          0xffff,                /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* 32-bit PC relative.  */
 614   HOWTO (R_PPC64_REL32,         /* type */
 615          0,                     /* rightshift */
 616          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 617          32,                    /* bitsize */
 618          TRUE,                  /* pc_relative */
 619          0,                     /* bitpos */
 620          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 621          complain_overflow_signed, /* complain_on_overflow */
 622          bfd_elf_generic_reloc, /* special_function */
 623          "R_PPC64_REL32",       /* name */
 624          FALSE,                 /* partial_inplace */
 625          0,                     /* src_mask */
 626          0xffffffff,            /* dst_mask */
 627          TRUE),                 /* pcrel_offset */
 628
 629   /* 32-bit relocation to the symbol's procedure linkage table.  */
 630   HOWTO (R_PPC64_PLT32,         /* type */
 631          0,                     /* rightshift */
 632          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 633          32,                    /* bitsize */
 634          FALSE,                 /* pc_relative */
 635          0,                     /* bitpos */
 636          complain_overflow_bitfield, /* complain_on_overflow */
 637          ppc64_elf_unhandled_reloc, /* special_function */
 638          "R_PPC64_PLT32",       /* name */
 639          FALSE,                 /* partial_inplace */
 640          0,                     /* src_mask */
 641          0xffffffff,            /* dst_mask */
 642          FALSE),                /* pcrel_offset */
 643
 644   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 645      FIXME: R_PPC64_PLTREL32 not supported.  */
 646   HOWTO (R_PPC64_PLTREL32,      /* type */
 647          0,                     /* rightshift */
 648          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 649          32,                    /* bitsize */
 650          TRUE,                  /* pc_relative */
 651          0,                     /* bitpos */
 652          complain_overflow_signed, /* complain_on_overflow */
 653          bfd_elf_generic_reloc, /* special_function */
 654          "R_PPC64_PLTREL32",    /* name */
 655          FALSE,                 /* partial_inplace */
 656          0,                     /* src_mask */
 657          0xffffffff,            /* dst_mask */
 658          TRUE),                 /* pcrel_offset */
 659
 660   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 661      the symbol.  */
 662   HOWTO (R_PPC64_PLT16_LO,      /* type */
 663          0,                     /* rightshift */
 664          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 665          16,                    /* bitsize */
 666          FALSE,                 /* pc_relative */
 667          0,                     /* bitpos */
 668          complain_overflow_dont, /* complain_on_overflow */
 669          ppc64_elf_unhandled_reloc, /* special_function */
 670          "R_PPC64_PLT16_LO",    /* name */
 671          FALSE,                 /* partial_inplace */
 672          0,                     /* src_mask */
 673          0xffff,                /* dst_mask */
 674          FALSE),                /* pcrel_offset */
 675
 676   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 677      the symbol.  */
 678   HOWTO (R_PPC64_PLT16_HI,      /* type */
 679          16,                    /* rightshift */
 680          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 681          16,                    /* bitsize */
 682          FALSE,                 /* pc_relative */
 683          0,                     /* bitpos */
 684          complain_overflow_signed, /* complain_on_overflow */
 685          ppc64_elf_unhandled_reloc, /* special_function */
 686          "R_PPC64_PLT16_HI",    /* name */
 687          FALSE,                 /* partial_inplace */
 688          0,                     /* src_mask */
 689          0xffff,                /* dst_mask */
 690          FALSE),                /* pcrel_offset */
 691
 692   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 693      the symbol.  */
 694   HOWTO (R_PPC64_PLT16_HA,      /* type */
 695          16,                    /* rightshift */
 696          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 697          16,                    /* bitsize */
 698          FALSE,                 /* pc_relative */
 699          0,                     /* bitpos */
 700          complain_overflow_signed, /* complain_on_overflow */
 701          ppc64_elf_unhandled_reloc, /* special_function */
 702          "R_PPC64_PLT16_HA",    /* name */
 703          FALSE,                 /* partial_inplace */
 704          0,                     /* src_mask */
 705          0xffff,                /* dst_mask */
 706          FALSE),                /* pcrel_offset */
 707
 708   /* 16-bit section relative relocation.  */
 709   HOWTO (R_PPC64_SECTOFF,       /* type */
 710          0,                     /* rightshift */
 711          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 712          16,                    /* bitsize */
 713          FALSE,                 /* pc_relative */
 714          0,                     /* bitpos */
 715          complain_overflow_bitfield, /* complain_on_overflow */
 716          ppc64_elf_sectoff_reloc, /* special_function */
 717          "R_PPC64_SECTOFF",     /* name */
 718          FALSE,                 /* partial_inplace */
 719          0,                     /* src_mask */
 720          0xffff,                /* dst_mask */
 721          FALSE),                /* pcrel_offset */
 722
 723   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 724   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 725          0,                     /* rightshift */
 726          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 727          16,                    /* bitsize */
 728          FALSE,                 /* pc_relative */
 729          0,                     /* bitpos */
 730          complain_overflow_dont, /* complain_on_overflow */
 731          ppc64_elf_sectoff_reloc, /* special_function */
 732          "R_PPC64_SECTOFF_LO",  /* name */
 733          FALSE,                 /* partial_inplace */
 734          0,                     /* src_mask */
 735          0xffff,                /* dst_mask */
 736          FALSE),                /* pcrel_offset */
 737
 738   /* 16-bit upper half section relative relocation.  */
 739   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 740          16,                    /* rightshift */
 741          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 742          16,                    /* bitsize */
 743          FALSE,                 /* pc_relative */
 744          0,                     /* bitpos */
 745          complain_overflow_signed, /* complain_on_overflow */
 746          ppc64_elf_sectoff_reloc, /* special_function */
 747          "R_PPC64_SECTOFF_HI",  /* name */
 748          FALSE,                 /* partial_inplace */
 749          0,                     /* src_mask */
 750          0xffff,                /* dst_mask */
 751          FALSE),                /* pcrel_offset */
 752
 753   /* 16-bit upper half adjusted section relative relocation.  */
 754   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 755          16,                    /* rightshift */
 756          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 757          16,                    /* bitsize */
 758          FALSE,                 /* pc_relative */
 759          0,                     /* bitpos */
 760          complain_overflow_signed, /* complain_on_overflow */
 761          ppc64_elf_sectoff_ha_reloc, /* special_function */
 762          "R_PPC64_SECTOFF_HA",  /* name */
 763          FALSE,                 /* partial_inplace */
 764          0,                     /* src_mask */
 765          0xffff,                /* dst_mask */
 766          FALSE),                /* pcrel_offset */
 767
 768   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 769   HOWTO (R_PPC64_REL30,         /* type */
 770          2,                     /* rightshift */
 771          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 772          30,                    /* bitsize */
 773          TRUE,                  /* pc_relative */
 774          0,                     /* bitpos */
 775          complain_overflow_dont, /* complain_on_overflow */
 776          bfd_elf_generic_reloc, /* special_function */
 777          "R_PPC64_REL30",       /* name */
 778          FALSE,                 /* partial_inplace */
 779          0,                     /* src_mask */
 780          0xfffffffc,            /* dst_mask */
 781          TRUE),                 /* pcrel_offset */
 782
 783   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 784
 785   /* A standard 64-bit relocation.  */
 786   HOWTO (R_PPC64_ADDR64,        /* type */
 787          0,                     /* rightshift */
 788          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 789          64,                    /* bitsize */
 790          FALSE,                 /* pc_relative */
 791          0,                     /* bitpos */
 792          complain_overflow_dont, /* complain_on_overflow */
 793          bfd_elf_generic_reloc, /* special_function */
 794          "R_PPC64_ADDR64",      /* name */
 795          FALSE,                 /* partial_inplace */
 796          0,                     /* src_mask */
 797          ONES (64),             /* dst_mask */
 798          FALSE),                /* pcrel_offset */
 799
 800   /* The bits 32-47 of an address.  */
 801   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 802          32,                    /* rightshift */
 803          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 804          16,                    /* bitsize */
 805          FALSE,                 /* pc_relative */
 806          0,                     /* bitpos */
 807          complain_overflow_dont, /* complain_on_overflow */
 808          bfd_elf_generic_reloc, /* special_function */
 809          "R_PPC64_ADDR16_HIGHER", /* name */
 810          FALSE,                 /* partial_inplace */
 811          0,                     /* src_mask */
 812          0xffff,                /* dst_mask */
 813          FALSE),                /* pcrel_offset */
 814
 815   /* The bits 32-47 of an address, plus 1 if the contents of the low
 816      16 bits, treated as a signed number, is negative.  */
 817   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 818          32,                    /* rightshift */
 819          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 820          16,                    /* bitsize */
 821          FALSE,                 /* pc_relative */
 822          0,                     /* bitpos */
 823          complain_overflow_dont, /* complain_on_overflow */
 824          ppc64_elf_ha_reloc,    /* special_function */
 825          "R_PPC64_ADDR16_HIGHERA", /* name */
 826          FALSE,                 /* partial_inplace */
 827          0,                     /* src_mask */
 828          0xffff,                /* dst_mask */
 829          FALSE),                /* pcrel_offset */
 830
 831   /* The bits 48-63 of an address.  */
 832   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 833          48,                    /* rightshift */
 834          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 835          16,                    /* bitsize */
 836          FALSE,                 /* pc_relative */
 837          0,                     /* bitpos */
 838          complain_overflow_dont, /* complain_on_overflow */
 839          bfd_elf_generic_reloc, /* special_function */
 840          "R_PPC64_ADDR16_HIGHEST", /* name */
 841          FALSE,                 /* partial_inplace */
 842          0,                     /* src_mask */
 843          0xffff,                /* dst_mask */
 844          FALSE),                /* pcrel_offset */
 845
 846   /* The bits 48-63 of an address, plus 1 if the contents of the low
 847      16 bits, treated as a signed number, is negative.  */
 848   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 849          48,                    /* rightshift */
 850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 851          16,                    /* bitsize */
 852          FALSE,                 /* pc_relative */
 853          0,                     /* bitpos */
 854          complain_overflow_dont, /* complain_on_overflow */
 855          ppc64_elf_ha_reloc,    /* special_function */
 856          "R_PPC64_ADDR16_HIGHESTA", /* name */
 857          FALSE,                 /* partial_inplace */
 858          0,                     /* src_mask */
 859          0xffff,                /* dst_mask */
 860          FALSE),                /* pcrel_offset */
 861
 862   /* Like ADDR64, but may be unaligned.  */
 863   HOWTO (R_PPC64_UADDR64,       /* type */
 864          0,                     /* rightshift */
 865          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 866          64,                    /* bitsize */
 867          FALSE,                 /* pc_relative */
 868          0,                     /* bitpos */
 869          complain_overflow_dont, /* complain_on_overflow */
 870          bfd_elf_generic_reloc, /* special_function */
 871          "R_PPC64_UADDR64",     /* name */
 872          FALSE,                 /* partial_inplace */
 873          0,                     /* src_mask */
 874          ONES (64),             /* dst_mask */
 875          FALSE),                /* pcrel_offset */
 876
 877   /* 64-bit relative relocation.  */
 878   HOWTO (R_PPC64_REL64,         /* type */
 879          0,                     /* rightshift */
 880          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 881          64,                    /* bitsize */
 882          TRUE,                  /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_dont, /* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* special_function */
 886          "R_PPC64_REL64",       /* name */
 887          FALSE,                 /* partial_inplace */
 888          0,                     /* src_mask */
 889          ONES (64),             /* dst_mask */
 890          TRUE),                 /* pcrel_offset */
 891
 892   /* 64-bit relocation to the symbol's procedure linkage table.  */
 893   HOWTO (R_PPC64_PLT64,         /* type */
 894          0,                     /* rightshift */
 895          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 896          64,                    /* bitsize */
 897          FALSE,                 /* pc_relative */
 898          0,                     /* bitpos */
 899          complain_overflow_dont, /* complain_on_overflow */
 900          ppc64_elf_unhandled_reloc, /* special_function */
 901          "R_PPC64_PLT64",       /* name */
 902          FALSE,                 /* partial_inplace */
 903          0,                     /* src_mask */
 904          ONES (64),             /* dst_mask */
 905          FALSE),                /* pcrel_offset */
 906
 907   /* 64-bit PC relative relocation to the symbol's procedure linkage
 908      table.  */
 909   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 910   HOWTO (R_PPC64_PLTREL64,      /* type */
 911          0,                     /* rightshift */
 912          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 913          64,                    /* bitsize */
 914          TRUE,                  /* pc_relative */
 915          0,                     /* bitpos */
 916          complain_overflow_dont, /* complain_on_overflow */
 917          ppc64_elf_unhandled_reloc, /* special_function */
 918          "R_PPC64_PLTREL64",    /* name */
 919          FALSE,                 /* partial_inplace */
 920          0,                     /* src_mask */
 921          ONES (64),             /* dst_mask */
 922          TRUE),                 /* pcrel_offset */
 923
 924   /* 16 bit TOC-relative relocation.  */
 925
 926   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 927   HOWTO (R_PPC64_TOC16,         /* type */
 928          0,                     /* rightshift */
 929          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 930          16,                    /* bitsize */
 931          FALSE,                 /* pc_relative */
 932          0,                     /* bitpos */
 933          complain_overflow_signed, /* complain_on_overflow */
 934          ppc64_elf_toc_reloc,   /* special_function */
 935          "R_PPC64_TOC16",       /* name */
 936          FALSE,                 /* partial_inplace */
 937          0,                     /* src_mask */
 938          0xffff,                /* dst_mask */
 939          FALSE),                /* pcrel_offset */
 940
 941   /* 16 bit TOC-relative relocation without overflow.  */
 942
 943   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 944   HOWTO (R_PPC64_TOC16_LO,      /* type */
 945          0,                     /* rightshift */
 946          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 947          16,                    /* bitsize */
 948          FALSE,                 /* pc_relative */
 949          0,                     /* bitpos */
 950          complain_overflow_dont, /* complain_on_overflow */
 951          ppc64_elf_toc_reloc,   /* special_function */
 952          "R_PPC64_TOC16_LO",    /* name */
 953          FALSE,                 /* partial_inplace */
 954          0,                     /* src_mask */
 955          0xffff,                /* dst_mask */
 956          FALSE),                /* pcrel_offset */
 957
 958   /* 16 bit TOC-relative relocation, high 16 bits.  */
 959
 960   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 961   HOWTO (R_PPC64_TOC16_HI,      /* type */
 962          16,                    /* rightshift */
 963          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 964          16,                    /* bitsize */
 965          FALSE,                 /* pc_relative */
 966          0,                     /* bitpos */
 967          complain_overflow_signed, /* complain_on_overflow */
 968          ppc64_elf_toc_reloc,   /* special_function */
 969          "R_PPC64_TOC16_HI",    /* name */
 970          FALSE,                 /* partial_inplace */
 971          0,                     /* src_mask */
 972          0xffff,                /* dst_mask */
 973          FALSE),                /* pcrel_offset */
 974
 975   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 976      contents of the low 16 bits, treated as a signed number, is
 977      negative.  */
 978
 979   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 980   HOWTO (R_PPC64_TOC16_HA,      /* type */
 981          16,                    /* rightshift */
 982          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 983          16,                    /* bitsize */
 984          FALSE,                 /* pc_relative */
 985          0,                     /* bitpos */
 986          complain_overflow_signed, /* complain_on_overflow */
 987          ppc64_elf_toc_ha_reloc, /* special_function */
 988          "R_PPC64_TOC16_HA",    /* name */
 989          FALSE,                 /* partial_inplace */
 990          0,                     /* src_mask */
 991          0xffff,                /* dst_mask */
 992          FALSE),                /* pcrel_offset */
 993
 994   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 995
 996   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 997   HOWTO (R_PPC64_TOC,           /* type */
 998          0,                     /* rightshift */
 999          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1000          64,                    /* bitsize */
1001          FALSE,                 /* pc_relative */
1002          0,                     /* bitpos */
1003          complain_overflow_bitfield, /* complain_on_overflow */
1004          ppc64_elf_toc64_reloc, /* special_function */
1005          "R_PPC64_TOC",         /* name */
1006          FALSE,                 /* partial_inplace */
1007          0,                     /* src_mask */
1008          ONES (64),             /* dst_mask */
1009          FALSE),                /* pcrel_offset */
1010
1011   /* Like R_PPC64_GOT16, but also informs the link editor that the
1012      value to relocate may (!) refer to a PLT entry which the link
1013      editor (a) may replace with the symbol value.  If the link editor
1014      is unable to fully resolve the symbol, it may (b) create a PLT
1015      entry and store the address to the new PLT entry in the GOT.
1016      This permits lazy resolution of function symbols at run time.
1017      The link editor may also skip all of this and just (c) emit a
1018      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1019   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1020     HOWTO (R_PPC64_PLTGOT16,    /* type */
1021          0,                     /* rightshift */
1022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1023          16,                    /* bitsize */
1024          FALSE,                 /* pc_relative */
1025          0,                     /* bitpos */
1026          complain_overflow_signed, /* complain_on_overflow */
1027          ppc64_elf_unhandled_reloc, /* special_function */
1028          "R_PPC64_PLTGOT16",    /* name */
1029          FALSE,                 /* partial_inplace */
1030          0,                     /* src_mask */
1031          0xffff,                /* dst_mask */
1032          FALSE),                /* pcrel_offset */
1033
1034   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1035   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1036   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1037          0,                     /* rightshift */
1038          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1039          16,                    /* bitsize */
1040          FALSE,                 /* pc_relative */
1041          0,                     /* bitpos */
1042          complain_overflow_dont, /* complain_on_overflow */
1043          ppc64_elf_unhandled_reloc, /* special_function */
1044          "R_PPC64_PLTGOT16_LO", /* name */
1045          FALSE,                 /* partial_inplace */
1046          0,                     /* src_mask */
1047          0xffff,                /* dst_mask */
1048          FALSE),                /* pcrel_offset */
1049
1050   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1051   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1052   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1053          16,                    /* rightshift */
1054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1055          16,                    /* bitsize */
1056          FALSE,                 /* pc_relative */
1057          0,                     /* bitpos */
1058          complain_overflow_signed, /* complain_on_overflow */
1059          ppc64_elf_unhandled_reloc, /* special_function */
1060          "R_PPC64_PLTGOT16_HI", /* name */
1061          FALSE,                 /* partial_inplace */
1062          0,                     /* src_mask */
1063          0xffff,                /* dst_mask */
1064          FALSE),                /* pcrel_offset */
1065
1066   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1067      1 if the contents of the low 16 bits, treated as a signed number,
1068      is negative.  */
1069   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1070   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1071          16,                    /* rightshift */
1072          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1073          16,                    /* bitsize */
1074          FALSE,                 /* pc_relative */
1075          0,                     /* bitpos */
1076          complain_overflow_signed, /* complain_on_overflow */
1077          ppc64_elf_unhandled_reloc, /* special_function */
1078          "R_PPC64_PLTGOT16_HA", /* name */
1079          FALSE,                 /* partial_inplace */
1080          0,                     /* src_mask */
1081          0xffff,                /* dst_mask */
1082          FALSE),                /* pcrel_offset */
1083
1084   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1085   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1086          0,                     /* rightshift */
1087          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1088          16,                    /* bitsize */
1089          FALSE,                 /* pc_relative */
1090          0,                     /* bitpos */
1091          complain_overflow_bitfield, /* complain_on_overflow */
1092          bfd_elf_generic_reloc, /* special_function */
1093          "R_PPC64_ADDR16_DS",   /* name */
1094          FALSE,                 /* partial_inplace */
1095          0,                     /* src_mask */
1096          0xfffc,                /* dst_mask */
1097          FALSE),                /* pcrel_offset */
1098
1099   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1100   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1101          0,                     /* rightshift */
1102          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1103          16,                    /* bitsize */
1104          FALSE,                 /* pc_relative */
1105          0,                     /* bitpos */
1106          complain_overflow_dont,/* complain_on_overflow */
1107          bfd_elf_generic_reloc, /* special_function */
1108          "R_PPC64_ADDR16_LO_DS",/* name */
1109          FALSE,                 /* partial_inplace */
1110          0,                     /* src_mask */
1111          0xfffc,                /* dst_mask */
1112          FALSE),                /* pcrel_offset */
1113
1114   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1115   HOWTO (R_PPC64_GOT16_DS,      /* type */
1116          0,                     /* rightshift */
1117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1118          16,                    /* bitsize */
1119          FALSE,                 /* pc_relative */
1120          0,                     /* bitpos */
1121          complain_overflow_signed, /* complain_on_overflow */
1122          ppc64_elf_unhandled_reloc, /* special_function */
1123          "R_PPC64_GOT16_DS",    /* name */
1124          FALSE,                 /* partial_inplace */
1125          0,                     /* src_mask */
1126          0xfffc,                /* dst_mask */
1127          FALSE),                /* pcrel_offset */
1128
1129   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1130   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1131          0,                     /* rightshift */
1132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1133          16,                    /* bitsize */
1134          FALSE,                 /* pc_relative */
1135          0,                     /* bitpos */
1136          complain_overflow_dont, /* complain_on_overflow */
1137          ppc64_elf_unhandled_reloc, /* special_function */
1138          "R_PPC64_GOT16_LO_DS", /* name */
1139          FALSE,                 /* partial_inplace */
1140          0,                     /* src_mask */
1141          0xfffc,                /* dst_mask */
1142          FALSE),                /* pcrel_offset */
1143
1144   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1145   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1146          0,                     /* rightshift */
1147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1148          16,                    /* bitsize */
1149          FALSE,                 /* pc_relative */
1150          0,                     /* bitpos */
1151          complain_overflow_dont, /* complain_on_overflow */
1152          ppc64_elf_unhandled_reloc, /* special_function */
1153          "R_PPC64_PLT16_LO_DS", /* name */
1154          FALSE,                 /* partial_inplace */
1155          0,                     /* src_mask */
1156          0xfffc,                /* dst_mask */
1157          FALSE),                /* pcrel_offset */
1158
1159   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1160   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1161          0,                     /* rightshift */
1162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1163          16,                    /* bitsize */
1164          FALSE,                 /* pc_relative */
1165          0,                     /* bitpos */
1166          complain_overflow_bitfield, /* complain_on_overflow */
1167          ppc64_elf_sectoff_reloc, /* special_function */
1168          "R_PPC64_SECTOFF_DS",  /* name */
1169          FALSE,                 /* partial_inplace */
1170          0,                     /* src_mask */
1171          0xfffc,                /* dst_mask */
1172          FALSE),                /* pcrel_offset */
1173
1174   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1175   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1176          0,                     /* rightshift */
1177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1178          16,                    /* bitsize */
1179          FALSE,                 /* pc_relative */
1180          0,                     /* bitpos */
1181          complain_overflow_dont, /* complain_on_overflow */
1182          ppc64_elf_sectoff_reloc, /* special_function */
1183          "R_PPC64_SECTOFF_LO_DS",/* name */
1184          FALSE,                 /* partial_inplace */
1185          0,                     /* src_mask */
1186          0xfffc,                /* dst_mask */
1187          FALSE),                /* pcrel_offset */
1188
1189   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1190   HOWTO (R_PPC64_TOC16_DS,      /* type */
1191          0,                     /* rightshift */
1192          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1193          16,                    /* bitsize */
1194          FALSE,                 /* pc_relative */
1195          0,                     /* bitpos */
1196          complain_overflow_signed, /* complain_on_overflow */
1197          ppc64_elf_toc_reloc,   /* special_function */
1198          "R_PPC64_TOC16_DS",    /* name */
1199          FALSE,                 /* partial_inplace */
1200          0,                     /* src_mask */
1201          0xfffc,                /* dst_mask */
1202          FALSE),                /* pcrel_offset */
1203
1204   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1205   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1206          0,                     /* rightshift */
1207          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1208          16,                    /* bitsize */
1209          FALSE,                 /* pc_relative */
1210          0,                     /* bitpos */
1211          complain_overflow_dont, /* complain_on_overflow */
1212          ppc64_elf_toc_reloc,   /* special_function */
1213          "R_PPC64_TOC16_LO_DS", /* name */
1214          FALSE,                 /* partial_inplace */
1215          0,                     /* src_mask */
1216          0xfffc,                /* dst_mask */
1217          FALSE),                /* pcrel_offset */
1218
1219   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1220   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1221   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1222          0,                     /* rightshift */
1223          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1224          16,                    /* bitsize */
1225          FALSE,                 /* pc_relative */
1226          0,                     /* bitpos */
1227          complain_overflow_signed, /* complain_on_overflow */
1228          ppc64_elf_unhandled_reloc, /* special_function */
1229          "R_PPC64_PLTGOT16_DS", /* name */
1230          FALSE,                 /* partial_inplace */
1231          0,                     /* src_mask */
1232          0xfffc,                /* dst_mask */
1233          FALSE),                /* pcrel_offset */
1234
1235   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1236   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1237   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1238          0,                     /* rightshift */
1239          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1240          16,                    /* bitsize */
1241          FALSE,                 /* pc_relative */
1242          0,                     /* bitpos */
1243          complain_overflow_dont, /* complain_on_overflow */
1244          ppc64_elf_unhandled_reloc, /* special_function */
1245          "R_PPC64_PLTGOT16_LO_DS",/* name */
1246          FALSE,                 /* partial_inplace */
1247          0,                     /* src_mask */
1248          0xfffc,                /* dst_mask */
1249          FALSE),                /* pcrel_offset */
1250
1251   /* Marker relocs for TLS.  */
1252   HOWTO (R_PPC64_TLS,
1253          0,                     /* rightshift */
1254          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1255          32,                    /* bitsize */
1256          FALSE,                 /* pc_relative */
1257          0,                     /* bitpos */
1258          complain_overflow_dont, /* complain_on_overflow */
1259          bfd_elf_generic_reloc, /* special_function */
1260          "R_PPC64_TLS",         /* name */
1261          FALSE,                 /* partial_inplace */
1262          0,                     /* src_mask */
1263          0,                     /* dst_mask */
1264          FALSE),                /* pcrel_offset */
1265
1266   HOWTO (R_PPC64_TLSGD,
1267          0,                     /* rightshift */
1268          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1269          32,                    /* bitsize */
1270          FALSE,                 /* pc_relative */
1271          0,                     /* bitpos */
1272          complain_overflow_dont, /* complain_on_overflow */
1273          bfd_elf_generic_reloc, /* special_function */
1274          "R_PPC64_TLSGD",       /* name */
1275          FALSE,                 /* partial_inplace */
1276          0,                     /* src_mask */
1277          0,                     /* dst_mask */
1278          FALSE),                /* pcrel_offset */
1279
1280   HOWTO (R_PPC64_TLSLD,
1281          0,                     /* rightshift */
1282          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1283          32,                    /* bitsize */
1284          FALSE,                 /* pc_relative */
1285          0,                     /* bitpos */
1286          complain_overflow_dont, /* complain_on_overflow */
1287          bfd_elf_generic_reloc, /* special_function */
1288          "R_PPC64_TLSLD",       /* name */
1289          FALSE,                 /* partial_inplace */
1290          0,                     /* src_mask */
1291          0,                     /* dst_mask */
1292          FALSE),                /* pcrel_offset */
1293
1294   HOWTO (R_PPC64_TOCSAVE,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TOCSAVE",     /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   /* Computes the load module index of the load module that contains the
1309      definition of its TLS sym.  */
1310   HOWTO (R_PPC64_DTPMOD64,
1311          0,                     /* rightshift */
1312          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1313          64,                    /* bitsize */
1314          FALSE,                 /* pc_relative */
1315          0,                     /* bitpos */
1316          complain_overflow_dont, /* complain_on_overflow */
1317          ppc64_elf_unhandled_reloc, /* special_function */
1318          "R_PPC64_DTPMOD64",    /* name */
1319          FALSE,                 /* partial_inplace */
1320          0,                     /* src_mask */
1321          ONES (64),             /* dst_mask */
1322          FALSE),                /* pcrel_offset */
1323
1324   /* Computes a dtv-relative displacement, the difference between the value
1325      of sym+add and the base address of the thread-local storage block that
1326      contains the definition of sym, minus 0x8000.  */
1327   HOWTO (R_PPC64_DTPREL64,
1328          0,                     /* rightshift */
1329          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1330          64,                    /* bitsize */
1331          FALSE,                 /* pc_relative */
1332          0,                     /* bitpos */
1333          complain_overflow_dont, /* complain_on_overflow */
1334          ppc64_elf_unhandled_reloc, /* special_function */
1335          "R_PPC64_DTPREL64",    /* name */
1336          FALSE,                 /* partial_inplace */
1337          0,                     /* src_mask */
1338          ONES (64),             /* dst_mask */
1339          FALSE),                /* pcrel_offset */
1340
1341   /* A 16 bit dtprel reloc.  */
1342   HOWTO (R_PPC64_DTPREL16,
1343          0,                     /* rightshift */
1344          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1345          16,                    /* bitsize */
1346          FALSE,                 /* pc_relative */
1347          0,                     /* bitpos */
1348          complain_overflow_signed, /* complain_on_overflow */
1349          ppc64_elf_unhandled_reloc, /* special_function */
1350          "R_PPC64_DTPREL16",    /* name */
1351          FALSE,                 /* partial_inplace */
1352          0,                     /* src_mask */
1353          0xffff,                /* dst_mask */
1354          FALSE),                /* pcrel_offset */
1355
1356   /* Like DTPREL16, but no overflow.  */
1357   HOWTO (R_PPC64_DTPREL16_LO,
1358          0,                     /* rightshift */
1359          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1360          16,                    /* bitsize */
1361          FALSE,                 /* pc_relative */
1362          0,                     /* bitpos */
1363          complain_overflow_dont, /* complain_on_overflow */
1364          ppc64_elf_unhandled_reloc, /* special_function */
1365          "R_PPC64_DTPREL16_LO", /* name */
1366          FALSE,                 /* partial_inplace */
1367          0,                     /* src_mask */
1368          0xffff,                /* dst_mask */
1369          FALSE),                /* pcrel_offset */
1370
1371   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1372   HOWTO (R_PPC64_DTPREL16_HI,
1373          16,                    /* rightshift */
1374          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1375          16,                    /* bitsize */
1376          FALSE,                 /* pc_relative */
1377          0,                     /* bitpos */
1378          complain_overflow_signed, /* complain_on_overflow */
1379          ppc64_elf_unhandled_reloc, /* special_function */
1380          "R_PPC64_DTPREL16_HI", /* name */
1381          FALSE,                 /* partial_inplace */
1382          0,                     /* src_mask */
1383          0xffff,                /* dst_mask */
1384          FALSE),                /* pcrel_offset */
1385
1386   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1387   HOWTO (R_PPC64_DTPREL16_HA,
1388          16,                    /* rightshift */
1389          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          16,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_signed, /* complain_on_overflow */
1394          ppc64_elf_unhandled_reloc, /* special_function */
1395          "R_PPC64_DTPREL16_HA", /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          0xffff,                /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1402   HOWTO (R_PPC64_DTPREL16_HIGHER,
1403          32,                    /* rightshift */
1404          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1405          16,                    /* bitsize */
1406          FALSE,                 /* pc_relative */
1407          0,                     /* bitpos */
1408          complain_overflow_dont, /* complain_on_overflow */
1409          ppc64_elf_unhandled_reloc, /* special_function */
1410          "R_PPC64_DTPREL16_HIGHER", /* name */
1411          FALSE,                 /* partial_inplace */
1412          0,                     /* src_mask */
1413          0xffff,                /* dst_mask */
1414          FALSE),                /* pcrel_offset */
1415
1416   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1417   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1418          32,                    /* rightshift */
1419          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1420          16,                    /* bitsize */
1421          FALSE,                 /* pc_relative */
1422          0,                     /* bitpos */
1423          complain_overflow_dont, /* complain_on_overflow */
1424          ppc64_elf_unhandled_reloc, /* special_function */
1425          "R_PPC64_DTPREL16_HIGHERA", /* name */
1426          FALSE,                 /* partial_inplace */
1427          0,                     /* src_mask */
1428          0xffff,                /* dst_mask */
1429          FALSE),                /* pcrel_offset */
1430
1431   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1432   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1433          48,                    /* rightshift */
1434          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1435          16,                    /* bitsize */
1436          FALSE,                 /* pc_relative */
1437          0,                     /* bitpos */
1438          complain_overflow_dont, /* complain_on_overflow */
1439          ppc64_elf_unhandled_reloc, /* special_function */
1440          "R_PPC64_DTPREL16_HIGHEST", /* name */
1441          FALSE,                 /* partial_inplace */
1442          0,                     /* src_mask */
1443          0xffff,                /* dst_mask */
1444          FALSE),                /* pcrel_offset */
1445
1446   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1447   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1448          48,                    /* rightshift */
1449          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1450          16,                    /* bitsize */
1451          FALSE,                 /* pc_relative */
1452          0,                     /* bitpos */
1453          complain_overflow_dont, /* complain_on_overflow */
1454          ppc64_elf_unhandled_reloc, /* special_function */
1455          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1456          FALSE,                 /* partial_inplace */
1457          0,                     /* src_mask */
1458          0xffff,                /* dst_mask */
1459          FALSE),                /* pcrel_offset */
1460
1461   /* Like DTPREL16, but for insns with a DS field.  */
1462   HOWTO (R_PPC64_DTPREL16_DS,
1463          0,                     /* rightshift */
1464          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1465          16,                    /* bitsize */
1466          FALSE,                 /* pc_relative */
1467          0,                     /* bitpos */
1468          complain_overflow_signed, /* complain_on_overflow */
1469          ppc64_elf_unhandled_reloc, /* special_function */
1470          "R_PPC64_DTPREL16_DS", /* name */
1471          FALSE,                 /* partial_inplace */
1472          0,                     /* src_mask */
1473          0xfffc,                /* dst_mask */
1474          FALSE),                /* pcrel_offset */
1475
1476   /* Like DTPREL16_DS, but no overflow.  */
1477   HOWTO (R_PPC64_DTPREL16_LO_DS,
1478          0,                     /* rightshift */
1479          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1480          16,                    /* bitsize */
1481          FALSE,                 /* pc_relative */
1482          0,                     /* bitpos */
1483          complain_overflow_dont, /* complain_on_overflow */
1484          ppc64_elf_unhandled_reloc, /* special_function */
1485          "R_PPC64_DTPREL16_LO_DS", /* name */
1486          FALSE,                 /* partial_inplace */
1487          0,                     /* src_mask */
1488          0xfffc,                /* dst_mask */
1489          FALSE),                /* pcrel_offset */
1490
1491   /* Computes a tp-relative displacement, the difference between the value of
1492      sym+add and the value of the thread pointer (r13).  */
1493   HOWTO (R_PPC64_TPREL64,
1494          0,                     /* rightshift */
1495          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1496          64,                    /* bitsize */
1497          FALSE,                 /* pc_relative */
1498          0,                     /* bitpos */
1499          complain_overflow_dont, /* complain_on_overflow */
1500          ppc64_elf_unhandled_reloc, /* special_function */
1501          "R_PPC64_TPREL64",     /* name */
1502          FALSE,                 /* partial_inplace */
1503          0,                     /* src_mask */
1504          ONES (64),             /* dst_mask */
1505          FALSE),                /* pcrel_offset */
1506
1507   /* A 16 bit tprel reloc.  */
1508   HOWTO (R_PPC64_TPREL16,
1509          0,                     /* rightshift */
1510          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1511          16,                    /* bitsize */
1512          FALSE,                 /* pc_relative */
1513          0,                     /* bitpos */
1514          complain_overflow_signed, /* complain_on_overflow */
1515          ppc64_elf_unhandled_reloc, /* special_function */
1516          "R_PPC64_TPREL16",     /* name */
1517          FALSE,                 /* partial_inplace */
1518          0,                     /* src_mask */
1519          0xffff,                /* dst_mask */
1520          FALSE),                /* pcrel_offset */
1521
1522   /* Like TPREL16, but no overflow.  */
1523   HOWTO (R_PPC64_TPREL16_LO,
1524          0,                     /* rightshift */
1525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1526          16,                    /* bitsize */
1527          FALSE,                 /* pc_relative */
1528          0,                     /* bitpos */
1529          complain_overflow_dont, /* complain_on_overflow */
1530          ppc64_elf_unhandled_reloc, /* special_function */
1531          "R_PPC64_TPREL16_LO",  /* name */
1532          FALSE,                 /* partial_inplace */
1533          0,                     /* src_mask */
1534          0xffff,                /* dst_mask */
1535          FALSE),                /* pcrel_offset */
1536
1537   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1538   HOWTO (R_PPC64_TPREL16_HI,
1539          16,                    /* rightshift */
1540          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1541          16,                    /* bitsize */
1542          FALSE,                 /* pc_relative */
1543          0,                     /* bitpos */
1544          complain_overflow_signed, /* complain_on_overflow */
1545          ppc64_elf_unhandled_reloc, /* special_function */
1546          "R_PPC64_TPREL16_HI",  /* name */
1547          FALSE,                 /* partial_inplace */
1548          0,                     /* src_mask */
1549          0xffff,                /* dst_mask */
1550          FALSE),                /* pcrel_offset */
1551
1552   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1553   HOWTO (R_PPC64_TPREL16_HA,
1554          16,                    /* rightshift */
1555          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1556          16,                    /* bitsize */
1557          FALSE,                 /* pc_relative */
1558          0,                     /* bitpos */
1559          complain_overflow_signed, /* complain_on_overflow */
1560          ppc64_elf_unhandled_reloc, /* special_function */
1561          "R_PPC64_TPREL16_HA",  /* name */
1562          FALSE,                 /* partial_inplace */
1563          0,                     /* src_mask */
1564          0xffff,                /* dst_mask */
1565          FALSE),                /* pcrel_offset */
1566
1567   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1568   HOWTO (R_PPC64_TPREL16_HIGHER,
1569          32,                    /* rightshift */
1570          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1571          16,                    /* bitsize */
1572          FALSE,                 /* pc_relative */
1573          0,                     /* bitpos */
1574          complain_overflow_dont, /* complain_on_overflow */
1575          ppc64_elf_unhandled_reloc, /* special_function */
1576          "R_PPC64_TPREL16_HIGHER",      /* name */
1577          FALSE,                 /* partial_inplace */
1578          0,                     /* src_mask */
1579          0xffff,                /* dst_mask */
1580          FALSE),                /* pcrel_offset */
1581
1582   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1583   HOWTO (R_PPC64_TPREL16_HIGHERA,
1584          32,                    /* rightshift */
1585          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1586          16,                    /* bitsize */
1587          FALSE,                 /* pc_relative */
1588          0,                     /* bitpos */
1589          complain_overflow_dont, /* complain_on_overflow */
1590          ppc64_elf_unhandled_reloc, /* special_function */
1591          "R_PPC64_TPREL16_HIGHERA", /* name */
1592          FALSE,                 /* partial_inplace */
1593          0,                     /* src_mask */
1594          0xffff,                /* dst_mask */
1595          FALSE),                /* pcrel_offset */
1596
1597   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1598   HOWTO (R_PPC64_TPREL16_HIGHEST,
1599          48,                    /* rightshift */
1600          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1601          16,                    /* bitsize */
1602          FALSE,                 /* pc_relative */
1603          0,                     /* bitpos */
1604          complain_overflow_dont, /* complain_on_overflow */
1605          ppc64_elf_unhandled_reloc, /* special_function */
1606          "R_PPC64_TPREL16_HIGHEST", /* name */
1607          FALSE,                 /* partial_inplace */
1608          0,                     /* src_mask */
1609          0xffff,                /* dst_mask */
1610          FALSE),                /* pcrel_offset */
1611
1612   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1613   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1614          48,                    /* rightshift */
1615          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1616          16,                    /* bitsize */
1617          FALSE,                 /* pc_relative */
1618          0,                     /* bitpos */
1619          complain_overflow_dont, /* complain_on_overflow */
1620          ppc64_elf_unhandled_reloc, /* special_function */
1621          "R_PPC64_TPREL16_HIGHESTA", /* name */
1622          FALSE,                 /* partial_inplace */
1623          0,                     /* src_mask */
1624          0xffff,                /* dst_mask */
1625          FALSE),                /* pcrel_offset */
1626
1627   /* Like TPREL16, but for insns with a DS field.  */
1628   HOWTO (R_PPC64_TPREL16_DS,
1629          0,                     /* rightshift */
1630          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1631          16,                    /* bitsize */
1632          FALSE,                 /* pc_relative */
1633          0,                     /* bitpos */
1634          complain_overflow_signed, /* complain_on_overflow */
1635          ppc64_elf_unhandled_reloc, /* special_function */
1636          "R_PPC64_TPREL16_DS",  /* name */
1637          FALSE,                 /* partial_inplace */
1638          0,                     /* src_mask */
1639          0xfffc,                /* dst_mask */
1640          FALSE),                /* pcrel_offset */
1641
1642   /* Like TPREL16_DS, but no overflow.  */
1643   HOWTO (R_PPC64_TPREL16_LO_DS,
1644          0,                     /* rightshift */
1645          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1646          16,                    /* bitsize */
1647          FALSE,                 /* pc_relative */
1648          0,                     /* bitpos */
1649          complain_overflow_dont, /* complain_on_overflow */
1650          ppc64_elf_unhandled_reloc, /* special_function */
1651          "R_PPC64_TPREL16_LO_DS", /* name */
1652          FALSE,                 /* partial_inplace */
1653          0,                     /* src_mask */
1654          0xfffc,                /* dst_mask */
1655          FALSE),                /* pcrel_offset */
1656
1657   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1658      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1659      to the first entry relative to the TOC base (r2).  */
1660   HOWTO (R_PPC64_GOT_TLSGD16,
1661          0,                     /* rightshift */
1662          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1663          16,                    /* bitsize */
1664          FALSE,                 /* pc_relative */
1665          0,                     /* bitpos */
1666          complain_overflow_signed, /* complain_on_overflow */
1667          ppc64_elf_unhandled_reloc, /* special_function */
1668          "R_PPC64_GOT_TLSGD16", /* name */
1669          FALSE,                 /* partial_inplace */
1670          0,                     /* src_mask */
1671          0xffff,                /* dst_mask */
1672          FALSE),                /* pcrel_offset */
1673
1674   /* Like GOT_TLSGD16, but no overflow.  */
1675   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1676          0,                     /* rightshift */
1677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1678          16,                    /* bitsize */
1679          FALSE,                 /* pc_relative */
1680          0,                     /* bitpos */
1681          complain_overflow_dont, /* complain_on_overflow */
1682          ppc64_elf_unhandled_reloc, /* special_function */
1683          "R_PPC64_GOT_TLSGD16_LO", /* name */
1684          FALSE,                 /* partial_inplace */
1685          0,                     /* src_mask */
1686          0xffff,                /* dst_mask */
1687          FALSE),                /* pcrel_offset */
1688
1689   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1690   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1691          16,                    /* rightshift */
1692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1693          16,                    /* bitsize */
1694          FALSE,                 /* pc_relative */
1695          0,                     /* bitpos */
1696          complain_overflow_signed, /* complain_on_overflow */
1697          ppc64_elf_unhandled_reloc, /* special_function */
1698          "R_PPC64_GOT_TLSGD16_HI", /* name */
1699          FALSE,                 /* partial_inplace */
1700          0,                     /* src_mask */
1701          0xffff,                /* dst_mask */
1702          FALSE),                /* pcrel_offset */
1703
1704   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1705   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1706          16,                    /* rightshift */
1707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1708          16,                    /* bitsize */
1709          FALSE,                 /* pc_relative */
1710          0,                     /* bitpos */
1711          complain_overflow_signed, /* complain_on_overflow */
1712          ppc64_elf_unhandled_reloc, /* special_function */
1713          "R_PPC64_GOT_TLSGD16_HA", /* name */
1714          FALSE,                 /* partial_inplace */
1715          0,                     /* src_mask */
1716          0xffff,                /* dst_mask */
1717          FALSE),                /* pcrel_offset */
1718
1719   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1720      with values (sym+add)@dtpmod and zero, and computes the offset to the
1721      first entry relative to the TOC base (r2).  */
1722   HOWTO (R_PPC64_GOT_TLSLD16,
1723          0,                     /* rightshift */
1724          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1725          16,                    /* bitsize */
1726          FALSE,                 /* pc_relative */
1727          0,                     /* bitpos */
1728          complain_overflow_signed, /* complain_on_overflow */
1729          ppc64_elf_unhandled_reloc, /* special_function */
1730          "R_PPC64_GOT_TLSLD16", /* name */
1731          FALSE,                 /* partial_inplace */
1732          0,                     /* src_mask */
1733          0xffff,                /* dst_mask */
1734          FALSE),                /* pcrel_offset */
1735
1736   /* Like GOT_TLSLD16, but no overflow.  */
1737   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1738          0,                     /* rightshift */
1739          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1740          16,                    /* bitsize */
1741          FALSE,                 /* pc_relative */
1742          0,                     /* bitpos */
1743          complain_overflow_dont, /* complain_on_overflow */
1744          ppc64_elf_unhandled_reloc, /* special_function */
1745          "R_PPC64_GOT_TLSLD16_LO", /* name */
1746          FALSE,                 /* partial_inplace */
1747          0,                     /* src_mask */
1748          0xffff,                /* dst_mask */
1749          FALSE),                /* pcrel_offset */
1750
1751   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1752   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1753          16,                    /* rightshift */
1754          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1755          16,                    /* bitsize */
1756          FALSE,                 /* pc_relative */
1757          0,                     /* bitpos */
1758          complain_overflow_signed, /* complain_on_overflow */
1759          ppc64_elf_unhandled_reloc, /* special_function */
1760          "R_PPC64_GOT_TLSLD16_HI", /* name */
1761          FALSE,                 /* partial_inplace */
1762          0,                     /* src_mask */
1763          0xffff,                /* dst_mask */
1764          FALSE),                /* pcrel_offset */
1765
1766   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1767   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1768          16,                    /* rightshift */
1769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          16,                    /* bitsize */
1771          FALSE,                 /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_signed, /* complain_on_overflow */
1774          ppc64_elf_unhandled_reloc, /* special_function */
1775          "R_PPC64_GOT_TLSLD16_HA", /* name */
1776          FALSE,                 /* partial_inplace */
1777          0,                     /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1782      the offset to the entry relative to the TOC base (r2).  */
1783   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1784          0,                     /* rightshift */
1785          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1786          16,                    /* bitsize */
1787          FALSE,                 /* pc_relative */
1788          0,                     /* bitpos */
1789          complain_overflow_signed, /* complain_on_overflow */
1790          ppc64_elf_unhandled_reloc, /* special_function */
1791          "R_PPC64_GOT_DTPREL16_DS", /* name */
1792          FALSE,                 /* partial_inplace */
1793          0,                     /* src_mask */
1794          0xfffc,                /* dst_mask */
1795          FALSE),                /* pcrel_offset */
1796
1797   /* Like GOT_DTPREL16_DS, but no overflow.  */
1798   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1799          0,                     /* rightshift */
1800          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1801          16,                    /* bitsize */
1802          FALSE,                 /* pc_relative */
1803          0,                     /* bitpos */
1804          complain_overflow_dont, /* complain_on_overflow */
1805          ppc64_elf_unhandled_reloc, /* special_function */
1806          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1807          FALSE,                 /* partial_inplace */
1808          0,                     /* src_mask */
1809          0xfffc,                /* dst_mask */
1810          FALSE),                /* pcrel_offset */
1811
1812   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1813   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1814          16,                    /* rightshift */
1815          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1816          16,                    /* bitsize */
1817          FALSE,                 /* pc_relative */
1818          0,                     /* bitpos */
1819          complain_overflow_signed, /* complain_on_overflow */
1820          ppc64_elf_unhandled_reloc, /* special_function */
1821          "R_PPC64_GOT_DTPREL16_HI", /* name */
1822          FALSE,                 /* partial_inplace */
1823          0,                     /* src_mask */
1824          0xffff,                /* dst_mask */
1825          FALSE),                /* pcrel_offset */
1826
1827   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1828   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1829          16,                    /* rightshift */
1830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1831          16,                    /* bitsize */
1832          FALSE,                 /* pc_relative */
1833          0,                     /* bitpos */
1834          complain_overflow_signed, /* complain_on_overflow */
1835          ppc64_elf_unhandled_reloc, /* special_function */
1836          "R_PPC64_GOT_DTPREL16_HA", /* name */
1837          FALSE,                 /* partial_inplace */
1838          0,                     /* src_mask */
1839          0xffff,                /* dst_mask */
1840          FALSE),                /* pcrel_offset */
1841
1842   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1843      offset to the entry relative to the TOC base (r2).  */
1844   HOWTO (R_PPC64_GOT_TPREL16_DS,
1845          0,                     /* rightshift */
1846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1847          16,                    /* bitsize */
1848          FALSE,                 /* pc_relative */
1849          0,                     /* bitpos */
1850          complain_overflow_signed, /* complain_on_overflow */
1851          ppc64_elf_unhandled_reloc, /* special_function */
1852          "R_PPC64_GOT_TPREL16_DS", /* name */
1853          FALSE,                 /* partial_inplace */
1854          0,                     /* src_mask */
1855          0xfffc,                /* dst_mask */
1856          FALSE),                /* pcrel_offset */
1857
1858   /* Like GOT_TPREL16_DS, but no overflow.  */
1859   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1860          0,                     /* rightshift */
1861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1862          16,                    /* bitsize */
1863          FALSE,                 /* pc_relative */
1864          0,                     /* bitpos */
1865          complain_overflow_dont, /* complain_on_overflow */
1866          ppc64_elf_unhandled_reloc, /* special_function */
1867          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1868          FALSE,                 /* partial_inplace */
1869          0,                     /* src_mask */
1870          0xfffc,                /* dst_mask */
1871          FALSE),                /* pcrel_offset */
1872
1873   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1874   HOWTO (R_PPC64_GOT_TPREL16_HI,
1875          16,                    /* rightshift */
1876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1877          16,                    /* bitsize */
1878          FALSE,                 /* pc_relative */
1879          0,                     /* bitpos */
1880          complain_overflow_signed, /* complain_on_overflow */
1881          ppc64_elf_unhandled_reloc, /* special_function */
1882          "R_PPC64_GOT_TPREL16_HI", /* name */
1883          FALSE,                 /* partial_inplace */
1884          0,                     /* src_mask */
1885          0xffff,                /* dst_mask */
1886          FALSE),                /* pcrel_offset */
1887
1888   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1889   HOWTO (R_PPC64_GOT_TPREL16_HA,
1890          16,                    /* rightshift */
1891          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1892          16,                    /* bitsize */
1893          FALSE,                 /* pc_relative */
1894          0,                     /* bitpos */
1895          complain_overflow_signed, /* complain_on_overflow */
1896          ppc64_elf_unhandled_reloc, /* special_function */
1897          "R_PPC64_GOT_TPREL16_HA", /* name */
1898          FALSE,                 /* partial_inplace */
1899          0,                     /* src_mask */
1900          0xffff,                /* dst_mask */
1901          FALSE),                /* pcrel_offset */
1902
1903   HOWTO (R_PPC64_JMP_IREL,      /* type */
1904          0,                     /* rightshift */
1905          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1906          0,                     /* bitsize */
1907          FALSE,                 /* pc_relative */
1908          0,                     /* bitpos */
1909          complain_overflow_dont, /* complain_on_overflow */
1910          ppc64_elf_unhandled_reloc, /* special_function */
1911          "R_PPC64_JMP_IREL",    /* name */
1912          FALSE,                 /* partial_inplace */
1913          0,                     /* src_mask */
1914          0,                     /* dst_mask */
1915          FALSE),                /* pcrel_offset */
1916
1917   HOWTO (R_PPC64_IRELATIVE,     /* type */
1918          0,                     /* rightshift */
1919          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1920          64,                    /* bitsize */
1921          FALSE,                 /* pc_relative */
1922          0,                     /* bitpos */
1923          complain_overflow_dont, /* complain_on_overflow */
1924          bfd_elf_generic_reloc, /* special_function */
1925          "R_PPC64_IRELATIVE",   /* name */
1926          FALSE,                 /* partial_inplace */
1927          0,                     /* src_mask */
1928          ONES (64),             /* dst_mask */
1929          FALSE),                /* pcrel_offset */
1930
1931   /* A 16 bit relative relocation.  */
1932   HOWTO (R_PPC64_REL16,         /* type */
1933          0,                     /* rightshift */
1934          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1935          16,                    /* bitsize */
1936          TRUE,                  /* pc_relative */
1937          0,                     /* bitpos */
1938          complain_overflow_bitfield, /* complain_on_overflow */
1939          bfd_elf_generic_reloc, /* special_function */
1940          "R_PPC64_REL16",       /* name */
1941          FALSE,                 /* partial_inplace */
1942          0,                     /* src_mask */
1943          0xffff,                /* dst_mask */
1944          TRUE),                 /* pcrel_offset */
1945
1946   /* A 16 bit relative relocation without overflow.  */
1947   HOWTO (R_PPC64_REL16_LO,      /* type */
1948          0,                     /* rightshift */
1949          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1950          16,                    /* bitsize */
1951          TRUE,                  /* pc_relative */
1952          0,                     /* bitpos */
1953          complain_overflow_dont,/* complain_on_overflow */
1954          bfd_elf_generic_reloc, /* special_function */
1955          "R_PPC64_REL16_LO",    /* name */
1956          FALSE,                 /* partial_inplace */
1957          0,                     /* src_mask */
1958          0xffff,                /* dst_mask */
1959          TRUE),                 /* pcrel_offset */
1960
1961   /* The high order 16 bits of a relative address.  */
1962   HOWTO (R_PPC64_REL16_HI,      /* type */
1963          16,                    /* rightshift */
1964          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1965          16,                    /* bitsize */
1966          TRUE,                  /* pc_relative */
1967          0,                     /* bitpos */
1968          complain_overflow_signed, /* complain_on_overflow */
1969          bfd_elf_generic_reloc, /* special_function */
1970          "R_PPC64_REL16_HI",    /* name */
1971          FALSE,                 /* partial_inplace */
1972          0,                     /* src_mask */
1973          0xffff,                /* dst_mask */
1974          TRUE),                 /* pcrel_offset */
1975
1976   /* The high order 16 bits of a relative address, plus 1 if the contents of
1977      the low 16 bits, treated as a signed number, is negative.  */
1978   HOWTO (R_PPC64_REL16_HA,      /* type */
1979          16,                    /* rightshift */
1980          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1981          16,                    /* bitsize */
1982          TRUE,                  /* pc_relative */
1983          0,                     /* bitpos */
1984          complain_overflow_signed, /* complain_on_overflow */
1985          ppc64_elf_ha_reloc,    /* special_function */
1986          "R_PPC64_REL16_HA",    /* name */
1987          FALSE,                 /* partial_inplace */
1988          0,                     /* src_mask */
1989          0xffff,                /* dst_mask */
1990          TRUE),                 /* pcrel_offset */
1991
1992   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
1993   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
1994          16,                    /* rightshift */
1995          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1996          16,                    /* bitsize */
1997          FALSE,                 /* pc_relative */
1998          0,                     /* bitpos */
1999          complain_overflow_dont, /* complain_on_overflow */
2000          bfd_elf_generic_reloc, /* special_function */
2001          "R_PPC64_ADDR16_HIGH", /* name */
2002          FALSE,                 /* partial_inplace */
2003          0,                     /* src_mask */
2004          0xffff,                /* dst_mask */
2005          FALSE),                /* pcrel_offset */
2006
2007   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2008   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2009          16,                    /* rightshift */
2010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2011          16,                    /* bitsize */
2012          FALSE,                 /* pc_relative */
2013          0,                     /* bitpos */
2014          complain_overflow_dont, /* complain_on_overflow */
2015          ppc64_elf_ha_reloc,    /* special_function */
2016          "R_PPC64_ADDR16_HIGHA",        /* name */
2017          FALSE,                 /* partial_inplace */
2018          0,                     /* src_mask */
2019          0xffff,                /* dst_mask */
2020          FALSE),                /* pcrel_offset */
2021
2022   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2023   HOWTO (R_PPC64_DTPREL16_HIGH,
2024          16,                    /* rightshift */
2025          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2026          16,                    /* bitsize */
2027          FALSE,                 /* pc_relative */
2028          0,                     /* bitpos */
2029          complain_overflow_dont, /* complain_on_overflow */
2030          ppc64_elf_unhandled_reloc, /* special_function */
2031          "R_PPC64_DTPREL16_HIGH", /* name */
2032          FALSE,                 /* partial_inplace */
2033          0,                     /* src_mask */
2034          0xffff,                /* dst_mask */
2035          FALSE),                /* pcrel_offset */
2036
2037   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2038   HOWTO (R_PPC64_DTPREL16_HIGHA,
2039          16,                    /* rightshift */
2040          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2041          16,                    /* bitsize */
2042          FALSE,                 /* pc_relative */
2043          0,                     /* bitpos */
2044          complain_overflow_dont, /* complain_on_overflow */
2045          ppc64_elf_unhandled_reloc, /* special_function */
2046          "R_PPC64_DTPREL16_HIGHA", /* name */
2047          FALSE,                 /* partial_inplace */
2048          0,                     /* src_mask */
2049          0xffff,                /* dst_mask */
2050          FALSE),                /* pcrel_offset */
2051
2052   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2053   HOWTO (R_PPC64_TPREL16_HIGH,
2054          16,                    /* rightshift */
2055          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2056          16,                    /* bitsize */
2057          FALSE,                 /* pc_relative */
2058          0,                     /* bitpos */
2059          complain_overflow_dont, /* complain_on_overflow */
2060          ppc64_elf_unhandled_reloc, /* special_function */
2061          "R_PPC64_TPREL16_HIGH",        /* name */
2062          FALSE,                 /* partial_inplace */
2063          0,                     /* src_mask */
2064          0xffff,                /* dst_mask */
2065          FALSE),                /* pcrel_offset */
2066
2067   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2068   HOWTO (R_PPC64_TPREL16_HIGHA,
2069          16,                    /* rightshift */
2070          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2071          16,                    /* bitsize */
2072          FALSE,                 /* pc_relative */
2073          0,                     /* bitpos */
2074          complain_overflow_dont, /* complain_on_overflow */
2075          ppc64_elf_unhandled_reloc, /* special_function */
2076          "R_PPC64_TPREL16_HIGHA",       /* name */
2077          FALSE,                 /* partial_inplace */
2078          0,                     /* src_mask */
2079          0xffff,                /* dst_mask */
2080          FALSE),                /* pcrel_offset */
2081
2082   /* GNU extension to record C++ vtable hierarchy.  */
2083   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2084          0,                     /* rightshift */
2085          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2086          0,                     /* bitsize */
2087          FALSE,                 /* pc_relative */
2088          0,                     /* bitpos */
2089          complain_overflow_dont, /* complain_on_overflow */
2090          NULL,                  /* special_function */
2091          "R_PPC64_GNU_VTINHERIT", /* name */
2092          FALSE,                 /* partial_inplace */
2093          0,                     /* src_mask */
2094          0,                     /* dst_mask */
2095          FALSE),                /* pcrel_offset */
2096
2097   /* GNU extension to record C++ vtable member usage.  */
2098   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2099          0,                     /* rightshift */
2100          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2101          0,                     /* bitsize */
2102          FALSE,                 /* pc_relative */
2103          0,                     /* bitpos */
2104          complain_overflow_dont, /* complain_on_overflow */
2105          NULL,                  /* special_function */
2106          "R_PPC64_GNU_VTENTRY", /* name */
2107          FALSE,                 /* partial_inplace */
2108          0,                     /* src_mask */
2109          0,                     /* dst_mask */
2110          FALSE),                /* pcrel_offset */
2111 };
2112
2113 \f
2114 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2115    be done.  */
2116
2117 static void
2118 ppc_howto_init (void)
2119 {
2120   unsigned int i, type;
2121
2122   for (i = 0;
2123        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2124        i++)
2125     {
2126       type = ppc64_elf_howto_raw[i].type;
2127       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2128                           / sizeof (ppc64_elf_howto_table[0])));
2129       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2130     }
2131 }
2132
2133 static reloc_howto_type *
2134 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2135                              bfd_reloc_code_real_type code)
2136 {
2137   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2138
2139   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2140     /* Initialize howto table if needed.  */
2141     ppc_howto_init ();
2142
2143   switch (code)
2144     {
2145     default:
2146       return NULL;
2147
2148     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2149       break;
2150     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2151       break;
2152     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2153       break;
2154     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2155       break;
2156     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2157       break;
2158     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2159       break;
2160     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2161       break;
2162     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2163       break;
2164     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2165       break;
2166     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2167       break;
2168     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2169       break;
2170     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2171       break;
2172     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2173       break;
2174     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2175       break;
2176     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2177       break;
2178     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2179       break;
2180     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2181       break;
2182     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2183       break;
2184     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2185       break;
2186     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2187       break;
2188     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2189       break;
2190     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2191       break;
2192     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2193       break;
2194     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2195       break;
2196     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2197       break;
2198     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2199       break;
2200     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2201       break;
2202     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2203       break;
2204     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2205       break;
2206     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2207       break;
2208     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2209       break;
2210     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2211       break;
2212     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2213       break;
2214     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2215       break;
2216     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2217       break;
2218     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2219       break;
2220     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2221       break;
2222     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2223       break;
2224     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2225       break;
2226     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2227       break;
2228     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2229       break;
2230     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2231       break;
2232     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2233       break;
2234     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2235       break;
2236     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2237       break;
2238     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2239       break;
2240     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2241       break;
2242     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2243       break;
2244     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2245       break;
2246     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2247       break;
2248     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2249       break;
2250     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2251       break;
2252     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2253       break;
2254     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2255       break;
2256     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2257       break;
2258     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2259       break;
2260     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2261       break;
2262     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2263       break;
2264     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2265       break;
2266     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2267       break;
2268     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2269       break;
2270     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2271       break;
2272     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2273       break;
2274     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2275       break;
2276     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2277       break;
2278     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2279       break;
2280     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2281       break;
2282     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2283       break;
2284     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2285       break;
2286     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2287       break;
2288     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2289       break;
2290     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2291       break;
2292     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2293       break;
2294     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2295       break;
2296     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2297       break;
2298     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2299       break;
2300     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2301       break;
2302     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2303       break;
2304     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2305       break;
2306     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2307       break;
2308     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2309       break;
2310     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2311       break;
2312     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2313       break;
2314     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2315       break;
2316     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2317       break;
2318     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2319       break;
2320     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2321       break;
2322     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2323       break;
2324     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2325       break;
2326     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2327       break;
2328     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2329       break;
2330     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2331       break;
2332     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2333       break;
2334     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2335       break;
2336     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2337       break;
2338     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2339       break;
2340     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2341       break;
2342     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2343       break;
2344     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2345       break;
2346     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2347       break;
2348     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2349       break;
2350     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2351       break;
2352     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2353       break;
2354     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2355       break;
2356     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2357       break;
2358     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2359       break;
2360     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2361       break;
2362     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2363       break;
2364     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2365       break;
2366     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2367       break;
2368     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2369       break;
2370     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2371       break;
2372     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2373       break;
2374     }
2375
2376   return ppc64_elf_howto_table[r];
2377 };
2378
2379 static reloc_howto_type *
2380 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2381                              const char *r_name)
2382 {
2383   unsigned int i;
2384
2385   for (i = 0;
2386        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2387        i++)
2388     if (ppc64_elf_howto_raw[i].name != NULL
2389         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2390       return &ppc64_elf_howto_raw[i];
2391
2392   return NULL;
2393 }
2394
2395 /* Set the howto pointer for a PowerPC ELF reloc.  */
2396
2397 static void
2398 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2399                          Elf_Internal_Rela *dst)
2400 {
2401   unsigned int type;
2402
2403   /* Initialize howto table if needed.  */
2404   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2405     ppc_howto_init ();
2406
2407   type = ELF64_R_TYPE (dst->r_info);
2408   if (type >= (sizeof (ppc64_elf_howto_table)
2409                / sizeof (ppc64_elf_howto_table[0])))
2410     {
2411       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2412                              abfd, (int) type);
2413       type = R_PPC64_NONE;
2414     }
2415   cache_ptr->howto = ppc64_elf_howto_table[type];
2416 }
2417
2418 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2419
2420 static bfd_reloc_status_type
2421 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2422                     void *data, asection *input_section,
2423                     bfd *output_bfd, char **error_message)
2424 {
2425   /* If this is a relocatable link (output_bfd test tells us), just
2426      call the generic function.  Any adjustment will be done at final
2427      link time.  */
2428   if (output_bfd != NULL)
2429     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2430                                   input_section, output_bfd, error_message);
2431
2432   /* Adjust the addend for sign extension of the low 16 bits.
2433      We won't actually be using the low 16 bits, so trashing them
2434      doesn't matter.  */
2435   reloc_entry->addend += 0x8000;
2436   return bfd_reloc_continue;
2437 }
2438
2439 static bfd_reloc_status_type
2440 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2441                         void *data, asection *input_section,
2442                         bfd *output_bfd, char **error_message)
2443 {
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   if (strcmp (symbol->section->name, ".opd") == 0
2449       && (symbol->section->owner->flags & DYNAMIC) == 0)
2450     {
2451       bfd_vma dest = opd_entry_value (symbol->section,
2452                                       symbol->value + reloc_entry->addend,
2453                                       NULL, NULL, FALSE);
2454       if (dest != (bfd_vma) -1)
2455         reloc_entry->addend = dest - (symbol->value
2456                                       + symbol->section->output_section->vma
2457                                       + symbol->section->output_offset);
2458     }
2459   return bfd_reloc_continue;
2460 }
2461
2462 static bfd_reloc_status_type
2463 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2464                          void *data, asection *input_section,
2465                          bfd *output_bfd, char **error_message)
2466 {
2467   long insn;
2468   enum elf_ppc64_reloc_type r_type;
2469   bfd_size_type octets;
2470   /* Assume 'at' branch hints.  */
2471   bfd_boolean is_isa_v2 = TRUE;
2472
2473   /* If this is a relocatable link (output_bfd test tells us), just
2474      call the generic function.  Any adjustment will be done at final
2475      link time.  */
2476   if (output_bfd != NULL)
2477     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2478                                   input_section, output_bfd, error_message);
2479
2480   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2481   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2482   insn &= ~(0x01 << 21);
2483   r_type = reloc_entry->howto->type;
2484   if (r_type == R_PPC64_ADDR14_BRTAKEN
2485       || r_type == R_PPC64_REL14_BRTAKEN)
2486     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2487
2488   if (is_isa_v2)
2489     {
2490       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2491          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2492          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2493       if ((insn & (0x14 << 21)) == (0x04 << 21))
2494         insn |= 0x02 << 21;
2495       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2496         insn |= 0x08 << 21;
2497       else
2498         goto out;
2499     }
2500   else
2501     {
2502       bfd_vma target = 0;
2503       bfd_vma from;
2504
2505       if (!bfd_is_com_section (symbol->section))
2506         target = symbol->value;
2507       target += symbol->section->output_section->vma;
2508       target += symbol->section->output_offset;
2509       target += reloc_entry->addend;
2510
2511       from = (reloc_entry->address
2512               + input_section->output_offset
2513               + input_section->output_section->vma);
2514
2515       /* Invert 'y' bit if not the default.  */
2516       if ((bfd_signed_vma) (target - from) < 0)
2517         insn ^= 0x01 << 21;
2518     }
2519   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2520  out:
2521   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2522                                  input_section, output_bfd, error_message);
2523 }
2524
2525 static bfd_reloc_status_type
2526 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527                          void *data, asection *input_section,
2528                          bfd *output_bfd, char **error_message)
2529 {
2530   /* If this is a relocatable link (output_bfd test tells us), just
2531      call the generic function.  Any adjustment will be done at final
2532      link time.  */
2533   if (output_bfd != NULL)
2534     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2535                                   input_section, output_bfd, error_message);
2536
2537   /* Subtract the symbol section base address.  */
2538   reloc_entry->addend -= symbol->section->output_section->vma;
2539   return bfd_reloc_continue;
2540 }
2541
2542 static bfd_reloc_status_type
2543 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2544                             void *data, asection *input_section,
2545                             bfd *output_bfd, char **error_message)
2546 {
2547   /* If this is a relocatable link (output_bfd test tells us), just
2548      call the generic function.  Any adjustment will be done at final
2549      link time.  */
2550   if (output_bfd != NULL)
2551     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2552                                   input_section, output_bfd, error_message);
2553
2554   /* Subtract the symbol section base address.  */
2555   reloc_entry->addend -= symbol->section->output_section->vma;
2556
2557   /* Adjust the addend for sign extension of the low 16 bits.  */
2558   reloc_entry->addend += 0x8000;
2559   return bfd_reloc_continue;
2560 }
2561
2562 static bfd_reloc_status_type
2563 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2564                      void *data, asection *input_section,
2565                      bfd *output_bfd, char **error_message)
2566 {
2567   bfd_vma TOCstart;
2568
2569   /* If this is a relocatable link (output_bfd test tells us), just
2570      call the generic function.  Any adjustment will be done at final
2571      link time.  */
2572   if (output_bfd != NULL)
2573     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2574                                   input_section, output_bfd, error_message);
2575
2576   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2577   if (TOCstart == 0)
2578     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2579
2580   /* Subtract the TOC base address.  */
2581   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2582   return bfd_reloc_continue;
2583 }
2584
2585 static bfd_reloc_status_type
2586 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2587                         void *data, asection *input_section,
2588                         bfd *output_bfd, char **error_message)
2589 {
2590   bfd_vma TOCstart;
2591
2592   /* If this is a relocatable link (output_bfd test tells us), just
2593      call the generic function.  Any adjustment will be done at final
2594      link time.  */
2595   if (output_bfd != NULL)
2596     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2597                                   input_section, output_bfd, error_message);
2598
2599   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2600   if (TOCstart == 0)
2601     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2602
2603   /* Subtract the TOC base address.  */
2604   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2605
2606   /* Adjust the addend for sign extension of the low 16 bits.  */
2607   reloc_entry->addend += 0x8000;
2608   return bfd_reloc_continue;
2609 }
2610
2611 static bfd_reloc_status_type
2612 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2613                        void *data, asection *input_section,
2614                        bfd *output_bfd, char **error_message)
2615 {
2616   bfd_vma TOCstart;
2617   bfd_size_type octets;
2618
2619   /* If this is a relocatable link (output_bfd test tells us), just
2620      call the generic function.  Any adjustment will be done at final
2621      link time.  */
2622   if (output_bfd != NULL)
2623     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2624                                   input_section, output_bfd, error_message);
2625
2626   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2627   if (TOCstart == 0)
2628     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2629
2630   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2631   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2632   return bfd_reloc_ok;
2633 }
2634
2635 static bfd_reloc_status_type
2636 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2637                            void *data, asection *input_section,
2638                            bfd *output_bfd, char **error_message)
2639 {
2640   /* If this is a relocatable link (output_bfd test tells us), just
2641      call the generic function.  Any adjustment will be done at final
2642      link time.  */
2643   if (output_bfd != NULL)
2644     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2645                                   input_section, output_bfd, error_message);
2646
2647   if (error_message != NULL)
2648     {
2649       static char buf[60];
2650       sprintf (buf, "generic linker can't handle %s",
2651                reloc_entry->howto->name);
2652       *error_message = buf;
2653     }
2654   return bfd_reloc_dangerous;
2655 }
2656
2657 /* Track GOT entries needed for a given symbol.  We might need more
2658    than one got entry per symbol.  */
2659 struct got_entry
2660 {
2661   struct got_entry *next;
2662
2663   /* The symbol addend that we'll be placing in the GOT.  */
2664   bfd_vma addend;
2665
2666   /* Unlike other ELF targets, we use separate GOT entries for the same
2667      symbol referenced from different input files.  This is to support
2668      automatic multiple TOC/GOT sections, where the TOC base can vary
2669      from one input file to another.  After partitioning into TOC groups
2670      we merge entries within the group.
2671
2672      Point to the BFD owning this GOT entry.  */
2673   bfd *owner;
2674
2675   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2676      TLS_TPREL or TLS_DTPREL for tls entries.  */
2677   unsigned char tls_type;
2678
2679   /* Non-zero if got.ent points to real entry.  */
2680   unsigned char is_indirect;
2681
2682   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2683   union
2684     {
2685       bfd_signed_vma refcount;
2686       bfd_vma offset;
2687       struct got_entry *ent;
2688     } got;
2689 };
2690
2691 /* The same for PLT.  */
2692 struct plt_entry
2693 {
2694   struct plt_entry *next;
2695
2696   bfd_vma addend;
2697
2698   union
2699     {
2700       bfd_signed_vma refcount;
2701       bfd_vma offset;
2702     } plt;
2703 };
2704
2705 struct ppc64_elf_obj_tdata
2706 {
2707   struct elf_obj_tdata elf;
2708
2709   /* Shortcuts to dynamic linker sections.  */
2710   asection *got;
2711   asection *relgot;
2712
2713   /* Used during garbage collection.  We attach global symbols defined
2714      on removed .opd entries to this section so that the sym is removed.  */
2715   asection *deleted_section;
2716
2717   /* TLS local dynamic got entry handling.  Support for multiple GOT
2718      sections means we potentially need one of these for each input bfd.  */
2719   struct got_entry tlsld_got;
2720
2721   union {
2722     /* A copy of relocs before they are modified for --emit-relocs.  */
2723     Elf_Internal_Rela *relocs;
2724
2725     /* Section contents.  */
2726     bfd_byte *contents;
2727   } opd;
2728
2729   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2730      the reloc to be in the range -32768 to 32767.  */
2731   unsigned int has_small_toc_reloc : 1;
2732
2733   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2734      instruction not one we handle.  */
2735   unsigned int unexpected_toc_insn : 1;
2736 };
2737
2738 #define ppc64_elf_tdata(bfd) \
2739   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2740
2741 #define ppc64_tlsld_got(bfd) \
2742   (&ppc64_elf_tdata (bfd)->tlsld_got)
2743
2744 #define is_ppc64_elf(bfd) \
2745   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2746    && elf_object_id (bfd) == PPC64_ELF_DATA)
2747
2748 /* Override the generic function because we store some extras.  */
2749
2750 static bfd_boolean
2751 ppc64_elf_mkobject (bfd *abfd)
2752 {
2753   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2754                                   PPC64_ELF_DATA);
2755 }
2756
2757 /* Fix bad default arch selected for a 64 bit input bfd when the
2758    default is 32 bit.  */
2759
2760 static bfd_boolean
2761 ppc64_elf_object_p (bfd *abfd)
2762 {
2763   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2764     {
2765       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2766
2767       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2768         {
2769           /* Relies on arch after 32 bit default being 64 bit default.  */
2770           abfd->arch_info = abfd->arch_info->next;
2771           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2772         }
2773     }
2774   return TRUE;
2775 }
2776
2777 /* Support for core dump NOTE sections.  */
2778
2779 static bfd_boolean
2780 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2781 {
2782   size_t offset, size;
2783
2784   if (note->descsz != 504)
2785     return FALSE;
2786
2787   /* pr_cursig */
2788   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2789
2790   /* pr_pid */
2791   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2792
2793   /* pr_reg */
2794   offset = 112;
2795   size = 384;
2796
2797   /* Make a ".reg/999" section.  */
2798   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2799                                           size, note->descpos + offset);
2800 }
2801
2802 static bfd_boolean
2803 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2804 {
2805   if (note->descsz != 136)
2806     return FALSE;
2807
2808   elf_tdata (abfd)->core->pid
2809     = bfd_get_32 (abfd, note->descdata + 24);
2810   elf_tdata (abfd)->core->program
2811     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2812   elf_tdata (abfd)->core->command
2813     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2814
2815   return TRUE;
2816 }
2817
2818 static char *
2819 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2820                            ...)
2821 {
2822   switch (note_type)
2823     {
2824     default:
2825       return NULL;
2826
2827     case NT_PRPSINFO:
2828       {
2829         char data[136];
2830         va_list ap;
2831
2832         va_start (ap, note_type);
2833         memset (data, 0, sizeof (data));
2834         strncpy (data + 40, va_arg (ap, const char *), 16);
2835         strncpy (data + 56, va_arg (ap, const char *), 80);
2836         va_end (ap);
2837         return elfcore_write_note (abfd, buf, bufsiz,
2838                                    "CORE", note_type, data, sizeof (data));
2839       }
2840
2841     case NT_PRSTATUS:
2842       {
2843         char data[504];
2844         va_list ap;
2845         long pid;
2846         int cursig;
2847         const void *greg;
2848
2849         va_start (ap, note_type);
2850         memset (data, 0, 112);
2851         pid = va_arg (ap, long);
2852         bfd_put_32 (abfd, pid, data + 32);
2853         cursig = va_arg (ap, int);
2854         bfd_put_16 (abfd, cursig, data + 12);
2855         greg = va_arg (ap, const void *);
2856         memcpy (data + 112, greg, 384);
2857         memset (data + 496, 0, 8);
2858         va_end (ap);
2859         return elfcore_write_note (abfd, buf, bufsiz,
2860                                    "CORE", note_type, data, sizeof (data));
2861       }
2862     }
2863 }
2864
2865 /* Add extra PPC sections.  */
2866
2867 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2868 {
2869   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2870   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2871   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2872   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2873   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2874   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2875   { NULL,                     0,  0, 0,            0 }
2876 };
2877
2878 enum _ppc64_sec_type {
2879   sec_normal = 0,
2880   sec_opd = 1,
2881   sec_toc = 2
2882 };
2883
2884 struct _ppc64_elf_section_data
2885 {
2886   struct bfd_elf_section_data elf;
2887
2888   union
2889   {
2890     /* An array with one entry for each opd function descriptor.  */
2891     struct _opd_sec_data
2892     {
2893       /* Points to the function code section for local opd entries.  */
2894       asection **func_sec;
2895
2896       /* After editing .opd, adjust references to opd local syms.  */
2897       long *adjust;
2898     } opd;
2899
2900     /* An array for toc sections, indexed by offset/8.  */
2901     struct _toc_sec_data
2902     {
2903       /* Specifies the relocation symbol index used at a given toc offset.  */
2904       unsigned *symndx;
2905
2906       /* And the relocation addend.  */
2907       bfd_vma *add;
2908     } toc;
2909   } u;
2910
2911   enum _ppc64_sec_type sec_type:2;
2912
2913   /* Flag set when small branches are detected.  Used to
2914      select suitable defaults for the stub group size.  */
2915   unsigned int has_14bit_branch:1;
2916 };
2917
2918 #define ppc64_elf_section_data(sec) \
2919   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2920
2921 static bfd_boolean
2922 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2923 {
2924   if (!sec->used_by_bfd)
2925     {
2926       struct _ppc64_elf_section_data *sdata;
2927       bfd_size_type amt = sizeof (*sdata);
2928
2929       sdata = bfd_zalloc (abfd, amt);
2930       if (sdata == NULL)
2931         return FALSE;
2932       sec->used_by_bfd = sdata;
2933     }
2934
2935   return _bfd_elf_new_section_hook (abfd, sec);
2936 }
2937
2938 static struct _opd_sec_data *
2939 get_opd_info (asection * sec)
2940 {
2941   if (sec != NULL
2942       && ppc64_elf_section_data (sec) != NULL
2943       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2944     return &ppc64_elf_section_data (sec)->u.opd;
2945   return NULL;
2946 }
2947
2948 static inline int
2949 abiversion (bfd *abfd)
2950 {
2951   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2952 }
2953
2954 static inline void
2955 set_abiversion (bfd *abfd, int ver)
2956 {
2957   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2958   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2959 }
2960 \f
2961 /* Parameters for the qsort hook.  */
2962 static bfd_boolean synthetic_relocatable;
2963
2964 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2965
2966 static int
2967 compare_symbols (const void *ap, const void *bp)
2968 {
2969   const asymbol *a = * (const asymbol **) ap;
2970   const asymbol *b = * (const asymbol **) bp;
2971
2972   /* Section symbols first.  */
2973   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2974     return -1;
2975   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2976     return 1;
2977
2978   /* then .opd symbols.  */
2979   if (strcmp (a->section->name, ".opd") == 0
2980       && strcmp (b->section->name, ".opd") != 0)
2981     return -1;
2982   if (strcmp (a->section->name, ".opd") != 0
2983       && strcmp (b->section->name, ".opd") == 0)
2984     return 1;
2985
2986   /* then other code symbols.  */
2987   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2988       == (SEC_CODE | SEC_ALLOC)
2989       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2990          != (SEC_CODE | SEC_ALLOC))
2991     return -1;
2992
2993   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2994       != (SEC_CODE | SEC_ALLOC)
2995       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2996          == (SEC_CODE | SEC_ALLOC))
2997     return 1;
2998
2999   if (synthetic_relocatable)
3000     {
3001       if (a->section->id < b->section->id)
3002         return -1;
3003
3004       if (a->section->id > b->section->id)
3005         return 1;
3006     }
3007
3008   if (a->value + a->section->vma < b->value + b->section->vma)
3009     return -1;
3010
3011   if (a->value + a->section->vma > b->value + b->section->vma)
3012     return 1;
3013
3014   /* For syms with the same value, prefer strong dynamic global function
3015      syms over other syms.  */
3016   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3017     return -1;
3018
3019   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3020     return 1;
3021
3022   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3023     return -1;
3024
3025   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3026     return 1;
3027
3028   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3029     return -1;
3030
3031   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3032     return 1;
3033
3034   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3035     return -1;
3036
3037   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3038     return 1;
3039
3040   return 0;
3041 }
3042
3043 /* Search SYMS for a symbol of the given VALUE.  */
3044
3045 static asymbol *
3046 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3047 {
3048   long mid;
3049
3050   if (id == -1)
3051     {
3052       while (lo < hi)
3053         {
3054           mid = (lo + hi) >> 1;
3055           if (syms[mid]->value + syms[mid]->section->vma < value)
3056             lo = mid + 1;
3057           else if (syms[mid]->value + syms[mid]->section->vma > value)
3058             hi = mid;
3059           else
3060             return syms[mid];
3061         }
3062     }
3063   else
3064     {
3065       while (lo < hi)
3066         {
3067           mid = (lo + hi) >> 1;
3068           if (syms[mid]->section->id < id)
3069             lo = mid + 1;
3070           else if (syms[mid]->section->id > id)
3071             hi = mid;
3072           else if (syms[mid]->value < value)
3073             lo = mid + 1;
3074           else if (syms[mid]->value > value)
3075             hi = mid;
3076           else
3077             return syms[mid];
3078         }
3079     }
3080   return NULL;
3081 }
3082
3083 static bfd_boolean
3084 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3085 {
3086   bfd_vma vma = *(bfd_vma *) ptr;
3087   return ((section->flags & SEC_ALLOC) != 0
3088           && section->vma <= vma
3089           && vma < section->vma + section->size);
3090 }
3091
3092 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3093    entry syms.  Also generate @plt symbols for the glink branch table.  */
3094
3095 static long
3096 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3097                                 long static_count, asymbol **static_syms,
3098                                 long dyn_count, asymbol **dyn_syms,
3099                                 asymbol **ret)
3100 {
3101   asymbol *s;
3102   long i;
3103   long count;
3104   char *names;
3105   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3106   asection *opd = NULL;
3107   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3108   asymbol **syms;
3109   int abi = abiversion (abfd);
3110
3111   *ret = NULL;
3112
3113   if (abi < 2)
3114     {
3115       opd = bfd_get_section_by_name (abfd, ".opd");
3116       if (opd == NULL && abi == 1)
3117         return 0;
3118     }
3119
3120   symcount = static_count;
3121   if (!relocatable)
3122     symcount += dyn_count;
3123   if (symcount == 0)
3124     return 0;
3125
3126   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3127   if (syms == NULL)
3128     return -1;
3129
3130   if (!relocatable && static_count != 0 && dyn_count != 0)
3131     {
3132       /* Use both symbol tables.  */
3133       memcpy (syms, static_syms, static_count * sizeof (*syms));
3134       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3135     }
3136   else if (!relocatable && static_count == 0)
3137     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3138   else
3139     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3140
3141   synthetic_relocatable = relocatable;
3142   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3143
3144   if (!relocatable && symcount > 1)
3145     {
3146       long j;
3147       /* Trim duplicate syms, since we may have merged the normal and
3148          dynamic symbols.  Actually, we only care about syms that have
3149          different values, so trim any with the same value.  */
3150       for (i = 1, j = 1; i < symcount; ++i)
3151         if (syms[i - 1]->value + syms[i - 1]->section->vma
3152             != syms[i]->value + syms[i]->section->vma)
3153           syms[j++] = syms[i];
3154       symcount = j;
3155     }
3156
3157   i = 0;
3158   if (strcmp (syms[i]->section->name, ".opd") == 0)
3159     ++i;
3160   codesecsym = i;
3161
3162   for (; i < symcount; ++i)
3163     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3164          != (SEC_CODE | SEC_ALLOC))
3165         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3166       break;
3167   codesecsymend = i;
3168
3169   for (; i < symcount; ++i)
3170     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3171       break;
3172   secsymend = i;
3173
3174   for (; i < symcount; ++i)
3175     if (strcmp (syms[i]->section->name, ".opd") != 0)
3176       break;
3177   opdsymend = i;
3178
3179   for (; i < symcount; ++i)
3180     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3181         != (SEC_CODE | SEC_ALLOC))
3182       break;
3183   symcount = i;
3184
3185   count = 0;
3186
3187   if (relocatable)
3188     {
3189       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3190       arelent *r;
3191       size_t size;
3192       long relcount;
3193
3194       if (opdsymend == secsymend)
3195         goto done;
3196
3197       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3198       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3199       if (relcount == 0)
3200         goto done;
3201
3202       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3203         {
3204           count = -1;
3205           goto done;
3206         }
3207
3208       size = 0;
3209       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3210         {
3211           asymbol *sym;
3212
3213           while (r < opd->relocation + relcount
3214                  && r->address < syms[i]->value + opd->vma)
3215             ++r;
3216
3217           if (r == opd->relocation + relcount)
3218             break;
3219
3220           if (r->address != syms[i]->value + opd->vma)
3221             continue;
3222
3223           if (r->howto->type != R_PPC64_ADDR64)
3224             continue;
3225
3226           sym = *r->sym_ptr_ptr;
3227           if (!sym_exists_at (syms, opdsymend, symcount,
3228                               sym->section->id, sym->value + r->addend))
3229             {
3230               ++count;
3231               size += sizeof (asymbol);
3232               size += strlen (syms[i]->name) + 2;
3233             }
3234         }
3235
3236       s = *ret = bfd_malloc (size);
3237       if (s == NULL)
3238         {
3239           count = -1;
3240           goto done;
3241         }
3242
3243       names = (char *) (s + count);
3244
3245       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3246         {
3247           asymbol *sym;
3248
3249           while (r < opd->relocation + relcount
3250                  && r->address < syms[i]->value + opd->vma)
3251             ++r;
3252
3253           if (r == opd->relocation + relcount)
3254             break;
3255
3256           if (r->address != syms[i]->value + opd->vma)
3257             continue;
3258
3259           if (r->howto->type != R_PPC64_ADDR64)
3260             continue;
3261
3262           sym = *r->sym_ptr_ptr;
3263           if (!sym_exists_at (syms, opdsymend, symcount,
3264                               sym->section->id, sym->value + r->addend))
3265             {
3266               size_t len;
3267
3268               *s = *syms[i];
3269               s->flags |= BSF_SYNTHETIC;
3270               s->section = sym->section;
3271               s->value = sym->value + r->addend;
3272               s->name = names;
3273               *names++ = '.';
3274               len = strlen (syms[i]->name);
3275               memcpy (names, syms[i]->name, len + 1);
3276               names += len + 1;
3277               /* Have udata.p point back to the original symbol this
3278                  synthetic symbol was derived from.  */
3279               s->udata.p = syms[i];
3280               s++;
3281             }
3282         }
3283     }
3284   else
3285     {
3286       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3287       bfd_byte *contents = NULL;
3288       size_t size;
3289       long plt_count = 0;
3290       bfd_vma glink_vma = 0, resolv_vma = 0;
3291       asection *dynamic, *glink = NULL, *relplt = NULL;
3292       arelent *p;
3293
3294       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3295         {
3296         free_contents_and_exit:
3297           if (contents)
3298             free (contents);
3299           count = -1;
3300           goto done;
3301         }
3302
3303       size = 0;
3304       for (i = secsymend; i < opdsymend; ++i)
3305         {
3306           bfd_vma ent;
3307
3308           /* Ignore bogus symbols.  */
3309           if (syms[i]->value > opd->size - 8)
3310             continue;
3311
3312           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3313           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3314             {
3315               ++count;
3316               size += sizeof (asymbol);
3317               size += strlen (syms[i]->name) + 2;
3318             }
3319         }
3320
3321       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3322       if (dyn_count != 0
3323           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3324         {
3325           bfd_byte *dynbuf, *extdyn, *extdynend;
3326           size_t extdynsize;
3327           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3328
3329           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3330             goto free_contents_and_exit;
3331
3332           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3333           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3334
3335           extdyn = dynbuf;
3336           extdynend = extdyn + dynamic->size;
3337           for (; extdyn < extdynend; extdyn += extdynsize)
3338             {
3339               Elf_Internal_Dyn dyn;
3340               (*swap_dyn_in) (abfd, extdyn, &dyn);
3341
3342               if (dyn.d_tag == DT_NULL)
3343                 break;
3344
3345               if (dyn.d_tag == DT_PPC64_GLINK)
3346                 {
3347                   /* The first glink stub starts at offset 32; see comment in
3348                      ppc64_elf_finish_dynamic_sections. */
3349                   glink_vma = dyn.d_un.d_val + 32;
3350                   /* The .glink section usually does not survive the final
3351                      link; search for the section (usually .text) where the
3352                      glink stubs now reside.  */
3353                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3354                                                 &glink_vma);
3355                   break;
3356                 }
3357             }
3358
3359           free (dynbuf);
3360         }
3361
3362       if (glink != NULL)
3363         {
3364           /* Determine __glink trampoline by reading the relative branch
3365              from the first glink stub.  */
3366           bfd_byte buf[4];
3367           if (bfd_get_section_contents (abfd, glink, buf,
3368                                         glink_vma + 4 - glink->vma, 4))
3369             {
3370               unsigned int insn = bfd_get_32 (abfd, buf);
3371               insn ^= B_DOT;
3372               if ((insn & ~0x3fffffc) == 0)
3373                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3374             }
3375
3376           if (resolv_vma)
3377             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3378
3379           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3380           if (relplt != NULL)
3381             {
3382               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3383               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3384                 goto free_contents_and_exit;
3385
3386               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3387               size += plt_count * sizeof (asymbol);
3388
3389               p = relplt->relocation;
3390               for (i = 0; i < plt_count; i++, p++)
3391                 {
3392                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3393                   if (p->addend != 0)
3394                     size += sizeof ("+0x") - 1 + 16;
3395                 }
3396             }
3397         }
3398
3399       s = *ret = bfd_malloc (size);
3400       if (s == NULL)
3401         goto free_contents_and_exit;
3402
3403       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3404
3405       for (i = secsymend; i < opdsymend; ++i)
3406         {
3407           bfd_vma ent;
3408
3409           if (syms[i]->value > opd->size - 8)
3410             continue;
3411
3412           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3413           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3414             {
3415               long lo, hi;
3416               size_t len;
3417               asection *sec = abfd->sections;
3418
3419               *s = *syms[i];
3420               lo = codesecsym;
3421               hi = codesecsymend;
3422               while (lo < hi)
3423                 {
3424                   long mid = (lo + hi) >> 1;
3425                   if (syms[mid]->section->vma < ent)
3426                     lo = mid + 1;
3427                   else if (syms[mid]->section->vma > ent)
3428                     hi = mid;
3429                   else
3430                     {
3431                       sec = syms[mid]->section;
3432                       break;
3433                     }
3434                 }
3435
3436               if (lo >= hi && lo > codesecsym)
3437                 sec = syms[lo - 1]->section;
3438
3439               for (; sec != NULL; sec = sec->next)
3440                 {
3441                   if (sec->vma > ent)
3442                     break;
3443                   /* SEC_LOAD may not be set if SEC is from a separate debug
3444                      info file.  */
3445                   if ((sec->flags & SEC_ALLOC) == 0)
3446                     break;
3447                   if ((sec->flags & SEC_CODE) != 0)
3448                     s->section = sec;
3449                 }
3450               s->flags |= BSF_SYNTHETIC;
3451               s->value = ent - s->section->vma;
3452               s->name = names;
3453               *names++ = '.';
3454               len = strlen (syms[i]->name);
3455               memcpy (names, syms[i]->name, len + 1);
3456               names += len + 1;
3457               /* Have udata.p point back to the original symbol this
3458                  synthetic symbol was derived from.  */
3459               s->udata.p = syms[i];
3460               s++;
3461             }
3462         }
3463       free (contents);
3464
3465       if (glink != NULL && relplt != NULL)
3466         {
3467           if (resolv_vma)
3468             {
3469               /* Add a symbol for the main glink trampoline.  */
3470               memset (s, 0, sizeof *s);
3471               s->the_bfd = abfd;
3472               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3473               s->section = glink;
3474               s->value = resolv_vma - glink->vma;
3475               s->name = names;
3476               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3477               names += sizeof ("__glink_PLTresolve");
3478               s++;
3479               count++;
3480             }
3481
3482           /* FIXME: It would be very much nicer to put sym@plt on the
3483              stub rather than on the glink branch table entry.  The
3484              objdump disassembler would then use a sensible symbol
3485              name on plt calls.  The difficulty in doing so is
3486              a) finding the stubs, and,
3487              b) matching stubs against plt entries, and,
3488              c) there can be multiple stubs for a given plt entry.
3489
3490              Solving (a) could be done by code scanning, but older
3491              ppc64 binaries used different stubs to current code.
3492              (b) is the tricky one since you need to known the toc
3493              pointer for at least one function that uses a pic stub to
3494              be able to calculate the plt address referenced.
3495              (c) means gdb would need to set multiple breakpoints (or
3496              find the glink branch itself) when setting breakpoints
3497              for pending shared library loads.  */
3498           p = relplt->relocation;
3499           for (i = 0; i < plt_count; i++, p++)
3500             {
3501               size_t len;
3502
3503               *s = **p->sym_ptr_ptr;
3504               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3505                  we are defining a symbol, ensure one of them is set.  */
3506               if ((s->flags & BSF_LOCAL) == 0)
3507                 s->flags |= BSF_GLOBAL;
3508               s->flags |= BSF_SYNTHETIC;
3509               s->section = glink;
3510               s->value = glink_vma - glink->vma;
3511               s->name = names;
3512               s->udata.p = NULL;
3513               len = strlen ((*p->sym_ptr_ptr)->name);
3514               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3515               names += len;
3516               if (p->addend != 0)
3517                 {
3518                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3519                   names += sizeof ("+0x") - 1;
3520                   bfd_sprintf_vma (abfd, names, p->addend);
3521                   names += strlen (names);
3522                 }
3523               memcpy (names, "@plt", sizeof ("@plt"));
3524               names += sizeof ("@plt");
3525               s++;
3526               glink_vma += 8;
3527               if (i >= 0x8000)
3528                 glink_vma += 4;
3529             }
3530           count += plt_count;
3531         }
3532     }
3533
3534  done:
3535   free (syms);
3536   return count;
3537 }
3538 \f
3539 /* The following functions are specific to the ELF linker, while
3540    functions above are used generally.  Those named ppc64_elf_* are
3541    called by the main ELF linker code.  They appear in this file more
3542    or less in the order in which they are called.  eg.
3543    ppc64_elf_check_relocs is called early in the link process,
3544    ppc64_elf_finish_dynamic_sections is one of the last functions
3545    called.
3546
3547    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3548    functions have both a function code symbol and a function descriptor
3549    symbol.  A call to foo in a relocatable object file looks like:
3550
3551    .            .text
3552    .    x:
3553    .            bl      .foo
3554    .            nop
3555
3556    The function definition in another object file might be:
3557
3558    .            .section .opd
3559    .    foo:    .quad   .foo
3560    .            .quad   .TOC.@tocbase
3561    .            .quad   0
3562    .
3563    .            .text
3564    .    .foo:   blr
3565
3566    When the linker resolves the call during a static link, the branch
3567    unsurprisingly just goes to .foo and the .opd information is unused.
3568    If the function definition is in a shared library, things are a little
3569    different:  The call goes via a plt call stub, the opd information gets
3570    copied to the plt, and the linker patches the nop.
3571
3572    .    x:
3573    .            bl      .foo_stub
3574    .            ld      2,40(1)
3575    .
3576    .
3577    .    .foo_stub:
3578    .            std     2,40(1)                 # in practice, the call stub
3579    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3580    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3581    .            ld      12,0(11)
3582    .            ld      2,8(11)
3583    .            mtctr   12
3584    .            ld      11,16(11)
3585    .            bctr
3586    .
3587    .            .section .plt
3588    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3589
3590    The "reloc ()" notation is supposed to indicate that the linker emits
3591    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3592    copying.
3593
3594    What are the difficulties here?  Well, firstly, the relocations
3595    examined by the linker in check_relocs are against the function code
3596    sym .foo, while the dynamic relocation in the plt is emitted against
3597    the function descriptor symbol, foo.  Somewhere along the line, we need
3598    to carefully copy dynamic link information from one symbol to the other.
3599    Secondly, the generic part of the elf linker will make .foo a dynamic
3600    symbol as is normal for most other backends.  We need foo dynamic
3601    instead, at least for an application final link.  However, when
3602    creating a shared library containing foo, we need to have both symbols
3603    dynamic so that references to .foo are satisfied during the early
3604    stages of linking.  Otherwise the linker might decide to pull in a
3605    definition from some other object, eg. a static library.
3606
3607    Update: As of August 2004, we support a new convention.  Function
3608    calls may use the function descriptor symbol, ie. "bl foo".  This
3609    behaves exactly as "bl .foo".  */
3610
3611 /* Of those relocs that might be copied as dynamic relocs, this function
3612    selects those that must be copied when linking a shared library,
3613    even when the symbol is local.  */
3614
3615 static int
3616 must_be_dyn_reloc (struct bfd_link_info *info,
3617                    enum elf_ppc64_reloc_type r_type)
3618 {
3619   switch (r_type)
3620     {
3621     default:
3622       return 1;
3623
3624     case R_PPC64_REL32:
3625     case R_PPC64_REL64:
3626     case R_PPC64_REL30:
3627       return 0;
3628
3629     case R_PPC64_TPREL16:
3630     case R_PPC64_TPREL16_LO:
3631     case R_PPC64_TPREL16_HI:
3632     case R_PPC64_TPREL16_HA:
3633     case R_PPC64_TPREL16_DS:
3634     case R_PPC64_TPREL16_LO_DS:
3635     case R_PPC64_TPREL16_HIGH:
3636     case R_PPC64_TPREL16_HIGHA:
3637     case R_PPC64_TPREL16_HIGHER:
3638     case R_PPC64_TPREL16_HIGHERA:
3639     case R_PPC64_TPREL16_HIGHEST:
3640     case R_PPC64_TPREL16_HIGHESTA:
3641     case R_PPC64_TPREL64:
3642       return !info->executable;
3643     }
3644 }
3645
3646 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3647    copying dynamic variables from a shared lib into an app's dynbss
3648    section, and instead use a dynamic relocation to point into the
3649    shared lib.  With code that gcc generates, it's vital that this be
3650    enabled;  In the PowerPC64 ABI, the address of a function is actually
3651    the address of a function descriptor, which resides in the .opd
3652    section.  gcc uses the descriptor directly rather than going via the
3653    GOT as some other ABI's do, which means that initialized function
3654    pointers must reference the descriptor.  Thus, a function pointer
3655    initialized to the address of a function in a shared library will
3656    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3657    redefines the function descriptor symbol to point to the copy.  This
3658    presents a problem as a plt entry for that function is also
3659    initialized from the function descriptor symbol and the copy reloc
3660    may not be initialized first.  */
3661 #define ELIMINATE_COPY_RELOCS 1
3662
3663 /* Section name for stubs is the associated section name plus this
3664    string.  */
3665 #define STUB_SUFFIX ".stub"
3666
3667 /* Linker stubs.
3668    ppc_stub_long_branch:
3669    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3670    destination, but a 24 bit branch in a stub section will reach.
3671    .    b       dest
3672
3673    ppc_stub_plt_branch:
3674    Similar to the above, but a 24 bit branch in the stub section won't
3675    reach its destination.
3676    .    addis   %r11,%r2,xxx@toc@ha
3677    .    ld      %r12,xxx@toc@l(%r11)
3678    .    mtctr   %r12
3679    .    bctr
3680
3681    ppc_stub_plt_call:
3682    Used to call a function in a shared library.  If it so happens that
3683    the plt entry referenced crosses a 64k boundary, then an extra
3684    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3685    .    std     %r2,40(%r1)
3686    .    addis   %r11,%r2,xxx@toc@ha
3687    .    ld      %r12,xxx+0@toc@l(%r11)
3688    .    mtctr   %r12
3689    .    ld      %r2,xxx+8@toc@l(%r11)
3690    .    ld      %r11,xxx+16@toc@l(%r11)
3691    .    bctr
3692
3693    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3694    code to adjust the value and save r2 to support multiple toc sections.
3695    A ppc_stub_long_branch with an r2 offset looks like:
3696    .    std     %r2,40(%r1)
3697    .    addis   %r2,%r2,off@ha
3698    .    addi    %r2,%r2,off@l
3699    .    b       dest
3700
3701    A ppc_stub_plt_branch with an r2 offset looks like:
3702    .    std     %r2,40(%r1)
3703    .    addis   %r11,%r2,xxx@toc@ha
3704    .    ld      %r12,xxx@toc@l(%r11)
3705    .    addis   %r2,%r2,off@ha
3706    .    addi    %r2,%r2,off@l
3707    .    mtctr   %r12
3708    .    bctr
3709
3710    In cases where the "addis" instruction would add zero, the "addis" is
3711    omitted and following instructions modified slightly in some cases.
3712 */
3713
3714 enum ppc_stub_type {
3715   ppc_stub_none,
3716   ppc_stub_long_branch,
3717   ppc_stub_long_branch_r2off,
3718   ppc_stub_plt_branch,
3719   ppc_stub_plt_branch_r2off,
3720   ppc_stub_plt_call,
3721   ppc_stub_plt_call_r2save
3722 };
3723
3724 struct ppc_stub_hash_entry {
3725
3726   /* Base hash table entry structure.  */
3727   struct bfd_hash_entry root;
3728
3729   enum ppc_stub_type stub_type;
3730
3731   /* The stub section.  */
3732   asection *stub_sec;
3733
3734   /* Offset within stub_sec of the beginning of this stub.  */
3735   bfd_vma stub_offset;
3736
3737   /* Given the symbol's value and its section we can determine its final
3738      value when building the stubs (so the stub knows where to jump.  */
3739   bfd_vma target_value;
3740   asection *target_section;
3741
3742   /* The symbol table entry, if any, that this was derived from.  */
3743   struct ppc_link_hash_entry *h;
3744   struct plt_entry *plt_ent;
3745
3746   /* Where this stub is being called from, or, in the case of combined
3747      stub sections, the first input section in the group.  */
3748   asection *id_sec;
3749 };
3750
3751 struct ppc_branch_hash_entry {
3752
3753   /* Base hash table entry structure.  */
3754   struct bfd_hash_entry root;
3755
3756   /* Offset within branch lookup table.  */
3757   unsigned int offset;
3758
3759   /* Generation marker.  */
3760   unsigned int iter;
3761 };
3762
3763 /* Used to track dynamic relocations for local symbols.  */
3764 struct ppc_dyn_relocs
3765 {
3766   struct ppc_dyn_relocs *next;
3767
3768   /* The input section of the reloc.  */
3769   asection *sec;
3770
3771   /* Total number of relocs copied for the input section.  */
3772   unsigned int count : 31;
3773
3774   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3775   unsigned int ifunc : 1;
3776 };
3777
3778 struct ppc_link_hash_entry
3779 {
3780   struct elf_link_hash_entry elf;
3781
3782   union {
3783     /* A pointer to the most recently used stub hash entry against this
3784        symbol.  */
3785     struct ppc_stub_hash_entry *stub_cache;
3786
3787     /* A pointer to the next symbol starting with a '.'  */
3788     struct ppc_link_hash_entry *next_dot_sym;
3789   } u;
3790
3791   /* Track dynamic relocs copied for this symbol.  */
3792   struct elf_dyn_relocs *dyn_relocs;
3793
3794   /* Link between function code and descriptor symbols.  */
3795   struct ppc_link_hash_entry *oh;
3796
3797   /* Flag function code and descriptor symbols.  */
3798   unsigned int is_func:1;
3799   unsigned int is_func_descriptor:1;
3800   unsigned int fake:1;
3801
3802   /* Whether global opd/toc sym has been adjusted or not.
3803      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3804      should be set for all globals defined in any opd/toc section.  */
3805   unsigned int adjust_done:1;
3806
3807   /* Set if we twiddled this symbol to weak at some stage.  */
3808   unsigned int was_undefined:1;
3809
3810   /* Contexts in which symbol is used in the GOT (or TOC).
3811      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3812      corresponding relocs are encountered during check_relocs.
3813      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3814      indicate the corresponding GOT entry type is not needed.
3815      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3816      a TPREL one.  We use a separate flag rather than setting TPREL
3817      just for convenience in distinguishing the two cases.  */
3818 #define TLS_GD           1      /* GD reloc. */
3819 #define TLS_LD           2      /* LD reloc. */
3820 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3821 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3822 #define TLS_TLS         16      /* Any TLS reloc.  */
3823 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3824 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3825 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3826   unsigned char tls_mask;
3827 };
3828
3829 /* ppc64 ELF linker hash table.  */
3830
3831 struct ppc_link_hash_table
3832 {
3833   struct elf_link_hash_table elf;
3834
3835   /* The stub hash table.  */
3836   struct bfd_hash_table stub_hash_table;
3837
3838   /* Another hash table for plt_branch stubs.  */
3839   struct bfd_hash_table branch_hash_table;
3840
3841   /* Hash table for function prologue tocsave.  */
3842   htab_t tocsave_htab;
3843
3844   /* Linker stub bfd.  */
3845   bfd *stub_bfd;
3846
3847   /* Linker call-backs.  */
3848   asection * (*add_stub_section) (const char *, asection *);
3849   void (*layout_sections_again) (void);
3850
3851   /* Array to keep track of which stub sections have been created, and
3852      information on stub grouping.  */
3853   struct map_stub {
3854     /* This is the section to which stubs in the group will be attached.  */
3855     asection *link_sec;
3856     /* The stub section.  */
3857     asection *stub_sec;
3858     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3859     bfd_vma toc_off;
3860   } *stub_group;
3861
3862   /* Temp used when calculating TOC pointers.  */
3863   bfd_vma toc_curr;
3864   bfd *toc_bfd;
3865   asection *toc_first_sec;
3866
3867   /* Highest input section id.  */
3868   int top_id;
3869
3870   /* Highest output section index.  */
3871   int top_index;
3872
3873   /* Used when adding symbols.  */
3874   struct ppc_link_hash_entry *dot_syms;
3875
3876   /* List of input sections for each output section.  */
3877   asection **input_list;
3878
3879   /* Short-cuts to get to dynamic linker sections.  */
3880   asection *got;
3881   asection *plt;
3882   asection *relplt;
3883   asection *iplt;
3884   asection *reliplt;
3885   asection *dynbss;
3886   asection *relbss;
3887   asection *glink;
3888   asection *sfpr;
3889   asection *brlt;
3890   asection *relbrlt;
3891   asection *glink_eh_frame;
3892
3893   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3894   struct ppc_link_hash_entry *tls_get_addr;
3895   struct ppc_link_hash_entry *tls_get_addr_fd;
3896
3897   /* The size of reliplt used by got entry relocs.  */
3898   bfd_size_type got_reli_size;
3899
3900   /* Statistics.  */
3901   unsigned long stub_count[ppc_stub_plt_call_r2save];
3902
3903   /* Number of stubs against global syms.  */
3904   unsigned long stub_globals;
3905
3906   /* Alignment of PLT call stubs.  */
3907   unsigned int plt_stub_align:4;
3908
3909   /* Set if we're linking code with function descriptors.  */
3910   unsigned int opd_abi:1;
3911
3912   /* Set if PLT call stubs should load r11.  */
3913   unsigned int plt_static_chain:1;
3914
3915   /* Set if PLT call stubs need a read-read barrier.  */
3916   unsigned int plt_thread_safe:1;
3917
3918   /* Set if we should emit symbols for stubs.  */
3919   unsigned int emit_stub_syms:1;
3920
3921   /* Set if __tls_get_addr optimization should not be done.  */
3922   unsigned int no_tls_get_addr_opt:1;
3923
3924   /* Support for multiple toc sections.  */
3925   unsigned int do_multi_toc:1;
3926   unsigned int multi_toc_needed:1;
3927   unsigned int second_toc_pass:1;
3928   unsigned int do_toc_opt:1;
3929
3930   /* Set on error.  */
3931   unsigned int stub_error:1;
3932
3933   /* Temp used by ppc64_elf_process_dot_syms.  */
3934   unsigned int twiddled_syms:1;
3935
3936   /* Incremented every time we size stubs.  */
3937   unsigned int stub_iteration;
3938
3939   /* Small local sym cache.  */
3940   struct sym_cache sym_cache;
3941 };
3942
3943 /* Rename some of the generic section flags to better document how they
3944    are used here.  */
3945
3946 /* Nonzero if this section has TLS related relocations.  */
3947 #define has_tls_reloc sec_flg0
3948
3949 /* Nonzero if this section has a call to __tls_get_addr.  */
3950 #define has_tls_get_addr_call sec_flg1
3951
3952 /* Nonzero if this section has any toc or got relocs.  */
3953 #define has_toc_reloc sec_flg2
3954
3955 /* Nonzero if this section has a call to another section that uses
3956    the toc or got.  */
3957 #define makes_toc_func_call sec_flg3
3958
3959 /* Recursion protection when determining above flag.  */
3960 #define call_check_in_progress sec_flg4
3961 #define call_check_done sec_flg5
3962
3963 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3964
3965 #define ppc_hash_table(p) \
3966   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3967   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3968
3969 #define ppc_stub_hash_lookup(table, string, create, copy) \
3970   ((struct ppc_stub_hash_entry *) \
3971    bfd_hash_lookup ((table), (string), (create), (copy)))
3972
3973 #define ppc_branch_hash_lookup(table, string, create, copy) \
3974   ((struct ppc_branch_hash_entry *) \
3975    bfd_hash_lookup ((table), (string), (create), (copy)))
3976
3977 /* Create an entry in the stub hash table.  */
3978
3979 static struct bfd_hash_entry *
3980 stub_hash_newfunc (struct bfd_hash_entry *entry,
3981                    struct bfd_hash_table *table,
3982                    const char *string)
3983 {
3984   /* Allocate the structure if it has not already been allocated by a
3985      subclass.  */
3986   if (entry == NULL)
3987     {
3988       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3989       if (entry == NULL)
3990         return entry;
3991     }
3992
3993   /* Call the allocation method of the superclass.  */
3994   entry = bfd_hash_newfunc (entry, table, string);
3995   if (entry != NULL)
3996     {
3997       struct ppc_stub_hash_entry *eh;
3998
3999       /* Initialize the local fields.  */
4000       eh = (struct ppc_stub_hash_entry *) entry;
4001       eh->stub_type = ppc_stub_none;
4002       eh->stub_sec = NULL;
4003       eh->stub_offset = 0;
4004       eh->target_value = 0;
4005       eh->target_section = NULL;
4006       eh->h = NULL;
4007       eh->id_sec = NULL;
4008     }
4009
4010   return entry;
4011 }
4012
4013 /* Create an entry in the branch hash table.  */
4014
4015 static struct bfd_hash_entry *
4016 branch_hash_newfunc (struct bfd_hash_entry *entry,
4017                      struct bfd_hash_table *table,
4018                      const char *string)
4019 {
4020   /* Allocate the structure if it has not already been allocated by a
4021      subclass.  */
4022   if (entry == NULL)
4023     {
4024       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4025       if (entry == NULL)
4026         return entry;
4027     }
4028
4029   /* Call the allocation method of the superclass.  */
4030   entry = bfd_hash_newfunc (entry, table, string);
4031   if (entry != NULL)
4032     {
4033       struct ppc_branch_hash_entry *eh;
4034
4035       /* Initialize the local fields.  */
4036       eh = (struct ppc_branch_hash_entry *) entry;
4037       eh->offset = 0;
4038       eh->iter = 0;
4039     }
4040
4041   return entry;
4042 }
4043
4044 /* Create an entry in a ppc64 ELF linker hash table.  */
4045
4046 static struct bfd_hash_entry *
4047 link_hash_newfunc (struct bfd_hash_entry *entry,
4048                    struct bfd_hash_table *table,
4049                    const char *string)
4050 {
4051   /* Allocate the structure if it has not already been allocated by a
4052      subclass.  */
4053   if (entry == NULL)
4054     {
4055       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4056       if (entry == NULL)
4057         return entry;
4058     }
4059
4060   /* Call the allocation method of the superclass.  */
4061   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4062   if (entry != NULL)
4063     {
4064       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4065
4066       memset (&eh->u.stub_cache, 0,
4067               (sizeof (struct ppc_link_hash_entry)
4068                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4069
4070       /* When making function calls, old ABI code references function entry
4071          points (dot symbols), while new ABI code references the function
4072          descriptor symbol.  We need to make any combination of reference and
4073          definition work together, without breaking archive linking.
4074
4075          For a defined function "foo" and an undefined call to "bar":
4076          An old object defines "foo" and ".foo", references ".bar" (possibly
4077          "bar" too).
4078          A new object defines "foo" and references "bar".
4079
4080          A new object thus has no problem with its undefined symbols being
4081          satisfied by definitions in an old object.  On the other hand, the
4082          old object won't have ".bar" satisfied by a new object.
4083
4084          Keep a list of newly added dot-symbols.  */
4085
4086       if (string[0] == '.')
4087         {
4088           struct ppc_link_hash_table *htab;
4089
4090           htab = (struct ppc_link_hash_table *) table;
4091           eh->u.next_dot_sym = htab->dot_syms;
4092           htab->dot_syms = eh;
4093         }
4094     }
4095
4096   return entry;
4097 }
4098
4099 struct tocsave_entry {
4100   asection *sec;
4101   bfd_vma offset;
4102 };
4103
4104 static hashval_t
4105 tocsave_htab_hash (const void *p)
4106 {
4107   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4108   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4109 }
4110
4111 static int
4112 tocsave_htab_eq (const void *p1, const void *p2)
4113 {
4114   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4115   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4116   return e1->sec == e2->sec && e1->offset == e2->offset;
4117 }
4118
4119 /* Create a ppc64 ELF linker hash table.  */
4120
4121 static struct bfd_link_hash_table *
4122 ppc64_elf_link_hash_table_create (bfd *abfd)
4123 {
4124   struct ppc_link_hash_table *htab;
4125   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4126
4127   htab = bfd_zmalloc (amt);
4128   if (htab == NULL)
4129     return NULL;
4130
4131   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4132                                       sizeof (struct ppc_link_hash_entry),
4133                                       PPC64_ELF_DATA))
4134     {
4135       free (htab);
4136       return NULL;
4137     }
4138
4139   /* Init the stub hash table too.  */
4140   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4141                             sizeof (struct ppc_stub_hash_entry)))
4142     return NULL;
4143
4144   /* And the branch hash table.  */
4145   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4146                             sizeof (struct ppc_branch_hash_entry)))
4147     return NULL;
4148
4149   htab->tocsave_htab = htab_try_create (1024,
4150                                         tocsave_htab_hash,
4151                                         tocsave_htab_eq,
4152                                         NULL);
4153   if (htab->tocsave_htab == NULL)
4154     return NULL;
4155
4156   /* Initializing two fields of the union is just cosmetic.  We really
4157      only care about glist, but when compiled on a 32-bit host the
4158      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4159      debugger inspection of these fields look nicer.  */
4160   htab->elf.init_got_refcount.refcount = 0;
4161   htab->elf.init_got_refcount.glist = NULL;
4162   htab->elf.init_plt_refcount.refcount = 0;
4163   htab->elf.init_plt_refcount.glist = NULL;
4164   htab->elf.init_got_offset.offset = 0;
4165   htab->elf.init_got_offset.glist = NULL;
4166   htab->elf.init_plt_offset.offset = 0;
4167   htab->elf.init_plt_offset.glist = NULL;
4168
4169   return &htab->elf.root;
4170 }
4171
4172 /* Free the derived linker hash table.  */
4173
4174 static void
4175 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4176 {
4177   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4178
4179   bfd_hash_table_free (&htab->stub_hash_table);
4180   bfd_hash_table_free (&htab->branch_hash_table);
4181   if (htab->tocsave_htab)
4182     htab_delete (htab->tocsave_htab);
4183   _bfd_elf_link_hash_table_free (hash);
4184 }
4185
4186 /* Create sections for linker generated code.  */
4187
4188 static bfd_boolean
4189 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4190 {
4191   struct ppc_link_hash_table *htab;
4192   flagword flags;
4193
4194   htab = ppc_hash_table (info);
4195
4196   /* Create .sfpr for code to save and restore fp regs.  */
4197   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4198            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4199   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4200                                                    flags);
4201   if (htab->sfpr == NULL
4202       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4203     return FALSE;
4204
4205   /* Create .glink for lazy dynamic linking support.  */
4206   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4207                                                     flags);
4208   if (htab->glink == NULL
4209       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4210     return FALSE;
4211
4212   if (!info->no_ld_generated_unwind_info)
4213     {
4214       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4215                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4216       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4217                                                                  ".eh_frame",
4218                                                                  flags);
4219       if (htab->glink_eh_frame == NULL
4220           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4221         return FALSE;
4222     }
4223
4224   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4225   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4226   if (htab->iplt == NULL
4227       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4228     return FALSE;
4229
4230   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4231            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4232   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4233                                                       ".rela.iplt",
4234                                                       flags);
4235   if (htab->reliplt == NULL
4236       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4237     return FALSE;
4238
4239   /* Create branch lookup table for plt_branch stubs.  */
4240   flags = (SEC_ALLOC | SEC_LOAD
4241            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4242   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4243                                                    flags);
4244   if (htab->brlt == NULL
4245       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4246     return FALSE;
4247
4248   if (!info->shared)
4249     return TRUE;
4250
4251   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4252            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4253   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4254                                                       ".rela.branch_lt",
4255                                                       flags);
4256   if (htab->relbrlt == NULL
4257       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4258     return FALSE;
4259
4260   return TRUE;
4261 }
4262
4263 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4264
4265 bfd_boolean
4266 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4267 {
4268   struct ppc_link_hash_table *htab;
4269
4270   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4271
4272 /* Always hook our dynamic sections into the first bfd, which is the
4273    linker created stub bfd.  This ensures that the GOT header is at
4274    the start of the output TOC section.  */
4275   htab = ppc_hash_table (info);
4276   if (htab == NULL)
4277     return FALSE;
4278   htab->stub_bfd = abfd;
4279   htab->elf.dynobj = abfd;
4280
4281   if (info->relocatable)
4282     return TRUE;
4283
4284   return create_linkage_sections (htab->elf.dynobj, info);
4285 }
4286
4287 /* Build a name for an entry in the stub hash table.  */
4288
4289 static char *
4290 ppc_stub_name (const asection *input_section,
4291                const asection *sym_sec,
4292                const struct ppc_link_hash_entry *h,
4293                const Elf_Internal_Rela *rel)
4294 {
4295   char *stub_name;
4296   ssize_t len;
4297
4298   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4299      offsets from a sym as a branch target?  In fact, we could
4300      probably assume the addend is always zero.  */
4301   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4302
4303   if (h)
4304     {
4305       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4306       stub_name = bfd_malloc (len);
4307       if (stub_name == NULL)
4308         return stub_name;
4309
4310       len = sprintf (stub_name, "%08x.%s+%x",
4311                      input_section->id & 0xffffffff,
4312                      h->elf.root.root.string,
4313                      (int) rel->r_addend & 0xffffffff);
4314     }
4315   else
4316     {
4317       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4318       stub_name = bfd_malloc (len);
4319       if (stub_name == NULL)
4320         return stub_name;
4321
4322       len = sprintf (stub_name, "%08x.%x:%x+%x",
4323                      input_section->id & 0xffffffff,
4324                      sym_sec->id & 0xffffffff,
4325                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4326                      (int) rel->r_addend & 0xffffffff);
4327     }
4328   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4329     stub_name[len - 2] = 0;
4330   return stub_name;
4331 }
4332
4333 /* Look up an entry in the stub hash.  Stub entries are cached because
4334    creating the stub name takes a bit of time.  */
4335
4336 static struct ppc_stub_hash_entry *
4337 ppc_get_stub_entry (const asection *input_section,
4338                     const asection *sym_sec,
4339                     struct ppc_link_hash_entry *h,
4340                     const Elf_Internal_Rela *rel,
4341                     struct ppc_link_hash_table *htab)
4342 {
4343   struct ppc_stub_hash_entry *stub_entry;
4344   const asection *id_sec;
4345
4346   /* If this input section is part of a group of sections sharing one
4347      stub section, then use the id of the first section in the group.
4348      Stub names need to include a section id, as there may well be
4349      more than one stub used to reach say, printf, and we need to
4350      distinguish between them.  */
4351   id_sec = htab->stub_group[input_section->id].link_sec;
4352
4353   if (h != NULL && h->u.stub_cache != NULL
4354       && h->u.stub_cache->h == h
4355       && h->u.stub_cache->id_sec == id_sec)
4356     {
4357       stub_entry = h->u.stub_cache;
4358     }
4359   else
4360     {
4361       char *stub_name;
4362
4363       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4364       if (stub_name == NULL)
4365         return NULL;
4366
4367       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4368                                          stub_name, FALSE, FALSE);
4369       if (h != NULL)
4370         h->u.stub_cache = stub_entry;
4371
4372       free (stub_name);
4373     }
4374
4375   return stub_entry;
4376 }
4377
4378 /* Add a new stub entry to the stub hash.  Not all fields of the new
4379    stub entry are initialised.  */
4380
4381 static struct ppc_stub_hash_entry *
4382 ppc_add_stub (const char *stub_name,
4383               asection *section,
4384               struct bfd_link_info *info)
4385 {
4386   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4387   asection *link_sec;
4388   asection *stub_sec;
4389   struct ppc_stub_hash_entry *stub_entry;
4390
4391   link_sec = htab->stub_group[section->id].link_sec;
4392   stub_sec = htab->stub_group[section->id].stub_sec;
4393   if (stub_sec == NULL)
4394     {
4395       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4396       if (stub_sec == NULL)
4397         {
4398           size_t namelen;
4399           bfd_size_type len;
4400           char *s_name;
4401
4402           namelen = strlen (link_sec->name);
4403           len = namelen + sizeof (STUB_SUFFIX);
4404           s_name = bfd_alloc (htab->stub_bfd, len);
4405           if (s_name == NULL)
4406             return NULL;
4407
4408           memcpy (s_name, link_sec->name, namelen);
4409           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4410           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4411           if (stub_sec == NULL)
4412             return NULL;
4413           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4414         }
4415       htab->stub_group[section->id].stub_sec = stub_sec;
4416     }
4417
4418   /* Enter this entry into the linker stub hash table.  */
4419   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4420                                      TRUE, FALSE);
4421   if (stub_entry == NULL)
4422     {
4423       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4424                               section->owner, stub_name);
4425       return NULL;
4426     }
4427
4428   stub_entry->stub_sec = stub_sec;
4429   stub_entry->stub_offset = 0;
4430   stub_entry->id_sec = link_sec;
4431   return stub_entry;
4432 }
4433
4434 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4435    not already done.  */
4436
4437 static bfd_boolean
4438 create_got_section (bfd *abfd, struct bfd_link_info *info)
4439 {
4440   asection *got, *relgot;
4441   flagword flags;
4442   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4443
4444   if (!is_ppc64_elf (abfd))
4445     return FALSE;
4446   if (htab == NULL)
4447     return FALSE;
4448
4449   if (!htab->got)
4450     {
4451       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4452         return FALSE;
4453
4454       htab->got = bfd_get_linker_section (htab->elf.dynobj, ".got");
4455       if (!htab->got)
4456         abort ();
4457     }
4458
4459   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4460            | SEC_LINKER_CREATED);
4461
4462   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4463   if (!got
4464       || !bfd_set_section_alignment (abfd, got, 3))
4465     return FALSE;
4466
4467   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4468                                                flags | SEC_READONLY);
4469   if (!relgot
4470       || ! bfd_set_section_alignment (abfd, relgot, 3))
4471     return FALSE;
4472
4473   ppc64_elf_tdata (abfd)->got = got;
4474   ppc64_elf_tdata (abfd)->relgot = relgot;
4475   return TRUE;
4476 }
4477
4478 /* Create the dynamic sections, and set up shortcuts.  */
4479
4480 static bfd_boolean
4481 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4482 {
4483   struct ppc_link_hash_table *htab;
4484
4485   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4486     return FALSE;
4487
4488   htab = ppc_hash_table (info);
4489   if (htab == NULL)
4490     return FALSE;
4491
4492   if (!htab->got)
4493     htab->got = bfd_get_linker_section (dynobj, ".got");
4494   htab->plt = bfd_get_linker_section (dynobj, ".plt");
4495   htab->relplt = bfd_get_linker_section (dynobj, ".rela.plt");
4496   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4497   if (!info->shared)
4498     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4499
4500   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4501       || (!info->shared && !htab->relbss))
4502     abort ();
4503
4504   return TRUE;
4505 }
4506
4507 /* Follow indirect and warning symbol links.  */
4508
4509 static inline struct bfd_link_hash_entry *
4510 follow_link (struct bfd_link_hash_entry *h)
4511 {
4512   while (h->type == bfd_link_hash_indirect
4513          || h->type == bfd_link_hash_warning)
4514     h = h->u.i.link;
4515   return h;
4516 }
4517
4518 static inline struct elf_link_hash_entry *
4519 elf_follow_link (struct elf_link_hash_entry *h)
4520 {
4521   return (struct elf_link_hash_entry *) follow_link (&h->root);
4522 }
4523
4524 static inline struct ppc_link_hash_entry *
4525 ppc_follow_link (struct ppc_link_hash_entry *h)
4526 {
4527   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4528 }
4529
4530 /* Merge PLT info on FROM with that on TO.  */
4531
4532 static void
4533 move_plt_plist (struct ppc_link_hash_entry *from,
4534                 struct ppc_link_hash_entry *to)
4535 {
4536   if (from->elf.plt.plist != NULL)
4537     {
4538       if (to->elf.plt.plist != NULL)
4539         {
4540           struct plt_entry **entp;
4541           struct plt_entry *ent;
4542
4543           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4544             {
4545               struct plt_entry *dent;
4546
4547               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4548                 if (dent->addend == ent->addend)
4549                   {
4550                     dent->plt.refcount += ent->plt.refcount;
4551                     *entp = ent->next;
4552                     break;
4553                   }
4554               if (dent == NULL)
4555                 entp = &ent->next;
4556             }
4557           *entp = to->elf.plt.plist;
4558         }
4559
4560       to->elf.plt.plist = from->elf.plt.plist;
4561       from->elf.plt.plist = NULL;
4562     }
4563 }
4564
4565 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4566
4567 static void
4568 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4569                                 struct elf_link_hash_entry *dir,
4570                                 struct elf_link_hash_entry *ind)
4571 {
4572   struct ppc_link_hash_entry *edir, *eind;
4573
4574   edir = (struct ppc_link_hash_entry *) dir;
4575   eind = (struct ppc_link_hash_entry *) ind;
4576
4577   edir->is_func |= eind->is_func;
4578   edir->is_func_descriptor |= eind->is_func_descriptor;
4579   edir->tls_mask |= eind->tls_mask;
4580   if (eind->oh != NULL)
4581     edir->oh = ppc_follow_link (eind->oh);
4582
4583   /* If called to transfer flags for a weakdef during processing
4584      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4585      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4586   if (!(ELIMINATE_COPY_RELOCS
4587         && eind->elf.root.type != bfd_link_hash_indirect
4588         && edir->elf.dynamic_adjusted))
4589     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4590
4591   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4592   edir->elf.ref_regular |= eind->elf.ref_regular;
4593   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4594   edir->elf.needs_plt |= eind->elf.needs_plt;
4595
4596   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4597   if (eind->dyn_relocs != NULL)
4598     {
4599       if (edir->dyn_relocs != NULL)
4600         {
4601           struct elf_dyn_relocs **pp;
4602           struct elf_dyn_relocs *p;
4603
4604           /* Add reloc counts against the indirect sym to the direct sym
4605              list.  Merge any entries against the same section.  */
4606           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4607             {
4608               struct elf_dyn_relocs *q;
4609
4610               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4611                 if (q->sec == p->sec)
4612                   {
4613                     q->pc_count += p->pc_count;
4614                     q->count += p->count;
4615                     *pp = p->next;
4616                     break;
4617                   }
4618               if (q == NULL)
4619                 pp = &p->next;
4620             }
4621           *pp = edir->dyn_relocs;
4622         }
4623
4624       edir->dyn_relocs = eind->dyn_relocs;
4625       eind->dyn_relocs = NULL;
4626     }
4627
4628   /* If we were called to copy over info for a weak sym, that's all.
4629      You might think dyn_relocs need not be copied over;  After all,
4630      both syms will be dynamic or both non-dynamic so we're just
4631      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4632      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4633      dyn_relocs in read-only sections, and it does so on what is the
4634      DIR sym here.  */
4635   if (eind->elf.root.type != bfd_link_hash_indirect)
4636     return;
4637
4638   /* Copy over got entries that we may have already seen to the
4639      symbol which just became indirect.  */
4640   if (eind->elf.got.glist != NULL)
4641     {
4642       if (edir->elf.got.glist != NULL)
4643         {
4644           struct got_entry **entp;
4645           struct got_entry *ent;
4646
4647           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4648             {
4649               struct got_entry *dent;
4650
4651               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4652                 if (dent->addend == ent->addend
4653                     && dent->owner == ent->owner
4654                     && dent->tls_type == ent->tls_type)
4655                   {
4656                     dent->got.refcount += ent->got.refcount;
4657                     *entp = ent->next;
4658                     break;
4659                   }
4660               if (dent == NULL)
4661                 entp = &ent->next;
4662             }
4663           *entp = edir->elf.got.glist;
4664         }
4665
4666       edir->elf.got.glist = eind->elf.got.glist;
4667       eind->elf.got.glist = NULL;
4668     }
4669
4670   /* And plt entries.  */
4671   move_plt_plist (eind, edir);
4672
4673   if (eind->elf.dynindx != -1)
4674     {
4675       if (edir->elf.dynindx != -1)
4676         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4677                                 edir->elf.dynstr_index);
4678       edir->elf.dynindx = eind->elf.dynindx;
4679       edir->elf.dynstr_index = eind->elf.dynstr_index;
4680       eind->elf.dynindx = -1;
4681       eind->elf.dynstr_index = 0;
4682     }
4683 }
4684
4685 /* Find the function descriptor hash entry from the given function code
4686    hash entry FH.  Link the entries via their OH fields.  */
4687
4688 static struct ppc_link_hash_entry *
4689 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4690 {
4691   struct ppc_link_hash_entry *fdh = fh->oh;
4692
4693   if (fdh == NULL)
4694     {
4695       const char *fd_name = fh->elf.root.root.string + 1;
4696
4697       fdh = (struct ppc_link_hash_entry *)
4698         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4699       if (fdh == NULL)
4700         return fdh;
4701
4702       fdh->is_func_descriptor = 1;
4703       fdh->oh = fh;
4704       fh->is_func = 1;
4705       fh->oh = fdh;
4706     }
4707
4708   return ppc_follow_link (fdh);
4709 }
4710
4711 /* Make a fake function descriptor sym for the code sym FH.  */
4712
4713 static struct ppc_link_hash_entry *
4714 make_fdh (struct bfd_link_info *info,
4715           struct ppc_link_hash_entry *fh)
4716 {
4717   bfd *abfd;
4718   asymbol *newsym;
4719   struct bfd_link_hash_entry *bh;
4720   struct ppc_link_hash_entry *fdh;
4721
4722   abfd = fh->elf.root.u.undef.abfd;
4723   newsym = bfd_make_empty_symbol (abfd);
4724   newsym->name = fh->elf.root.root.string + 1;
4725   newsym->section = bfd_und_section_ptr;
4726   newsym->value = 0;
4727   newsym->flags = BSF_WEAK;
4728
4729   bh = NULL;
4730   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4731                                          newsym->flags, newsym->section,
4732                                          newsym->value, NULL, FALSE, FALSE,
4733                                          &bh))
4734     return NULL;
4735
4736   fdh = (struct ppc_link_hash_entry *) bh;
4737   fdh->elf.non_elf = 0;
4738   fdh->fake = 1;
4739   fdh->is_func_descriptor = 1;
4740   fdh->oh = fh;
4741   fh->is_func = 1;
4742   fh->oh = fdh;
4743   return fdh;
4744 }
4745
4746 /* Fix function descriptor symbols defined in .opd sections to be
4747    function type.  */
4748
4749 static bfd_boolean
4750 ppc64_elf_add_symbol_hook (bfd *ibfd,
4751                            struct bfd_link_info *info,
4752                            Elf_Internal_Sym *isym,
4753                            const char **name ATTRIBUTE_UNUSED,
4754                            flagword *flags ATTRIBUTE_UNUSED,
4755                            asection **sec,
4756                            bfd_vma *value ATTRIBUTE_UNUSED)
4757 {
4758   if ((ibfd->flags & DYNAMIC) == 0
4759       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4760     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4761
4762   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4763     {
4764       if ((ibfd->flags & DYNAMIC) == 0)
4765         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4766     }
4767   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4768     ;
4769   else if (*sec != NULL
4770            && strcmp ((*sec)->name, ".opd") == 0)
4771     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4772
4773   return TRUE;
4774 }
4775
4776 /* This function makes an old ABI object reference to ".bar" cause the
4777    inclusion of a new ABI object archive that defines "bar".
4778    NAME is a symbol defined in an archive.  Return a symbol in the hash
4779    table that might be satisfied by the archive symbols.  */
4780
4781 static struct elf_link_hash_entry *
4782 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4783                                  struct bfd_link_info *info,
4784                                  const char *name)
4785 {
4786   struct elf_link_hash_entry *h;
4787   char *dot_name;
4788   size_t len;
4789
4790   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4791   if (h != NULL
4792       /* Don't return this sym if it is a fake function descriptor
4793          created by add_symbol_adjust.  */
4794       && !(h->root.type == bfd_link_hash_undefweak
4795            && ((struct ppc_link_hash_entry *) h)->fake))
4796     return h;
4797
4798   if (name[0] == '.')
4799     return h;
4800
4801   len = strlen (name);
4802   dot_name = bfd_alloc (abfd, len + 2);
4803   if (dot_name == NULL)
4804     return (struct elf_link_hash_entry *) 0 - 1;
4805   dot_name[0] = '.';
4806   memcpy (dot_name + 1, name, len + 1);
4807   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4808   bfd_release (abfd, dot_name);
4809   return h;
4810 }
4811
4812 /* This function satisfies all old ABI object references to ".bar" if a
4813    new ABI object defines "bar".  Well, at least, undefined dot symbols
4814    are made weak.  This stops later archive searches from including an
4815    object if we already have a function descriptor definition.  It also
4816    prevents the linker complaining about undefined symbols.
4817    We also check and correct mismatched symbol visibility here.  The
4818    most restrictive visibility of the function descriptor and the
4819    function entry symbol is used.  */
4820
4821 static bfd_boolean
4822 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4823 {
4824   struct ppc_link_hash_table *htab;
4825   struct ppc_link_hash_entry *fdh;
4826
4827   if (eh->elf.root.type == bfd_link_hash_indirect)
4828     return TRUE;
4829
4830   if (eh->elf.root.type == bfd_link_hash_warning)
4831     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4832
4833   if (eh->elf.root.root.string[0] != '.')
4834     abort ();
4835
4836   htab = ppc_hash_table (info);
4837   if (htab == NULL)
4838     return FALSE;
4839
4840   fdh = lookup_fdh (eh, htab);
4841   if (fdh == NULL)
4842     {
4843       if (!info->relocatable
4844           && (eh->elf.root.type == bfd_link_hash_undefined
4845               || eh->elf.root.type == bfd_link_hash_undefweak)
4846           && eh->elf.ref_regular)
4847         {
4848           /* Make an undefweak function descriptor sym, which is enough to
4849              pull in an --as-needed shared lib, but won't cause link
4850              errors.  Archives are handled elsewhere.  */
4851           fdh = make_fdh (info, eh);
4852           if (fdh == NULL)
4853             return FALSE;
4854           fdh->elf.ref_regular = 1;
4855         }
4856     }
4857   else
4858     {
4859       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4860       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4861       if (entry_vis < descr_vis)
4862         fdh->elf.other += entry_vis - descr_vis;
4863       else if (entry_vis > descr_vis)
4864         eh->elf.other += descr_vis - entry_vis;
4865
4866       if ((fdh->elf.root.type == bfd_link_hash_defined
4867            || fdh->elf.root.type == bfd_link_hash_defweak)
4868           && eh->elf.root.type == bfd_link_hash_undefined)
4869         {
4870           eh->elf.root.type = bfd_link_hash_undefweak;
4871           eh->was_undefined = 1;
4872           htab->twiddled_syms = 1;
4873         }
4874     }
4875
4876   return TRUE;
4877 }
4878
4879 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4880
4881 static bfd_boolean
4882 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4883 {
4884   struct ppc_link_hash_table *htab;
4885   struct ppc_link_hash_entry **p, *eh;
4886
4887   if (!is_ppc64_elf (info->output_bfd))
4888     return TRUE;
4889   htab = ppc_hash_table (info);
4890   if (htab == NULL)
4891     return FALSE;
4892
4893   if (is_ppc64_elf (ibfd))
4894     {
4895       p = &htab->dot_syms;
4896       while ((eh = *p) != NULL)
4897         {
4898           *p = NULL;
4899           if (&eh->elf == htab->elf.hgot)
4900             ;
4901           else if (htab->elf.hgot == NULL
4902                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4903             htab->elf.hgot = &eh->elf;
4904           else if (!add_symbol_adjust (eh, info))
4905             return FALSE;
4906           p = &eh->u.next_dot_sym;
4907         }
4908     }
4909
4910   /* Clear the list for non-ppc64 input files.  */
4911   p = &htab->dot_syms;
4912   while ((eh = *p) != NULL)
4913     {
4914       *p = NULL;
4915       p = &eh->u.next_dot_sym;
4916     }
4917
4918   /* We need to fix the undefs list for any syms we have twiddled to
4919      undef_weak.  */
4920   if (htab->twiddled_syms)
4921     {
4922       bfd_link_repair_undef_list (&htab->elf.root);
4923       htab->twiddled_syms = 0;
4924     }
4925   return TRUE;
4926 }
4927
4928 /* Undo hash table changes when an --as-needed input file is determined
4929    not to be needed.  */
4930
4931 static bfd_boolean
4932 ppc64_elf_notice_as_needed (bfd *ibfd,
4933                             struct bfd_link_info *info,
4934                             enum notice_asneeded_action act)
4935 {
4936   if (act == notice_not_needed)
4937     {
4938       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4939
4940       if (htab == NULL)
4941         return FALSE;
4942
4943       htab->dot_syms = NULL;
4944     }
4945   return _bfd_elf_notice_as_needed (ibfd, info, act);
4946 }
4947
4948 /* If --just-symbols against a final linked binary, then assume we need
4949    toc adjusting stubs when calling functions defined there.  */
4950
4951 static void
4952 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4953 {
4954   if ((sec->flags & SEC_CODE) != 0
4955       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4956       && is_ppc64_elf (sec->owner))
4957     {
4958       asection *got = bfd_get_section_by_name (sec->owner, ".got");
4959       if (got != NULL
4960           && got->size >= elf_backend_got_header_size
4961           && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4962         sec->has_toc_reloc = 1;
4963     }
4964   _bfd_elf_link_just_syms (sec, info);
4965 }
4966
4967 static struct plt_entry **
4968 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4969                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4970 {
4971   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4972   struct plt_entry **local_plt;
4973   unsigned char *local_got_tls_masks;
4974
4975   if (local_got_ents == NULL)
4976     {
4977       bfd_size_type size = symtab_hdr->sh_info;
4978
4979       size *= (sizeof (*local_got_ents)
4980                + sizeof (*local_plt)
4981                + sizeof (*local_got_tls_masks));
4982       local_got_ents = bfd_zalloc (abfd, size);
4983       if (local_got_ents == NULL)
4984         return NULL;
4985       elf_local_got_ents (abfd) = local_got_ents;
4986     }
4987
4988   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4989     {
4990       struct got_entry *ent;
4991
4992       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4993         if (ent->addend == r_addend
4994             && ent->owner == abfd
4995             && ent->tls_type == tls_type)
4996           break;
4997       if (ent == NULL)
4998         {
4999           bfd_size_type amt = sizeof (*ent);
5000           ent = bfd_alloc (abfd, amt);
5001           if (ent == NULL)
5002             return FALSE;
5003           ent->next = local_got_ents[r_symndx];
5004           ent->addend = r_addend;
5005           ent->owner = abfd;
5006           ent->tls_type = tls_type;
5007           ent->is_indirect = FALSE;
5008           ent->got.refcount = 0;
5009           local_got_ents[r_symndx] = ent;
5010         }
5011       ent->got.refcount += 1;
5012     }
5013
5014   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5015   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5016   local_got_tls_masks[r_symndx] |= tls_type;
5017
5018   return local_plt + r_symndx;
5019 }
5020
5021 static bfd_boolean
5022 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5023 {
5024   struct plt_entry *ent;
5025
5026   for (ent = *plist; ent != NULL; ent = ent->next)
5027     if (ent->addend == addend)
5028       break;
5029   if (ent == NULL)
5030     {
5031       bfd_size_type amt = sizeof (*ent);
5032       ent = bfd_alloc (abfd, amt);
5033       if (ent == NULL)
5034         return FALSE;
5035       ent->next = *plist;
5036       ent->addend = addend;
5037       ent->plt.refcount = 0;
5038       *plist = ent;
5039     }
5040   ent->plt.refcount += 1;
5041   return TRUE;
5042 }
5043
5044 static bfd_boolean
5045 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5046 {
5047   return (r_type == R_PPC64_REL24
5048           || r_type == R_PPC64_REL14
5049           || r_type == R_PPC64_REL14_BRTAKEN
5050           || r_type == R_PPC64_REL14_BRNTAKEN
5051           || r_type == R_PPC64_ADDR24
5052           || r_type == R_PPC64_ADDR14
5053           || r_type == R_PPC64_ADDR14_BRTAKEN
5054           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5055 }
5056
5057 /* Look through the relocs for a section during the first phase, and
5058    calculate needed space in the global offset table, procedure
5059    linkage table, and dynamic reloc sections.  */
5060
5061 static bfd_boolean
5062 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5063                         asection *sec, const Elf_Internal_Rela *relocs)
5064 {
5065   struct ppc_link_hash_table *htab;
5066   Elf_Internal_Shdr *symtab_hdr;
5067   struct elf_link_hash_entry **sym_hashes;
5068   const Elf_Internal_Rela *rel;
5069   const Elf_Internal_Rela *rel_end;
5070   asection *sreloc;
5071   asection **opd_sym_map;
5072   struct elf_link_hash_entry *tga, *dottga;
5073
5074   if (info->relocatable)
5075     return TRUE;
5076
5077   /* Don't do anything special with non-loaded, non-alloced sections.
5078      In particular, any relocs in such sections should not affect GOT
5079      and PLT reference counting (ie. we don't allow them to create GOT
5080      or PLT entries), there's no possibility or desire to optimize TLS
5081      relocs, and there's not much point in propagating relocs to shared
5082      libs that the dynamic linker won't relocate.  */
5083   if ((sec->flags & SEC_ALLOC) == 0)
5084     return TRUE;
5085
5086   BFD_ASSERT (is_ppc64_elf (abfd));
5087
5088   htab = ppc_hash_table (info);
5089   if (htab == NULL)
5090     return FALSE;
5091
5092   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5093                               FALSE, FALSE, TRUE);
5094   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5095                                  FALSE, FALSE, TRUE);
5096   symtab_hdr = &elf_symtab_hdr (abfd);
5097   sym_hashes = elf_sym_hashes (abfd);
5098   sreloc = NULL;
5099   opd_sym_map = NULL;
5100   if (strcmp (sec->name, ".opd") == 0)
5101     {
5102       /* Garbage collection needs some extra help with .opd sections.
5103          We don't want to necessarily keep everything referenced by
5104          relocs in .opd, as that would keep all functions.  Instead,
5105          if we reference an .opd symbol (a function descriptor), we
5106          want to keep the function code symbol's section.  This is
5107          easy for global symbols, but for local syms we need to keep
5108          information about the associated function section.  */
5109       bfd_size_type amt;
5110
5111       if (abiversion (abfd) == 0)
5112         set_abiversion (abfd, 1);
5113       else if (abiversion (abfd) == 2)
5114         {
5115           info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5116                                   abiversion (abfd));
5117           bfd_set_error (bfd_error_bad_value);
5118           return FALSE;
5119         }
5120       amt = sec->size * sizeof (*opd_sym_map) / 8;
5121       opd_sym_map = bfd_zalloc (abfd, amt);
5122       if (opd_sym_map == NULL)
5123         return FALSE;
5124       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5125       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5126       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5127     }
5128
5129   rel_end = relocs + sec->reloc_count;
5130   for (rel = relocs; rel < rel_end; rel++)
5131     {
5132       unsigned long r_symndx;
5133       struct elf_link_hash_entry *h;
5134       enum elf_ppc64_reloc_type r_type;
5135       int tls_type;
5136       struct _ppc64_elf_section_data *ppc64_sec;
5137       struct plt_entry **ifunc;
5138
5139       r_symndx = ELF64_R_SYM (rel->r_info);
5140       if (r_symndx < symtab_hdr->sh_info)
5141         h = NULL;
5142       else
5143         {
5144           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5145           h = elf_follow_link (h);
5146
5147           /* PR15323, ref flags aren't set for references in the same
5148              object.  */
5149           h->root.non_ir_ref = 1;
5150
5151           if (h == htab->elf.hgot)
5152             sec->has_toc_reloc = 1;
5153         }
5154
5155       tls_type = 0;
5156       ifunc = NULL;
5157       if (h != NULL)
5158         {
5159           if (h->type == STT_GNU_IFUNC)
5160             {
5161               h->needs_plt = 1;
5162               ifunc = &h->plt.plist;
5163             }
5164         }
5165       else
5166         {
5167           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5168                                                           abfd, r_symndx);
5169           if (isym == NULL)
5170             return FALSE;
5171
5172           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5173             {
5174               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5175                                              rel->r_addend, PLT_IFUNC);
5176               if (ifunc == NULL)
5177                 return FALSE;
5178             }
5179         }
5180       r_type = ELF64_R_TYPE (rel->r_info);
5181       if (is_branch_reloc (r_type))
5182         {
5183           if (h != NULL && (h == tga || h == dottga))
5184             {
5185               if (rel != relocs
5186                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5187                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5188                 /* We have a new-style __tls_get_addr call with a marker
5189                    reloc.  */
5190                 ;
5191               else
5192                 /* Mark this section as having an old-style call.  */
5193                 sec->has_tls_get_addr_call = 1;
5194             }
5195
5196           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5197           if (ifunc != NULL
5198               && !update_plt_info (abfd, ifunc, rel->r_addend))
5199             return FALSE;
5200         }
5201
5202       switch (r_type)
5203         {
5204         case R_PPC64_TLSGD:
5205         case R_PPC64_TLSLD:
5206           /* These special tls relocs tie a call to __tls_get_addr with
5207              its parameter symbol.  */
5208           break;
5209
5210         case R_PPC64_GOT_TLSLD16:
5211         case R_PPC64_GOT_TLSLD16_LO:
5212         case R_PPC64_GOT_TLSLD16_HI:
5213         case R_PPC64_GOT_TLSLD16_HA:
5214           tls_type = TLS_TLS | TLS_LD;
5215           goto dogottls;
5216
5217         case R_PPC64_GOT_TLSGD16:
5218         case R_PPC64_GOT_TLSGD16_LO:
5219         case R_PPC64_GOT_TLSGD16_HI:
5220         case R_PPC64_GOT_TLSGD16_HA:
5221           tls_type = TLS_TLS | TLS_GD;
5222           goto dogottls;
5223
5224         case R_PPC64_GOT_TPREL16_DS:
5225         case R_PPC64_GOT_TPREL16_LO_DS:
5226         case R_PPC64_GOT_TPREL16_HI:
5227         case R_PPC64_GOT_TPREL16_HA:
5228           if (!info->executable)
5229             info->flags |= DF_STATIC_TLS;
5230           tls_type = TLS_TLS | TLS_TPREL;
5231           goto dogottls;
5232
5233         case R_PPC64_GOT_DTPREL16_DS:
5234         case R_PPC64_GOT_DTPREL16_LO_DS:
5235         case R_PPC64_GOT_DTPREL16_HI:
5236         case R_PPC64_GOT_DTPREL16_HA:
5237           tls_type = TLS_TLS | TLS_DTPREL;
5238         dogottls:
5239           sec->has_tls_reloc = 1;
5240           /* Fall thru */
5241
5242         case R_PPC64_GOT16:
5243         case R_PPC64_GOT16_DS:
5244         case R_PPC64_GOT16_HA:
5245         case R_PPC64_GOT16_HI:
5246         case R_PPC64_GOT16_LO:
5247         case R_PPC64_GOT16_LO_DS:
5248           /* This symbol requires a global offset table entry.  */
5249           sec->has_toc_reloc = 1;
5250           if (r_type == R_PPC64_GOT_TLSLD16
5251               || r_type == R_PPC64_GOT_TLSGD16
5252               || r_type == R_PPC64_GOT_TPREL16_DS
5253               || r_type == R_PPC64_GOT_DTPREL16_DS
5254               || r_type == R_PPC64_GOT16
5255               || r_type == R_PPC64_GOT16_DS)
5256             {
5257               htab->do_multi_toc = 1;
5258               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5259             }
5260
5261           if (ppc64_elf_tdata (abfd)->got == NULL
5262               && !create_got_section (abfd, info))
5263             return FALSE;
5264
5265           if (h != NULL)
5266             {
5267               struct ppc_link_hash_entry *eh;
5268               struct got_entry *ent;
5269
5270               eh = (struct ppc_link_hash_entry *) h;
5271               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5272                 if (ent->addend == rel->r_addend
5273                     && ent->owner == abfd
5274                     && ent->tls_type == tls_type)
5275                   break;
5276               if (ent == NULL)
5277                 {
5278                   bfd_size_type amt = sizeof (*ent);
5279                   ent = bfd_alloc (abfd, amt);
5280                   if (ent == NULL)
5281                     return FALSE;
5282                   ent->next = eh->elf.got.glist;
5283                   ent->addend = rel->r_addend;
5284                   ent->owner = abfd;
5285                   ent->tls_type = tls_type;
5286                   ent->is_indirect = FALSE;
5287                   ent->got.refcount = 0;
5288                   eh->elf.got.glist = ent;
5289                 }
5290               ent->got.refcount += 1;
5291               eh->tls_mask |= tls_type;
5292             }
5293           else
5294             /* This is a global offset table entry for a local symbol.  */
5295             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5296                                         rel->r_addend, tls_type))
5297               return FALSE;
5298           break;
5299
5300         case R_PPC64_PLT16_HA:
5301         case R_PPC64_PLT16_HI:
5302         case R_PPC64_PLT16_LO:
5303         case R_PPC64_PLT32:
5304         case R_PPC64_PLT64:
5305           /* This symbol requires a procedure linkage table entry.  We
5306              actually build the entry in adjust_dynamic_symbol,
5307              because this might be a case of linking PIC code without
5308              linking in any dynamic objects, in which case we don't
5309              need to generate a procedure linkage table after all.  */
5310           if (h == NULL)
5311             {
5312               /* It does not make sense to have a procedure linkage
5313                  table entry for a local symbol.  */
5314               bfd_set_error (bfd_error_bad_value);
5315               return FALSE;
5316             }
5317           else
5318             {
5319               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5320                 return FALSE;
5321               h->needs_plt = 1;
5322               if (h->root.root.string[0] == '.'
5323                   && h->root.root.string[1] != '\0')
5324                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5325             }
5326           break;
5327
5328           /* The following relocations don't need to propagate the
5329              relocation if linking a shared object since they are
5330              section relative.  */
5331         case R_PPC64_SECTOFF:
5332         case R_PPC64_SECTOFF_LO:
5333         case R_PPC64_SECTOFF_HI:
5334         case R_PPC64_SECTOFF_HA:
5335         case R_PPC64_SECTOFF_DS:
5336         case R_PPC64_SECTOFF_LO_DS:
5337         case R_PPC64_DTPREL16:
5338         case R_PPC64_DTPREL16_LO:
5339         case R_PPC64_DTPREL16_HI:
5340         case R_PPC64_DTPREL16_HA:
5341         case R_PPC64_DTPREL16_DS:
5342         case R_PPC64_DTPREL16_LO_DS:
5343         case R_PPC64_DTPREL16_HIGH:
5344         case R_PPC64_DTPREL16_HIGHA:
5345         case R_PPC64_DTPREL16_HIGHER:
5346         case R_PPC64_DTPREL16_HIGHERA:
5347         case R_PPC64_DTPREL16_HIGHEST:
5348         case R_PPC64_DTPREL16_HIGHESTA:
5349           break;
5350
5351           /* Nor do these.  */
5352         case R_PPC64_REL16:
5353         case R_PPC64_REL16_LO:
5354         case R_PPC64_REL16_HI:
5355         case R_PPC64_REL16_HA:
5356           break;
5357
5358         case R_PPC64_TOC16:
5359         case R_PPC64_TOC16_DS:
5360           htab->do_multi_toc = 1;
5361           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5362         case R_PPC64_TOC16_LO:
5363         case R_PPC64_TOC16_HI:
5364         case R_PPC64_TOC16_HA:
5365         case R_PPC64_TOC16_LO_DS:
5366           sec->has_toc_reloc = 1;
5367           break;
5368
5369           /* This relocation describes the C++ object vtable hierarchy.
5370              Reconstruct it for later use during GC.  */
5371         case R_PPC64_GNU_VTINHERIT:
5372           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5373             return FALSE;
5374           break;
5375
5376           /* This relocation describes which C++ vtable entries are actually
5377              used.  Record for later use during GC.  */
5378         case R_PPC64_GNU_VTENTRY:
5379           BFD_ASSERT (h != NULL);
5380           if (h != NULL
5381               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5382             return FALSE;
5383           break;
5384
5385         case R_PPC64_REL14:
5386         case R_PPC64_REL14_BRTAKEN:
5387         case R_PPC64_REL14_BRNTAKEN:
5388           {
5389             asection *dest = NULL;
5390
5391             /* Heuristic: If jumping outside our section, chances are
5392                we are going to need a stub.  */
5393             if (h != NULL)
5394               {
5395                 /* If the sym is weak it may be overridden later, so
5396                    don't assume we know where a weak sym lives.  */
5397                 if (h->root.type == bfd_link_hash_defined)
5398                   dest = h->root.u.def.section;
5399               }
5400             else
5401               {
5402                 Elf_Internal_Sym *isym;
5403
5404                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5405                                               abfd, r_symndx);
5406                 if (isym == NULL)
5407                   return FALSE;
5408
5409                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5410               }
5411
5412             if (dest != sec)
5413               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5414           }
5415           /* Fall through.  */
5416
5417         case R_PPC64_REL24:
5418           if (h != NULL && ifunc == NULL)
5419             {
5420               /* We may need a .plt entry if the function this reloc
5421                  refers to is in a shared lib.  */
5422               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5423                 return FALSE;
5424               h->needs_plt = 1;
5425               if (h->root.root.string[0] == '.'
5426                   && h->root.root.string[1] != '\0')
5427                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5428               if (h == tga || h == dottga)
5429                 sec->has_tls_reloc = 1;
5430             }
5431           break;
5432
5433         case R_PPC64_TPREL64:
5434           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5435           if (!info->executable)
5436             info->flags |= DF_STATIC_TLS;
5437           goto dotlstoc;
5438
5439         case R_PPC64_DTPMOD64:
5440           if (rel + 1 < rel_end
5441               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5442               && rel[1].r_offset == rel->r_offset + 8)
5443             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5444           else
5445             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5446           goto dotlstoc;
5447
5448         case R_PPC64_DTPREL64:
5449           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5450           if (rel != relocs
5451               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5452               && rel[-1].r_offset == rel->r_offset - 8)
5453             /* This is the second reloc of a dtpmod, dtprel pair.
5454                Don't mark with TLS_DTPREL.  */
5455             goto dodyn;
5456
5457         dotlstoc:
5458           sec->has_tls_reloc = 1;
5459           if (h != NULL)
5460             {
5461               struct ppc_link_hash_entry *eh;
5462               eh = (struct ppc_link_hash_entry *) h;
5463               eh->tls_mask |= tls_type;
5464             }
5465           else
5466             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5467                                         rel->r_addend, tls_type))
5468               return FALSE;
5469
5470           ppc64_sec = ppc64_elf_section_data (sec);
5471           if (ppc64_sec->sec_type != sec_toc)
5472             {
5473               bfd_size_type amt;
5474
5475               /* One extra to simplify get_tls_mask.  */
5476               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5477               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5478               if (ppc64_sec->u.toc.symndx == NULL)
5479                 return FALSE;
5480               amt = sec->size * sizeof (bfd_vma) / 8;
5481               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5482               if (ppc64_sec->u.toc.add == NULL)
5483                 return FALSE;
5484               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5485               ppc64_sec->sec_type = sec_toc;
5486             }
5487           BFD_ASSERT (rel->r_offset % 8 == 0);
5488           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5489           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5490
5491           /* Mark the second slot of a GD or LD entry.
5492              -1 to indicate GD and -2 to indicate LD.  */
5493           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5494             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5495           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5496             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5497           goto dodyn;
5498
5499         case R_PPC64_TPREL16:
5500         case R_PPC64_TPREL16_LO:
5501         case R_PPC64_TPREL16_HI:
5502         case R_PPC64_TPREL16_HA:
5503         case R_PPC64_TPREL16_DS:
5504         case R_PPC64_TPREL16_LO_DS:
5505         case R_PPC64_TPREL16_HIGH:
5506         case R_PPC64_TPREL16_HIGHA:
5507         case R_PPC64_TPREL16_HIGHER:
5508         case R_PPC64_TPREL16_HIGHERA:
5509         case R_PPC64_TPREL16_HIGHEST:
5510         case R_PPC64_TPREL16_HIGHESTA:
5511           if (info->shared)
5512             {
5513               if (!info->executable)
5514                 info->flags |= DF_STATIC_TLS;
5515               goto dodyn;
5516             }
5517           break;
5518
5519         case R_PPC64_ADDR64:
5520           if (opd_sym_map != NULL
5521               && rel + 1 < rel_end
5522               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5523             {
5524               if (h != NULL)
5525                 {
5526                   if (h->root.root.string[0] == '.'
5527                       && h->root.root.string[1] != 0
5528                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5529                     ;
5530                   else
5531                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5532                 }
5533               else
5534                 {
5535                   asection *s;
5536                   Elf_Internal_Sym *isym;
5537
5538                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5539                                                 abfd, r_symndx);
5540                   if (isym == NULL)
5541                     return FALSE;
5542
5543                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5544                   if (s != NULL && s != sec)
5545                     opd_sym_map[rel->r_offset / 8] = s;
5546                 }
5547             }
5548           /* Fall through.  */
5549
5550         case R_PPC64_REL30:
5551         case R_PPC64_REL32:
5552         case R_PPC64_REL64:
5553         case R_PPC64_ADDR14:
5554         case R_PPC64_ADDR14_BRNTAKEN:
5555         case R_PPC64_ADDR14_BRTAKEN:
5556         case R_PPC64_ADDR16:
5557         case R_PPC64_ADDR16_DS:
5558         case R_PPC64_ADDR16_HA:
5559         case R_PPC64_ADDR16_HI:
5560         case R_PPC64_ADDR16_HIGH:
5561         case R_PPC64_ADDR16_HIGHA:
5562         case R_PPC64_ADDR16_HIGHER:
5563         case R_PPC64_ADDR16_HIGHERA:
5564         case R_PPC64_ADDR16_HIGHEST:
5565         case R_PPC64_ADDR16_HIGHESTA:
5566         case R_PPC64_ADDR16_LO:
5567         case R_PPC64_ADDR16_LO_DS:
5568         case R_PPC64_ADDR24:
5569         case R_PPC64_ADDR32:
5570         case R_PPC64_UADDR16:
5571         case R_PPC64_UADDR32:
5572         case R_PPC64_UADDR64:
5573         case R_PPC64_TOC:
5574           if (h != NULL && !info->shared)
5575             /* We may need a copy reloc.  */
5576             h->non_got_ref = 1;
5577
5578           /* Don't propagate .opd relocs.  */
5579           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5580             break;
5581
5582           /* If we are creating a shared library, and this is a reloc
5583              against a global symbol, or a non PC relative reloc
5584              against a local symbol, then we need to copy the reloc
5585              into the shared library.  However, if we are linking with
5586              -Bsymbolic, we do not need to copy a reloc against a
5587              global symbol which is defined in an object we are
5588              including in the link (i.e., DEF_REGULAR is set).  At
5589              this point we have not seen all the input files, so it is
5590              possible that DEF_REGULAR is not set now but will be set
5591              later (it is never cleared).  In case of a weak definition,
5592              DEF_REGULAR may be cleared later by a strong definition in
5593              a shared library.  We account for that possibility below by
5594              storing information in the dyn_relocs field of the hash
5595              table entry.  A similar situation occurs when creating
5596              shared libraries and symbol visibility changes render the
5597              symbol local.
5598
5599              If on the other hand, we are creating an executable, we
5600              may need to keep relocations for symbols satisfied by a
5601              dynamic library if we manage to avoid copy relocs for the
5602              symbol.  */
5603         dodyn:
5604           if ((info->shared
5605                && (must_be_dyn_reloc (info, r_type)
5606                    || (h != NULL
5607                        && (!SYMBOLIC_BIND (info, h)
5608                            || h->root.type == bfd_link_hash_defweak
5609                            || !h->def_regular))))
5610               || (ELIMINATE_COPY_RELOCS
5611                   && !info->shared
5612                   && h != NULL
5613                   && (h->root.type == bfd_link_hash_defweak
5614                       || !h->def_regular))
5615               || (!info->shared
5616                   && ifunc != NULL))
5617             {
5618               /* We must copy these reloc types into the output file.
5619                  Create a reloc section in dynobj and make room for
5620                  this reloc.  */
5621               if (sreloc == NULL)
5622                 {
5623                   sreloc = _bfd_elf_make_dynamic_reloc_section
5624                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5625
5626                   if (sreloc == NULL)
5627                     return FALSE;
5628                 }
5629
5630               /* If this is a global symbol, we count the number of
5631                  relocations we need for this symbol.  */
5632               if (h != NULL)
5633                 {
5634                   struct elf_dyn_relocs *p;
5635                   struct elf_dyn_relocs **head;
5636
5637                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5638                   p = *head;
5639                   if (p == NULL || p->sec != sec)
5640                     {
5641                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5642                       if (p == NULL)
5643                         return FALSE;
5644                       p->next = *head;
5645                       *head = p;
5646                       p->sec = sec;
5647                       p->count = 0;
5648                       p->pc_count = 0;
5649                     }
5650                   p->count += 1;
5651                   if (!must_be_dyn_reloc (info, r_type))
5652                     p->pc_count += 1;
5653                 }
5654               else
5655                 {
5656                   /* Track dynamic relocs needed for local syms too.
5657                      We really need local syms available to do this
5658                      easily.  Oh well.  */
5659                   struct ppc_dyn_relocs *p;
5660                   struct ppc_dyn_relocs **head;
5661                   bfd_boolean is_ifunc;
5662                   asection *s;
5663                   void *vpp;
5664                   Elf_Internal_Sym *isym;
5665
5666                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5667                                                 abfd, r_symndx);
5668                   if (isym == NULL)
5669                     return FALSE;
5670
5671                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5672                   if (s == NULL)
5673                     s = sec;
5674
5675                   vpp = &elf_section_data (s)->local_dynrel;
5676                   head = (struct ppc_dyn_relocs **) vpp;
5677                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5678                   p = *head;
5679                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5680                     p = p->next;
5681                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5682                     {
5683                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5684                       if (p == NULL)
5685                         return FALSE;
5686                       p->next = *head;
5687                       *head = p;
5688                       p->sec = sec;
5689                       p->ifunc = is_ifunc;
5690                       p->count = 0;
5691                     }
5692                   p->count += 1;
5693                 }
5694             }
5695           break;
5696
5697         default:
5698           break;
5699         }
5700     }
5701
5702   return TRUE;
5703 }
5704
5705 /* Merge backend specific data from an object file to the output
5706    object file when linking.  */
5707
5708 static bfd_boolean
5709 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5710 {
5711   unsigned long iflags, oflags;
5712
5713   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5714     return TRUE;
5715
5716   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5717     return TRUE;
5718
5719   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5720     return FALSE;
5721
5722   iflags = elf_elfheader (ibfd)->e_flags;
5723   oflags = elf_elfheader (obfd)->e_flags;
5724
5725   if (!elf_flags_init (obfd) || oflags == 0)
5726     {
5727       elf_flags_init (obfd) = TRUE;
5728       elf_elfheader (obfd)->e_flags = iflags;
5729     }
5730   else if (iflags == oflags || iflags == 0)
5731     ;
5732   else if (iflags & ~EF_PPC64_ABI)
5733     {
5734       (*_bfd_error_handler)
5735         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5736       bfd_set_error (bfd_error_bad_value);
5737       return FALSE;
5738     }
5739   else
5740     {
5741       (*_bfd_error_handler)
5742         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5743          ibfd, iflags, oflags);
5744       bfd_set_error (bfd_error_bad_value);
5745       return FALSE;
5746     }
5747
5748   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5749   _bfd_elf_merge_object_attributes (ibfd, obfd);
5750
5751   return TRUE;
5752 }
5753
5754 static bfd_boolean
5755 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5756 {
5757   /* Print normal ELF private data.  */
5758   _bfd_elf_print_private_bfd_data (abfd, ptr);
5759
5760   if (elf_elfheader (abfd)->e_flags != 0)
5761     {
5762       FILE *file = ptr;
5763
5764       /* xgettext:c-format */
5765       fprintf (file, _("private flags = 0x%lx:"),
5766                elf_elfheader (abfd)->e_flags);
5767
5768       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5769         fprintf (file, _(" [abiv%ld]"),
5770                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5771       fputc ('\n', file);
5772     }
5773
5774   return TRUE;
5775 }
5776
5777 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5778    of the code entry point, and its section.  */
5779
5780 static bfd_vma
5781 opd_entry_value (asection *opd_sec,
5782                  bfd_vma offset,
5783                  asection **code_sec,
5784                  bfd_vma *code_off,
5785                  bfd_boolean in_code_sec)
5786 {
5787   bfd *opd_bfd = opd_sec->owner;
5788   Elf_Internal_Rela *relocs;
5789   Elf_Internal_Rela *lo, *hi, *look;
5790   bfd_vma val;
5791
5792   /* No relocs implies we are linking a --just-symbols object, or looking
5793      at a final linked executable with addr2line or somesuch.  */
5794   if (opd_sec->reloc_count == 0)
5795     {
5796       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5797
5798       if (contents == NULL)
5799         {
5800           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5801             return (bfd_vma) -1;
5802           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5803         }
5804
5805       val = bfd_get_64 (opd_bfd, contents + offset);
5806       if (code_sec != NULL)
5807         {
5808           asection *sec, *likely = NULL;
5809
5810           if (in_code_sec)
5811             {
5812               sec = *code_sec;
5813               if (sec->vma <= val
5814                   && val < sec->vma + sec->size)
5815                 likely = sec;
5816               else
5817                 val = -1;
5818             }
5819           else
5820             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5821               if (sec->vma <= val
5822                   && (sec->flags & SEC_LOAD) != 0
5823                   && (sec->flags & SEC_ALLOC) != 0)
5824                 likely = sec;
5825           if (likely != NULL)
5826             {
5827               *code_sec = likely;
5828               if (code_off != NULL)
5829                 *code_off = val - likely->vma;
5830             }
5831         }
5832       return val;
5833     }
5834
5835   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5836
5837   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5838   if (relocs == NULL)
5839     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5840
5841   /* Go find the opd reloc at the sym address.  */
5842   lo = relocs;
5843   BFD_ASSERT (lo != NULL);
5844   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5845   val = (bfd_vma) -1;
5846   while (lo < hi)
5847     {
5848       look = lo + (hi - lo) / 2;
5849       if (look->r_offset < offset)
5850         lo = look + 1;
5851       else if (look->r_offset > offset)
5852         hi = look;
5853       else
5854         {
5855           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5856
5857           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5858               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5859             {
5860               unsigned long symndx = ELF64_R_SYM (look->r_info);
5861               asection *sec;
5862
5863               if (symndx < symtab_hdr->sh_info
5864                   || elf_sym_hashes (opd_bfd) == NULL)
5865                 {
5866                   Elf_Internal_Sym *sym;
5867
5868                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5869                   if (sym == NULL)
5870                     {
5871                       size_t symcnt = symtab_hdr->sh_info;
5872                       if (elf_sym_hashes (opd_bfd) == NULL)
5873                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5874                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5875                                                   0, NULL, NULL, NULL);
5876                       if (sym == NULL)
5877                         break;
5878                       symtab_hdr->contents = (bfd_byte *) sym;
5879                     }
5880
5881                   sym += symndx;
5882                   val = sym->st_value;
5883                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5884                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5885                 }
5886               else
5887                 {
5888                   struct elf_link_hash_entry **sym_hashes;
5889                   struct elf_link_hash_entry *rh;
5890
5891                   sym_hashes = elf_sym_hashes (opd_bfd);
5892                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5893                   if (rh != NULL)
5894                     {
5895                       rh = elf_follow_link (rh);
5896                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5897                                   || rh->root.type == bfd_link_hash_defweak);
5898                       val = rh->root.u.def.value;
5899                       sec = rh->root.u.def.section;
5900                     }
5901                   else
5902                     {
5903                       /* Handle the odd case where we can be called
5904                          during bfd_elf_link_add_symbols before the
5905                          symbol hashes have been fully populated.  */
5906                       Elf_Internal_Sym *sym;
5907
5908                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5909                                                   symndx, NULL, NULL, NULL);
5910                       if (sym == NULL)
5911                         break;
5912
5913                       val = sym->st_value;
5914                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5915                       free (sym);
5916                     }
5917                 }
5918               val += look->r_addend;
5919               if (code_off != NULL)
5920                 *code_off = val;
5921               if (code_sec != NULL)
5922                 {
5923                   if (in_code_sec && *code_sec != sec)
5924                     return -1;
5925                   else
5926                     *code_sec = sec;
5927                 }
5928               if (sec != NULL && sec->output_section != NULL)
5929                 val += sec->output_section->vma + sec->output_offset;
5930             }
5931           break;
5932         }
5933     }
5934
5935   return val;
5936 }
5937
5938 /* If the ELF symbol SYM might be a function in SEC, return the
5939    function size and set *CODE_OFF to the function's entry point,
5940    otherwise return zero.  */
5941
5942 static bfd_size_type
5943 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5944                               bfd_vma *code_off)
5945 {
5946   bfd_size_type size;
5947
5948   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5949                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5950     return 0;
5951
5952   size = 0;
5953   if (!(sym->flags & BSF_SYNTHETIC))
5954     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5955
5956   if (strcmp (sym->section->name, ".opd") == 0)
5957     {
5958       if (opd_entry_value (sym->section, sym->value,
5959                            &sec, code_off, TRUE) == (bfd_vma) -1)
5960         return 0;
5961       /* An old ABI binary with dot-syms has a size of 24 on the .opd
5962          symbol.  This size has nothing to do with the code size of the
5963          function, which is what we're supposed to return, but the
5964          code size isn't available without looking up the dot-sym.
5965          However, doing that would be a waste of time particularly
5966          since elf_find_function will look at the dot-sym anyway.
5967          Now, elf_find_function will keep the largest size of any
5968          function sym found at the code address of interest, so return
5969          1 here to avoid it incorrectly caching a larger function size
5970          for a small function.  This does mean we return the wrong
5971          size for a new-ABI function of size 24, but all that does is
5972          disable caching for such functions.  */
5973       if (size == 24)
5974         size = 1;
5975     }
5976   else
5977     {
5978       if (sym->section != sec)
5979         return 0;
5980       *code_off = sym->value;
5981     }
5982   if (size == 0)
5983     size = 1;
5984   return size;
5985 }
5986
5987 /* Return true if symbol is defined in a regular object file.  */
5988
5989 static bfd_boolean
5990 is_static_defined (struct elf_link_hash_entry *h)
5991 {
5992   return ((h->root.type == bfd_link_hash_defined
5993            || h->root.type == bfd_link_hash_defweak)
5994           && h->root.u.def.section != NULL
5995           && h->root.u.def.section->output_section != NULL);
5996 }
5997
5998 /* If FDH is a function descriptor symbol, return the associated code
5999    entry symbol if it is defined.  Return NULL otherwise.  */
6000
6001 static struct ppc_link_hash_entry *
6002 defined_code_entry (struct ppc_link_hash_entry *fdh)
6003 {
6004   if (fdh->is_func_descriptor)
6005     {
6006       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6007       if (fh->elf.root.type == bfd_link_hash_defined
6008           || fh->elf.root.type == bfd_link_hash_defweak)
6009         return fh;
6010     }
6011   return NULL;
6012 }
6013
6014 /* If FH is a function code entry symbol, return the associated
6015    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6016
6017 static struct ppc_link_hash_entry *
6018 defined_func_desc (struct ppc_link_hash_entry *fh)
6019 {
6020   if (fh->oh != NULL
6021       && fh->oh->is_func_descriptor)
6022     {
6023       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6024       if (fdh->elf.root.type == bfd_link_hash_defined
6025           || fdh->elf.root.type == bfd_link_hash_defweak)
6026         return fdh;
6027     }
6028   return NULL;
6029 }
6030
6031 /* Mark all our entry sym sections, both opd and code section.  */
6032
6033 static void
6034 ppc64_elf_gc_keep (struct bfd_link_info *info)
6035 {
6036   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6037   struct bfd_sym_chain *sym;
6038
6039   if (htab == NULL)
6040     return;
6041
6042   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6043     {
6044       struct ppc_link_hash_entry *eh, *fh;
6045       asection *sec;
6046
6047       eh = (struct ppc_link_hash_entry *)
6048         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6049       if (eh == NULL)
6050         continue;
6051       if (eh->elf.root.type != bfd_link_hash_defined
6052           && eh->elf.root.type != bfd_link_hash_defweak)
6053         continue;
6054
6055       fh = defined_code_entry (eh);
6056       if (fh != NULL)
6057         {
6058           sec = fh->elf.root.u.def.section;
6059           sec->flags |= SEC_KEEP;
6060         }
6061       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6062                && opd_entry_value (eh->elf.root.u.def.section,
6063                                    eh->elf.root.u.def.value,
6064                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6065         sec->flags |= SEC_KEEP;
6066
6067       sec = eh->elf.root.u.def.section;
6068       sec->flags |= SEC_KEEP;
6069     }
6070 }
6071
6072 /* Mark sections containing dynamically referenced symbols.  When
6073    building shared libraries, we must assume that any visible symbol is
6074    referenced.  */
6075
6076 static bfd_boolean
6077 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6078 {
6079   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6080   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6081   struct ppc_link_hash_entry *fdh;
6082
6083   /* Dynamic linking info is on the func descriptor sym.  */
6084   fdh = defined_func_desc (eh);
6085   if (fdh != NULL)
6086     eh = fdh;
6087
6088   if ((eh->elf.root.type == bfd_link_hash_defined
6089        || eh->elf.root.type == bfd_link_hash_defweak)
6090       && (eh->elf.ref_dynamic
6091           || (!info->executable
6092               && eh->elf.def_regular
6093               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6094               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6095               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6096                   || !bfd_hide_sym_by_version (info->version_info,
6097                                                eh->elf.root.root.string)))))
6098     {
6099       asection *code_sec;
6100       struct ppc_link_hash_entry *fh;
6101
6102       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6103
6104       /* Function descriptor syms cause the associated
6105          function code sym section to be marked.  */
6106       fh = defined_code_entry (eh);
6107       if (fh != NULL)
6108         {
6109           code_sec = fh->elf.root.u.def.section;
6110           code_sec->flags |= SEC_KEEP;
6111         }
6112       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6113                && opd_entry_value (eh->elf.root.u.def.section,
6114                                    eh->elf.root.u.def.value,
6115                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6116         code_sec->flags |= SEC_KEEP;
6117     }
6118
6119   return TRUE;
6120 }
6121
6122 /* Return the section that should be marked against GC for a given
6123    relocation.  */
6124
6125 static asection *
6126 ppc64_elf_gc_mark_hook (asection *sec,
6127                         struct bfd_link_info *info,
6128                         Elf_Internal_Rela *rel,
6129                         struct elf_link_hash_entry *h,
6130                         Elf_Internal_Sym *sym)
6131 {
6132   asection *rsec;
6133
6134   /* Syms return NULL if we're marking .opd, so we avoid marking all
6135      function sections, as all functions are referenced in .opd.  */
6136   rsec = NULL;
6137   if (get_opd_info (sec) != NULL)
6138     return rsec;
6139
6140   if (h != NULL)
6141     {
6142       enum elf_ppc64_reloc_type r_type;
6143       struct ppc_link_hash_entry *eh, *fh, *fdh;
6144
6145       r_type = ELF64_R_TYPE (rel->r_info);
6146       switch (r_type)
6147         {
6148         case R_PPC64_GNU_VTINHERIT:
6149         case R_PPC64_GNU_VTENTRY:
6150           break;
6151
6152         default:
6153           switch (h->root.type)
6154             {
6155             case bfd_link_hash_defined:
6156             case bfd_link_hash_defweak:
6157               eh = (struct ppc_link_hash_entry *) h;
6158               fdh = defined_func_desc (eh);
6159               if (fdh != NULL)
6160                 eh = fdh;
6161
6162               /* Function descriptor syms cause the associated
6163                  function code sym section to be marked.  */
6164               fh = defined_code_entry (eh);
6165               if (fh != NULL)
6166                 {
6167                   /* They also mark their opd section.  */
6168                   eh->elf.root.u.def.section->gc_mark = 1;
6169
6170                   rsec = fh->elf.root.u.def.section;
6171                 }
6172               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6173                        && opd_entry_value (eh->elf.root.u.def.section,
6174                                            eh->elf.root.u.def.value,
6175                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6176                 eh->elf.root.u.def.section->gc_mark = 1;
6177               else
6178                 rsec = h->root.u.def.section;
6179               break;
6180
6181             case bfd_link_hash_common:
6182               rsec = h->root.u.c.p->section;
6183               break;
6184
6185             default:
6186               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6187             }
6188         }
6189     }
6190   else
6191     {
6192       struct _opd_sec_data *opd;
6193
6194       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6195       opd = get_opd_info (rsec);
6196       if (opd != NULL && opd->func_sec != NULL)
6197         {
6198           rsec->gc_mark = 1;
6199
6200           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6201         }
6202     }
6203
6204   return rsec;
6205 }
6206
6207 /* Update the .got, .plt. and dynamic reloc reference counts for the
6208    section being removed.  */
6209
6210 static bfd_boolean
6211 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6212                          asection *sec, const Elf_Internal_Rela *relocs)
6213 {
6214   struct ppc_link_hash_table *htab;
6215   Elf_Internal_Shdr *symtab_hdr;
6216   struct elf_link_hash_entry **sym_hashes;
6217   struct got_entry **local_got_ents;
6218   const Elf_Internal_Rela *rel, *relend;
6219
6220   if (info->relocatable)
6221     return TRUE;
6222
6223   if ((sec->flags & SEC_ALLOC) == 0)
6224     return TRUE;
6225
6226   elf_section_data (sec)->local_dynrel = NULL;
6227
6228   htab = ppc_hash_table (info);
6229   if (htab == NULL)
6230     return FALSE;
6231
6232   symtab_hdr = &elf_symtab_hdr (abfd);
6233   sym_hashes = elf_sym_hashes (abfd);
6234   local_got_ents = elf_local_got_ents (abfd);
6235
6236   relend = relocs + sec->reloc_count;
6237   for (rel = relocs; rel < relend; rel++)
6238     {
6239       unsigned long r_symndx;
6240       enum elf_ppc64_reloc_type r_type;
6241       struct elf_link_hash_entry *h = NULL;
6242       unsigned char tls_type = 0;
6243
6244       r_symndx = ELF64_R_SYM (rel->r_info);
6245       r_type = ELF64_R_TYPE (rel->r_info);
6246       if (r_symndx >= symtab_hdr->sh_info)
6247         {
6248           struct ppc_link_hash_entry *eh;
6249           struct elf_dyn_relocs **pp;
6250           struct elf_dyn_relocs *p;
6251
6252           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6253           h = elf_follow_link (h);
6254           eh = (struct ppc_link_hash_entry *) h;
6255
6256           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6257             if (p->sec == sec)
6258               {
6259                 /* Everything must go for SEC.  */
6260                 *pp = p->next;
6261                 break;
6262               }
6263         }
6264
6265       if (is_branch_reloc (r_type))
6266         {
6267           struct plt_entry **ifunc = NULL;
6268           if (h != NULL)
6269             {
6270               if (h->type == STT_GNU_IFUNC)
6271                 ifunc = &h->plt.plist;
6272             }
6273           else if (local_got_ents != NULL)
6274             {
6275               struct plt_entry **local_plt = (struct plt_entry **)
6276                 (local_got_ents + symtab_hdr->sh_info);
6277               unsigned char *local_got_tls_masks = (unsigned char *)
6278                 (local_plt + symtab_hdr->sh_info);
6279               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6280                 ifunc = local_plt + r_symndx;
6281             }
6282           if (ifunc != NULL)
6283             {
6284               struct plt_entry *ent;
6285
6286               for (ent = *ifunc; ent != NULL; ent = ent->next)
6287                 if (ent->addend == rel->r_addend)
6288                   break;
6289               if (ent == NULL)
6290                 abort ();
6291               if (ent->plt.refcount > 0)
6292                 ent->plt.refcount -= 1;
6293               continue;
6294             }
6295         }
6296
6297       switch (r_type)
6298         {
6299         case R_PPC64_GOT_TLSLD16:
6300         case R_PPC64_GOT_TLSLD16_LO:
6301         case R_PPC64_GOT_TLSLD16_HI:
6302         case R_PPC64_GOT_TLSLD16_HA:
6303           tls_type = TLS_TLS | TLS_LD;
6304           goto dogot;
6305
6306         case R_PPC64_GOT_TLSGD16:
6307         case R_PPC64_GOT_TLSGD16_LO:
6308         case R_PPC64_GOT_TLSGD16_HI:
6309         case R_PPC64_GOT_TLSGD16_HA:
6310           tls_type = TLS_TLS | TLS_GD;
6311           goto dogot;
6312
6313         case R_PPC64_GOT_TPREL16_DS:
6314         case R_PPC64_GOT_TPREL16_LO_DS:
6315         case R_PPC64_GOT_TPREL16_HI:
6316         case R_PPC64_GOT_TPREL16_HA:
6317           tls_type = TLS_TLS | TLS_TPREL;
6318           goto dogot;
6319
6320         case R_PPC64_GOT_DTPREL16_DS:
6321         case R_PPC64_GOT_DTPREL16_LO_DS:
6322         case R_PPC64_GOT_DTPREL16_HI:
6323         case R_PPC64_GOT_DTPREL16_HA:
6324           tls_type = TLS_TLS | TLS_DTPREL;
6325           goto dogot;
6326
6327         case R_PPC64_GOT16:
6328         case R_PPC64_GOT16_DS:
6329         case R_PPC64_GOT16_HA:
6330         case R_PPC64_GOT16_HI:
6331         case R_PPC64_GOT16_LO:
6332         case R_PPC64_GOT16_LO_DS:
6333         dogot:
6334           {
6335             struct got_entry *ent;
6336
6337             if (h != NULL)
6338               ent = h->got.glist;
6339             else
6340               ent = local_got_ents[r_symndx];
6341
6342             for (; ent != NULL; ent = ent->next)
6343               if (ent->addend == rel->r_addend
6344                   && ent->owner == abfd
6345                   && ent->tls_type == tls_type)
6346                 break;
6347             if (ent == NULL)
6348               abort ();
6349             if (ent->got.refcount > 0)
6350               ent->got.refcount -= 1;
6351           }
6352           break;
6353
6354         case R_PPC64_PLT16_HA:
6355         case R_PPC64_PLT16_HI:
6356         case R_PPC64_PLT16_LO:
6357         case R_PPC64_PLT32:
6358         case R_PPC64_PLT64:
6359         case R_PPC64_REL14:
6360         case R_PPC64_REL14_BRNTAKEN:
6361         case R_PPC64_REL14_BRTAKEN:
6362         case R_PPC64_REL24:
6363           if (h != NULL)
6364             {
6365               struct plt_entry *ent;
6366
6367               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6368                 if (ent->addend == rel->r_addend)
6369                   break;
6370               if (ent != NULL && ent->plt.refcount > 0)
6371                 ent->plt.refcount -= 1;
6372             }
6373           break;
6374
6375         default:
6376           break;
6377         }
6378     }
6379   return TRUE;
6380 }
6381
6382 /* The maximum size of .sfpr.  */
6383 #define SFPR_MAX (218*4)
6384
6385 struct sfpr_def_parms
6386 {
6387   const char name[12];
6388   unsigned char lo, hi;
6389   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6390   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6391 };
6392
6393 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6394
6395 static bfd_boolean
6396 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6397 {
6398   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6399   unsigned int i;
6400   size_t len = strlen (parm->name);
6401   bfd_boolean writing = FALSE;
6402   char sym[16];
6403
6404   if (htab == NULL)
6405     return FALSE;
6406
6407   memcpy (sym, parm->name, len);
6408   sym[len + 2] = 0;
6409
6410   for (i = parm->lo; i <= parm->hi; i++)
6411     {
6412       struct elf_link_hash_entry *h;
6413
6414       sym[len + 0] = i / 10 + '0';
6415       sym[len + 1] = i % 10 + '0';
6416       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6417       if (h != NULL
6418           && !h->def_regular)
6419         {
6420           h->root.type = bfd_link_hash_defined;
6421           h->root.u.def.section = htab->sfpr;
6422           h->root.u.def.value = htab->sfpr->size;
6423           h->type = STT_FUNC;
6424           h->def_regular = 1;
6425           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6426           writing = TRUE;
6427           if (htab->sfpr->contents == NULL)
6428             {
6429               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6430               if (htab->sfpr->contents == NULL)
6431                 return FALSE;
6432             }
6433         }
6434       if (writing)
6435         {
6436           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6437           if (i != parm->hi)
6438             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6439           else
6440             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6441           htab->sfpr->size = p - htab->sfpr->contents;
6442         }
6443     }
6444
6445   return TRUE;
6446 }
6447
6448 static bfd_byte *
6449 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6450 {
6451   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6452   return p + 4;
6453 }
6454
6455 static bfd_byte *
6456 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6457 {
6458   p = savegpr0 (abfd, p, r);
6459   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6460   p = p + 4;
6461   bfd_put_32 (abfd, BLR, p);
6462   return p + 4;
6463 }
6464
6465 static bfd_byte *
6466 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6467 {
6468   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6469   return p + 4;
6470 }
6471
6472 static bfd_byte *
6473 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6474 {
6475   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6476   p = p + 4;
6477   p = restgpr0 (abfd, p, r);
6478   bfd_put_32 (abfd, MTLR_R0, p);
6479   p = p + 4;
6480   if (r == 29)
6481     {
6482       p = restgpr0 (abfd, p, 30);
6483       p = restgpr0 (abfd, p, 31);
6484     }
6485   bfd_put_32 (abfd, BLR, p);
6486   return p + 4;
6487 }
6488
6489 static bfd_byte *
6490 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6491 {
6492   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6493   return p + 4;
6494 }
6495
6496 static bfd_byte *
6497 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6498 {
6499   p = savegpr1 (abfd, p, r);
6500   bfd_put_32 (abfd, BLR, p);
6501   return p + 4;
6502 }
6503
6504 static bfd_byte *
6505 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6506 {
6507   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6508   return p + 4;
6509 }
6510
6511 static bfd_byte *
6512 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6513 {
6514   p = restgpr1 (abfd, p, r);
6515   bfd_put_32 (abfd, BLR, p);
6516   return p + 4;
6517 }
6518
6519 static bfd_byte *
6520 savefpr (bfd *abfd, bfd_byte *p, int r)
6521 {
6522   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6523   return p + 4;
6524 }
6525
6526 static bfd_byte *
6527 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6528 {
6529   p = savefpr (abfd, p, r);
6530   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6531   p = p + 4;
6532   bfd_put_32 (abfd, BLR, p);
6533   return p + 4;
6534 }
6535
6536 static bfd_byte *
6537 restfpr (bfd *abfd, bfd_byte *p, int r)
6538 {
6539   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6540   return p + 4;
6541 }
6542
6543 static bfd_byte *
6544 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6545 {
6546   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6547   p = p + 4;
6548   p = restfpr (abfd, p, r);
6549   bfd_put_32 (abfd, MTLR_R0, p);
6550   p = p + 4;
6551   if (r == 29)
6552     {
6553       p = restfpr (abfd, p, 30);
6554       p = restfpr (abfd, p, 31);
6555     }
6556   bfd_put_32 (abfd, BLR, p);
6557   return p + 4;
6558 }
6559
6560 static bfd_byte *
6561 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6562 {
6563   p = savefpr (abfd, p, r);
6564   bfd_put_32 (abfd, BLR, p);
6565   return p + 4;
6566 }
6567
6568 static bfd_byte *
6569 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6570 {
6571   p = restfpr (abfd, p, r);
6572   bfd_put_32 (abfd, BLR, p);
6573   return p + 4;
6574 }
6575
6576 static bfd_byte *
6577 savevr (bfd *abfd, bfd_byte *p, int r)
6578 {
6579   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6580   p = p + 4;
6581   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6582   return p + 4;
6583 }
6584
6585 static bfd_byte *
6586 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6587 {
6588   p = savevr (abfd, p, r);
6589   bfd_put_32 (abfd, BLR, p);
6590   return p + 4;
6591 }
6592
6593 static bfd_byte *
6594 restvr (bfd *abfd, bfd_byte *p, int r)
6595 {
6596   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6597   p = p + 4;
6598   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6599   return p + 4;
6600 }
6601
6602 static bfd_byte *
6603 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6604 {
6605   p = restvr (abfd, p, r);
6606   bfd_put_32 (abfd, BLR, p);
6607   return p + 4;
6608 }
6609
6610 /* Called via elf_link_hash_traverse to transfer dynamic linking
6611    information on function code symbol entries to their corresponding
6612    function descriptor symbol entries.  */
6613
6614 static bfd_boolean
6615 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6616 {
6617   struct bfd_link_info *info;
6618   struct ppc_link_hash_table *htab;
6619   struct plt_entry *ent;
6620   struct ppc_link_hash_entry *fh;
6621   struct ppc_link_hash_entry *fdh;
6622   bfd_boolean force_local;
6623
6624   fh = (struct ppc_link_hash_entry *) h;
6625   if (fh->elf.root.type == bfd_link_hash_indirect)
6626     return TRUE;
6627
6628   info = inf;
6629   htab = ppc_hash_table (info);
6630   if (htab == NULL)
6631     return FALSE;
6632
6633   /* Resolve undefined references to dot-symbols as the value
6634      in the function descriptor, if we have one in a regular object.
6635      This is to satisfy cases like ".quad .foo".  Calls to functions
6636      in dynamic objects are handled elsewhere.  */
6637   if (fh->elf.root.type == bfd_link_hash_undefweak
6638       && fh->was_undefined
6639       && (fdh = defined_func_desc (fh)) != NULL
6640       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6641       && opd_entry_value (fdh->elf.root.u.def.section,
6642                           fdh->elf.root.u.def.value,
6643                           &fh->elf.root.u.def.section,
6644                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6645     {
6646       fh->elf.root.type = fdh->elf.root.type;
6647       fh->elf.forced_local = 1;
6648       fh->elf.def_regular = fdh->elf.def_regular;
6649       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6650     }
6651
6652   /* If this is a function code symbol, transfer dynamic linking
6653      information to the function descriptor symbol.  */
6654   if (!fh->is_func)
6655     return TRUE;
6656
6657   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6658     if (ent->plt.refcount > 0)
6659       break;
6660   if (ent == NULL
6661       || fh->elf.root.root.string[0] != '.'
6662       || fh->elf.root.root.string[1] == '\0')
6663     return TRUE;
6664
6665   /* Find the corresponding function descriptor symbol.  Create it
6666      as undefined if necessary.  */
6667
6668   fdh = lookup_fdh (fh, htab);
6669   if (fdh == NULL
6670       && !info->executable
6671       && (fh->elf.root.type == bfd_link_hash_undefined
6672           || fh->elf.root.type == bfd_link_hash_undefweak))
6673     {
6674       fdh = make_fdh (info, fh);
6675       if (fdh == NULL)
6676         return FALSE;
6677     }
6678
6679   /* Fake function descriptors are made undefweak.  If the function
6680      code symbol is strong undefined, make the fake sym the same.
6681      If the function code symbol is defined, then force the fake
6682      descriptor local;  We can't support overriding of symbols in a
6683      shared library on a fake descriptor.  */
6684
6685   if (fdh != NULL
6686       && fdh->fake
6687       && fdh->elf.root.type == bfd_link_hash_undefweak)
6688     {
6689       if (fh->elf.root.type == bfd_link_hash_undefined)
6690         {
6691           fdh->elf.root.type = bfd_link_hash_undefined;
6692           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6693         }
6694       else if (fh->elf.root.type == bfd_link_hash_defined
6695                || fh->elf.root.type == bfd_link_hash_defweak)
6696         {
6697           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6698         }
6699     }
6700
6701   if (fdh != NULL
6702       && !fdh->elf.forced_local
6703       && (!info->executable
6704           || fdh->elf.def_dynamic
6705           || fdh->elf.ref_dynamic
6706           || (fdh->elf.root.type == bfd_link_hash_undefweak
6707               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6708     {
6709       if (fdh->elf.dynindx == -1)
6710         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6711           return FALSE;
6712       fdh->elf.ref_regular |= fh->elf.ref_regular;
6713       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6714       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6715       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6716       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6717         {
6718           move_plt_plist (fh, fdh);
6719           fdh->elf.needs_plt = 1;
6720         }
6721       fdh->is_func_descriptor = 1;
6722       fdh->oh = fh;
6723       fh->oh = fdh;
6724     }
6725
6726   /* Now that the info is on the function descriptor, clear the
6727      function code sym info.  Any function code syms for which we
6728      don't have a definition in a regular file, we force local.
6729      This prevents a shared library from exporting syms that have
6730      been imported from another library.  Function code syms that
6731      are really in the library we must leave global to prevent the
6732      linker dragging in a definition from a static library.  */
6733   force_local = (!fh->elf.def_regular
6734                  || fdh == NULL
6735                  || !fdh->elf.def_regular
6736                  || fdh->elf.forced_local);
6737   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6738
6739   return TRUE;
6740 }
6741
6742 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6743    this hook to a) provide some gcc support functions, and b) transfer
6744    dynamic linking information gathered so far on function code symbol
6745    entries, to their corresponding function descriptor symbol entries.  */
6746
6747 static bfd_boolean
6748 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6749                             struct bfd_link_info *info)
6750 {
6751   struct ppc_link_hash_table *htab;
6752   unsigned int i;
6753   static const struct sfpr_def_parms funcs[] =
6754     {
6755       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6756       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6757       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6758       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6759       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6760       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6761       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6762       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6763       { "._savef", 14, 31, savefpr, savefpr1_tail },
6764       { "._restf", 14, 31, restfpr, restfpr1_tail },
6765       { "_savevr_", 20, 31, savevr, savevr_tail },
6766       { "_restvr_", 20, 31, restvr, restvr_tail }
6767     };
6768
6769   htab = ppc_hash_table (info);
6770   if (htab == NULL)
6771     return FALSE;
6772
6773   if (!info->relocatable
6774       && htab->elf.hgot != NULL)
6775     _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6776
6777   if (htab->sfpr == NULL)
6778     /* We don't have any relocs.  */
6779     return TRUE;
6780
6781   /* Provide any missing _save* and _rest* functions.  */
6782   htab->sfpr->size = 0;
6783   if (!info->relocatable)
6784     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6785       if (!sfpr_define (info, &funcs[i]))
6786         return FALSE;
6787
6788   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6789
6790   if (htab->sfpr->size == 0)
6791     htab->sfpr->flags |= SEC_EXCLUDE;
6792
6793   return TRUE;
6794 }
6795
6796 /* Adjust a symbol defined by a dynamic object and referenced by a
6797    regular object.  The current definition is in some section of the
6798    dynamic object, but we're not including those sections.  We have to
6799    change the definition to something the rest of the link can
6800    understand.  */
6801
6802 static bfd_boolean
6803 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6804                                  struct elf_link_hash_entry *h)
6805 {
6806   struct ppc_link_hash_table *htab;
6807   asection *s;
6808
6809   htab = ppc_hash_table (info);
6810   if (htab == NULL)
6811     return FALSE;
6812
6813   /* Deal with function syms.  */
6814   if (h->type == STT_FUNC
6815       || h->type == STT_GNU_IFUNC
6816       || h->needs_plt)
6817     {
6818       /* Clear procedure linkage table information for any symbol that
6819          won't need a .plt entry.  */
6820       struct plt_entry *ent;
6821       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6822         if (ent->plt.refcount > 0)
6823           break;
6824       if (ent == NULL
6825           || (h->type != STT_GNU_IFUNC
6826               && (SYMBOL_CALLS_LOCAL (info, h)
6827                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6828                       && h->root.type == bfd_link_hash_undefweak))))
6829         {
6830           h->plt.plist = NULL;
6831           h->needs_plt = 0;
6832         }
6833     }
6834   else
6835     h->plt.plist = NULL;
6836
6837   /* If this is a weak symbol, and there is a real definition, the
6838      processor independent code will have arranged for us to see the
6839      real definition first, and we can just use the same value.  */
6840   if (h->u.weakdef != NULL)
6841     {
6842       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6843                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6844       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6845       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6846       if (ELIMINATE_COPY_RELOCS)
6847         h->non_got_ref = h->u.weakdef->non_got_ref;
6848       return TRUE;
6849     }
6850
6851   /* If we are creating a shared library, we must presume that the
6852      only references to the symbol are via the global offset table.
6853      For such cases we need not do anything here; the relocations will
6854      be handled correctly by relocate_section.  */
6855   if (info->shared)
6856     return TRUE;
6857
6858   /* If there are no references to this symbol that do not use the
6859      GOT, we don't need to generate a copy reloc.  */
6860   if (!h->non_got_ref)
6861     return TRUE;
6862
6863   /* Don't generate a copy reloc for symbols defined in the executable.  */
6864   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6865     return TRUE;
6866
6867   if (ELIMINATE_COPY_RELOCS)
6868     {
6869       struct ppc_link_hash_entry * eh;
6870       struct elf_dyn_relocs *p;
6871
6872       eh = (struct ppc_link_hash_entry *) h;
6873       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6874         {
6875           s = p->sec->output_section;
6876           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6877             break;
6878         }
6879
6880       /* If we didn't find any dynamic relocs in read-only sections, then
6881          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6882       if (p == NULL)
6883         {
6884           h->non_got_ref = 0;
6885           return TRUE;
6886         }
6887     }
6888
6889   if (h->plt.plist != NULL)
6890     {
6891       /* We should never get here, but unfortunately there are versions
6892          of gcc out there that improperly (for this ABI) put initialized
6893          function pointers, vtable refs and suchlike in read-only
6894          sections.  Allow them to proceed, but warn that this might
6895          break at runtime.  */
6896       info->callbacks->einfo
6897         (_("%P: copy reloc against `%T' requires lazy plt linking; "
6898            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6899          h->root.root.string);
6900     }
6901
6902   /* This is a reference to a symbol defined by a dynamic object which
6903      is not a function.  */
6904
6905   /* We must allocate the symbol in our .dynbss section, which will
6906      become part of the .bss section of the executable.  There will be
6907      an entry for this symbol in the .dynsym section.  The dynamic
6908      object will contain position independent code, so all references
6909      from the dynamic object to this symbol will go through the global
6910      offset table.  The dynamic linker will use the .dynsym entry to
6911      determine the address it must put in the global offset table, so
6912      both the dynamic object and the regular object will refer to the
6913      same memory location for the variable.  */
6914
6915   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6916      to copy the initial value out of the dynamic object and into the
6917      runtime process image.  We need to remember the offset into the
6918      .rela.bss section we are going to use.  */
6919   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6920     {
6921       htab->relbss->size += sizeof (Elf64_External_Rela);
6922       h->needs_copy = 1;
6923     }
6924
6925   s = htab->dynbss;
6926
6927   return _bfd_elf_adjust_dynamic_copy (h, s);
6928 }
6929
6930 /* If given a function descriptor symbol, hide both the function code
6931    sym and the descriptor.  */
6932 static void
6933 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6934                        struct elf_link_hash_entry *h,
6935                        bfd_boolean force_local)
6936 {
6937   struct ppc_link_hash_entry *eh;
6938   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6939
6940   eh = (struct ppc_link_hash_entry *) h;
6941   if (eh->is_func_descriptor)
6942     {
6943       struct ppc_link_hash_entry *fh = eh->oh;
6944
6945       if (fh == NULL)
6946         {
6947           const char *p, *q;
6948           struct ppc_link_hash_table *htab;
6949           char save;
6950
6951           /* We aren't supposed to use alloca in BFD because on
6952              systems which do not have alloca the version in libiberty
6953              calls xmalloc, which might cause the program to crash
6954              when it runs out of memory.  This function doesn't have a
6955              return status, so there's no way to gracefully return an
6956              error.  So cheat.  We know that string[-1] can be safely
6957              accessed;  It's either a string in an ELF string table,
6958              or allocated in an objalloc structure.  */
6959
6960           p = eh->elf.root.root.string - 1;
6961           save = *p;
6962           *(char *) p = '.';
6963           htab = ppc_hash_table (info);
6964           if (htab == NULL)
6965             return;
6966
6967           fh = (struct ppc_link_hash_entry *)
6968             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6969           *(char *) p = save;
6970
6971           /* Unfortunately, if it so happens that the string we were
6972              looking for was allocated immediately before this string,
6973              then we overwrote the string terminator.  That's the only
6974              reason the lookup should fail.  */
6975           if (fh == NULL)
6976             {
6977               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6978               while (q >= eh->elf.root.root.string && *q == *p)
6979                 --q, --p;
6980               if (q < eh->elf.root.root.string && *p == '.')
6981                 fh = (struct ppc_link_hash_entry *)
6982                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6983             }
6984           if (fh != NULL)
6985             {
6986               eh->oh = fh;
6987               fh->oh = eh;
6988             }
6989         }
6990       if (fh != NULL)
6991         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6992     }
6993 }
6994
6995 static bfd_boolean
6996 get_sym_h (struct elf_link_hash_entry **hp,
6997            Elf_Internal_Sym **symp,
6998            asection **symsecp,
6999            unsigned char **tls_maskp,
7000            Elf_Internal_Sym **locsymsp,
7001            unsigned long r_symndx,
7002            bfd *ibfd)
7003 {
7004   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7005
7006   if (r_symndx >= symtab_hdr->sh_info)
7007     {
7008       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7009       struct elf_link_hash_entry *h;
7010
7011       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7012       h = elf_follow_link (h);
7013
7014       if (hp != NULL)
7015         *hp = h;
7016
7017       if (symp != NULL)
7018         *symp = NULL;
7019
7020       if (symsecp != NULL)
7021         {
7022           asection *symsec = NULL;
7023           if (h->root.type == bfd_link_hash_defined
7024               || h->root.type == bfd_link_hash_defweak)
7025             symsec = h->root.u.def.section;
7026           *symsecp = symsec;
7027         }
7028
7029       if (tls_maskp != NULL)
7030         {
7031           struct ppc_link_hash_entry *eh;
7032
7033           eh = (struct ppc_link_hash_entry *) h;
7034           *tls_maskp = &eh->tls_mask;
7035         }
7036     }
7037   else
7038     {
7039       Elf_Internal_Sym *sym;
7040       Elf_Internal_Sym *locsyms = *locsymsp;
7041
7042       if (locsyms == NULL)
7043         {
7044           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7045           if (locsyms == NULL)
7046             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7047                                             symtab_hdr->sh_info,
7048                                             0, NULL, NULL, NULL);
7049           if (locsyms == NULL)
7050             return FALSE;
7051           *locsymsp = locsyms;
7052         }
7053       sym = locsyms + r_symndx;
7054
7055       if (hp != NULL)
7056         *hp = NULL;
7057
7058       if (symp != NULL)
7059         *symp = sym;
7060
7061       if (symsecp != NULL)
7062         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7063
7064       if (tls_maskp != NULL)
7065         {
7066           struct got_entry **lgot_ents;
7067           unsigned char *tls_mask;
7068
7069           tls_mask = NULL;
7070           lgot_ents = elf_local_got_ents (ibfd);
7071           if (lgot_ents != NULL)
7072             {
7073               struct plt_entry **local_plt = (struct plt_entry **)
7074                 (lgot_ents + symtab_hdr->sh_info);
7075               unsigned char *lgot_masks = (unsigned char *)
7076                 (local_plt + symtab_hdr->sh_info);
7077               tls_mask = &lgot_masks[r_symndx];
7078             }
7079           *tls_maskp = tls_mask;
7080         }
7081     }
7082   return TRUE;
7083 }
7084
7085 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7086    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7087    type suitable for optimization, and 1 otherwise.  */
7088
7089 static int
7090 get_tls_mask (unsigned char **tls_maskp,
7091               unsigned long *toc_symndx,
7092               bfd_vma *toc_addend,
7093               Elf_Internal_Sym **locsymsp,
7094               const Elf_Internal_Rela *rel,
7095               bfd *ibfd)
7096 {
7097   unsigned long r_symndx;
7098   int next_r;
7099   struct elf_link_hash_entry *h;
7100   Elf_Internal_Sym *sym;
7101   asection *sec;
7102   bfd_vma off;
7103
7104   r_symndx = ELF64_R_SYM (rel->r_info);
7105   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7106     return 0;
7107
7108   if ((*tls_maskp != NULL && **tls_maskp != 0)
7109       || sec == NULL
7110       || ppc64_elf_section_data (sec) == NULL
7111       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7112     return 1;
7113
7114   /* Look inside a TOC section too.  */
7115   if (h != NULL)
7116     {
7117       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7118       off = h->root.u.def.value;
7119     }
7120   else
7121     off = sym->st_value;
7122   off += rel->r_addend;
7123   BFD_ASSERT (off % 8 == 0);
7124   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7125   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7126   if (toc_symndx != NULL)
7127     *toc_symndx = r_symndx;
7128   if (toc_addend != NULL)
7129     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7130   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7131     return 0;
7132   if ((h == NULL || is_static_defined (h))
7133       && (next_r == -1 || next_r == -2))
7134     return 1 - next_r;
7135   return 1;
7136 }
7137
7138 /* Find (or create) an entry in the tocsave hash table.  */
7139
7140 static struct tocsave_entry *
7141 tocsave_find (struct ppc_link_hash_table *htab,
7142               enum insert_option insert,
7143               Elf_Internal_Sym **local_syms,
7144               const Elf_Internal_Rela *irela,
7145               bfd *ibfd)
7146 {
7147   unsigned long r_indx;
7148   struct elf_link_hash_entry *h;
7149   Elf_Internal_Sym *sym;
7150   struct tocsave_entry ent, *p;
7151   hashval_t hash;
7152   struct tocsave_entry **slot;
7153
7154   r_indx = ELF64_R_SYM (irela->r_info);
7155   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7156     return NULL;
7157   if (ent.sec == NULL || ent.sec->output_section == NULL)
7158     {
7159       (*_bfd_error_handler)
7160         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7161       return NULL;
7162     }
7163
7164   if (h != NULL)
7165     ent.offset = h->root.u.def.value;
7166   else
7167     ent.offset = sym->st_value;
7168   ent.offset += irela->r_addend;
7169
7170   hash = tocsave_htab_hash (&ent);
7171   slot = ((struct tocsave_entry **)
7172           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7173   if (slot == NULL)
7174     return NULL;
7175
7176   if (*slot == NULL)
7177     {
7178       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7179       if (p == NULL)
7180         return NULL;
7181       *p = ent;
7182       *slot = p;
7183     }
7184   return *slot;
7185 }
7186
7187 /* Adjust all global syms defined in opd sections.  In gcc generated
7188    code for the old ABI, these will already have been done.  */
7189
7190 static bfd_boolean
7191 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7192 {
7193   struct ppc_link_hash_entry *eh;
7194   asection *sym_sec;
7195   struct _opd_sec_data *opd;
7196
7197   if (h->root.type == bfd_link_hash_indirect)
7198     return TRUE;
7199
7200   if (h->root.type != bfd_link_hash_defined
7201       && h->root.type != bfd_link_hash_defweak)
7202     return TRUE;
7203
7204   eh = (struct ppc_link_hash_entry *) h;
7205   if (eh->adjust_done)
7206     return TRUE;
7207
7208   sym_sec = eh->elf.root.u.def.section;
7209   opd = get_opd_info (sym_sec);
7210   if (opd != NULL && opd->adjust != NULL)
7211     {
7212       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7213       if (adjust == -1)
7214         {
7215           /* This entry has been deleted.  */
7216           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7217           if (dsec == NULL)
7218             {
7219               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7220                 if (discarded_section (dsec))
7221                   {
7222                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7223                     break;
7224                   }
7225             }
7226           eh->elf.root.u.def.value = 0;
7227           eh->elf.root.u.def.section = dsec;
7228         }
7229       else
7230         eh->elf.root.u.def.value += adjust;
7231       eh->adjust_done = 1;
7232     }
7233   return TRUE;
7234 }
7235
7236 /* Handles decrementing dynamic reloc counts for the reloc specified by
7237    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7238    have already been determined.  */
7239
7240 static bfd_boolean
7241 dec_dynrel_count (bfd_vma r_info,
7242                   asection *sec,
7243                   struct bfd_link_info *info,
7244                   Elf_Internal_Sym **local_syms,
7245                   struct elf_link_hash_entry *h,
7246                   Elf_Internal_Sym *sym)
7247 {
7248   enum elf_ppc64_reloc_type r_type;
7249   asection *sym_sec = NULL;
7250
7251   /* Can this reloc be dynamic?  This switch, and later tests here
7252      should be kept in sync with the code in check_relocs.  */
7253   r_type = ELF64_R_TYPE (r_info);
7254   switch (r_type)
7255     {
7256     default:
7257       return TRUE;
7258
7259     case R_PPC64_TPREL16:
7260     case R_PPC64_TPREL16_LO:
7261     case R_PPC64_TPREL16_HI:
7262     case R_PPC64_TPREL16_HA:
7263     case R_PPC64_TPREL16_DS:
7264     case R_PPC64_TPREL16_LO_DS:
7265     case R_PPC64_TPREL16_HIGH:
7266     case R_PPC64_TPREL16_HIGHA:
7267     case R_PPC64_TPREL16_HIGHER:
7268     case R_PPC64_TPREL16_HIGHERA:
7269     case R_PPC64_TPREL16_HIGHEST:
7270     case R_PPC64_TPREL16_HIGHESTA:
7271       if (!info->shared)
7272         return TRUE;
7273
7274     case R_PPC64_TPREL64:
7275     case R_PPC64_DTPMOD64:
7276     case R_PPC64_DTPREL64:
7277     case R_PPC64_ADDR64:
7278     case R_PPC64_REL30:
7279     case R_PPC64_REL32:
7280     case R_PPC64_REL64:
7281     case R_PPC64_ADDR14:
7282     case R_PPC64_ADDR14_BRNTAKEN:
7283     case R_PPC64_ADDR14_BRTAKEN:
7284     case R_PPC64_ADDR16:
7285     case R_PPC64_ADDR16_DS:
7286     case R_PPC64_ADDR16_HA:
7287     case R_PPC64_ADDR16_HI:
7288     case R_PPC64_ADDR16_HIGH:
7289     case R_PPC64_ADDR16_HIGHA:
7290     case R_PPC64_ADDR16_HIGHER:
7291     case R_PPC64_ADDR16_HIGHERA:
7292     case R_PPC64_ADDR16_HIGHEST:
7293     case R_PPC64_ADDR16_HIGHESTA:
7294     case R_PPC64_ADDR16_LO:
7295     case R_PPC64_ADDR16_LO_DS:
7296     case R_PPC64_ADDR24:
7297     case R_PPC64_ADDR32:
7298     case R_PPC64_UADDR16:
7299     case R_PPC64_UADDR32:
7300     case R_PPC64_UADDR64:
7301     case R_PPC64_TOC:
7302       break;
7303     }
7304
7305   if (local_syms != NULL)
7306     {
7307       unsigned long r_symndx;
7308       bfd *ibfd = sec->owner;
7309
7310       r_symndx = ELF64_R_SYM (r_info);
7311       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7312         return FALSE;
7313     }
7314
7315   if ((info->shared
7316        && (must_be_dyn_reloc (info, r_type)
7317            || (h != NULL
7318                && (!SYMBOLIC_BIND (info, h)
7319                    || h->root.type == bfd_link_hash_defweak
7320                    || !h->def_regular))))
7321       || (ELIMINATE_COPY_RELOCS
7322           && !info->shared
7323           && h != NULL
7324           && (h->root.type == bfd_link_hash_defweak
7325               || !h->def_regular)))
7326     ;
7327   else
7328     return TRUE;
7329
7330   if (h != NULL)
7331     {
7332       struct elf_dyn_relocs *p;
7333       struct elf_dyn_relocs **pp;
7334       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7335
7336       /* elf_gc_sweep may have already removed all dyn relocs associated
7337          with local syms for a given section.  Also, symbol flags are
7338          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7339          report a dynreloc miscount.  */
7340       if (*pp == NULL && info->gc_sections)
7341         return TRUE;
7342
7343       while ((p = *pp) != NULL)
7344         {
7345           if (p->sec == sec)
7346             {
7347               if (!must_be_dyn_reloc (info, r_type))
7348                 p->pc_count -= 1;
7349               p->count -= 1;
7350               if (p->count == 0)
7351                 *pp = p->next;
7352               return TRUE;
7353             }
7354           pp = &p->next;
7355         }
7356     }
7357   else
7358     {
7359       struct ppc_dyn_relocs *p;
7360       struct ppc_dyn_relocs **pp;
7361       void *vpp;
7362       bfd_boolean is_ifunc;
7363
7364       if (local_syms == NULL)
7365         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7366       if (sym_sec == NULL)
7367         sym_sec = sec;
7368
7369       vpp = &elf_section_data (sym_sec)->local_dynrel;
7370       pp = (struct ppc_dyn_relocs **) vpp;
7371
7372       if (*pp == NULL && info->gc_sections)
7373         return TRUE;
7374
7375       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7376       while ((p = *pp) != NULL)
7377         {
7378           if (p->sec == sec && p->ifunc == is_ifunc)
7379             {
7380               p->count -= 1;
7381               if (p->count == 0)
7382                 *pp = p->next;
7383               return TRUE;
7384             }
7385           pp = &p->next;
7386         }
7387     }
7388
7389   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7390                           sec->owner, sec);
7391   bfd_set_error (bfd_error_bad_value);
7392   return FALSE;
7393 }
7394
7395 /* Remove unused Official Procedure Descriptor entries.  Currently we
7396    only remove those associated with functions in discarded link-once
7397    sections, or weakly defined functions that have been overridden.  It
7398    would be possible to remove many more entries for statically linked
7399    applications.  */
7400
7401 bfd_boolean
7402 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7403 {
7404   bfd *ibfd;
7405   bfd_boolean some_edited = FALSE;
7406   asection *need_pad = NULL;
7407
7408   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7409     {
7410       asection *sec;
7411       Elf_Internal_Rela *relstart, *rel, *relend;
7412       Elf_Internal_Shdr *symtab_hdr;
7413       Elf_Internal_Sym *local_syms;
7414       bfd_vma offset;
7415       struct _opd_sec_data *opd;
7416       bfd_boolean need_edit, add_aux_fields;
7417       bfd_size_type cnt_16b = 0;
7418
7419       if (!is_ppc64_elf (ibfd))
7420         continue;
7421
7422       sec = bfd_get_section_by_name (ibfd, ".opd");
7423       if (sec == NULL || sec->size == 0)
7424         continue;
7425
7426       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7427         continue;
7428
7429       if (sec->output_section == bfd_abs_section_ptr)
7430         continue;
7431
7432       /* Look through the section relocs.  */
7433       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7434         continue;
7435
7436       local_syms = NULL;
7437       symtab_hdr = &elf_symtab_hdr (ibfd);
7438
7439       /* Read the relocations.  */
7440       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7441                                             info->keep_memory);
7442       if (relstart == NULL)
7443         return FALSE;
7444
7445       /* First run through the relocs to check they are sane, and to
7446          determine whether we need to edit this opd section.  */
7447       need_edit = FALSE;
7448       need_pad = sec;
7449       offset = 0;
7450       relend = relstart + sec->reloc_count;
7451       for (rel = relstart; rel < relend; )
7452         {
7453           enum elf_ppc64_reloc_type r_type;
7454           unsigned long r_symndx;
7455           asection *sym_sec;
7456           struct elf_link_hash_entry *h;
7457           Elf_Internal_Sym *sym;
7458
7459           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7460              only interested in the reloc pointing to a function entry
7461              point.  */
7462           if (rel->r_offset != offset
7463               || rel + 1 >= relend
7464               || (rel + 1)->r_offset != offset + 8)
7465             {
7466               /* If someone messes with .opd alignment then after a
7467                  "ld -r" we might have padding in the middle of .opd.
7468                  Also, there's nothing to prevent someone putting
7469                  something silly in .opd with the assembler.  No .opd
7470                  optimization for them!  */
7471             broken_opd:
7472               (*_bfd_error_handler)
7473                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7474               need_edit = FALSE;
7475               break;
7476             }
7477
7478           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7479               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7480             {
7481               (*_bfd_error_handler)
7482                 (_("%B: unexpected reloc type %u in .opd section"),
7483                  ibfd, r_type);
7484               need_edit = FALSE;
7485               break;
7486             }
7487
7488           r_symndx = ELF64_R_SYM (rel->r_info);
7489           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7490                           r_symndx, ibfd))
7491             goto error_ret;
7492
7493           if (sym_sec == NULL || sym_sec->owner == NULL)
7494             {
7495               const char *sym_name;
7496               if (h != NULL)
7497                 sym_name = h->root.root.string;
7498               else
7499                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7500                                              sym_sec);
7501
7502               (*_bfd_error_handler)
7503                 (_("%B: undefined sym `%s' in .opd section"),
7504                  ibfd, sym_name);
7505               need_edit = FALSE;
7506               break;
7507             }
7508
7509           /* opd entries are always for functions defined in the
7510              current input bfd.  If the symbol isn't defined in the
7511              input bfd, then we won't be using the function in this
7512              bfd;  It must be defined in a linkonce section in another
7513              bfd, or is weak.  It's also possible that we are
7514              discarding the function due to a linker script /DISCARD/,
7515              which we test for via the output_section.  */
7516           if (sym_sec->owner != ibfd
7517               || sym_sec->output_section == bfd_abs_section_ptr)
7518             need_edit = TRUE;
7519
7520           rel += 2;
7521           if (rel == relend
7522               || (rel + 1 == relend && rel->r_offset == offset + 16))
7523             {
7524               if (sec->size == offset + 24)
7525                 {
7526                   need_pad = NULL;
7527                   break;
7528                 }
7529               if (rel == relend && sec->size == offset + 16)
7530                 {
7531                   cnt_16b++;
7532                   break;
7533                 }
7534               goto broken_opd;
7535             }
7536
7537           if (rel->r_offset == offset + 24)
7538             offset += 24;
7539           else if (rel->r_offset != offset + 16)
7540             goto broken_opd;
7541           else if (rel + 1 < relend
7542                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7543                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7544             {
7545               offset += 16;
7546               cnt_16b++;
7547             }
7548           else if (rel + 2 < relend
7549                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7550                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7551             {
7552               offset += 24;
7553               rel += 1;
7554             }
7555           else
7556             goto broken_opd;
7557         }
7558
7559       add_aux_fields = non_overlapping && cnt_16b > 0;
7560
7561       if (need_edit || add_aux_fields)
7562         {
7563           Elf_Internal_Rela *write_rel;
7564           Elf_Internal_Shdr *rel_hdr;
7565           bfd_byte *rptr, *wptr;
7566           bfd_byte *new_contents;
7567           bfd_boolean skip;
7568           long opd_ent_size;
7569           bfd_size_type amt;
7570
7571           new_contents = NULL;
7572           amt = sec->size * sizeof (long) / 8;
7573           opd = &ppc64_elf_section_data (sec)->u.opd;
7574           opd->adjust = bfd_zalloc (sec->owner, amt);
7575           if (opd->adjust == NULL)
7576             return FALSE;
7577           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7578
7579           /* This seems a waste of time as input .opd sections are all
7580              zeros as generated by gcc, but I suppose there's no reason
7581              this will always be so.  We might start putting something in
7582              the third word of .opd entries.  */
7583           if ((sec->flags & SEC_IN_MEMORY) == 0)
7584             {
7585               bfd_byte *loc;
7586               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7587                 {
7588                   if (loc != NULL)
7589                     free (loc);
7590                 error_ret:
7591                   if (local_syms != NULL
7592                       && symtab_hdr->contents != (unsigned char *) local_syms)
7593                     free (local_syms);
7594                   if (elf_section_data (sec)->relocs != relstart)
7595                     free (relstart);
7596                   return FALSE;
7597                 }
7598               sec->contents = loc;
7599               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7600             }
7601
7602           elf_section_data (sec)->relocs = relstart;
7603
7604           new_contents = sec->contents;
7605           if (add_aux_fields)
7606             {
7607               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7608               if (new_contents == NULL)
7609                 return FALSE;
7610               need_pad = FALSE;
7611             }
7612           wptr = new_contents;
7613           rptr = sec->contents;
7614
7615           write_rel = relstart;
7616           skip = FALSE;
7617           offset = 0;
7618           opd_ent_size = 0;
7619           for (rel = relstart; rel < relend; rel++)
7620             {
7621               unsigned long r_symndx;
7622               asection *sym_sec;
7623               struct elf_link_hash_entry *h;
7624               Elf_Internal_Sym *sym;
7625
7626               r_symndx = ELF64_R_SYM (rel->r_info);
7627               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7628                               r_symndx, ibfd))
7629                 goto error_ret;
7630
7631               if (rel->r_offset == offset)
7632                 {
7633                   struct ppc_link_hash_entry *fdh = NULL;
7634
7635                   /* See if the .opd entry is full 24 byte or
7636                      16 byte (with fd_aux entry overlapped with next
7637                      fd_func).  */
7638                   opd_ent_size = 24;
7639                   if ((rel + 2 == relend && sec->size == offset + 16)
7640                       || (rel + 3 < relend
7641                           && rel[2].r_offset == offset + 16
7642                           && rel[3].r_offset == offset + 24
7643                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7644                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7645                     opd_ent_size = 16;
7646
7647                   if (h != NULL
7648                       && h->root.root.string[0] == '.')
7649                     {
7650                       struct ppc_link_hash_table *htab;
7651
7652                       htab = ppc_hash_table (info);
7653                       if (htab != NULL)
7654                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7655                                           htab);
7656                       if (fdh != NULL
7657                           && fdh->elf.root.type != bfd_link_hash_defined
7658                           && fdh->elf.root.type != bfd_link_hash_defweak)
7659                         fdh = NULL;
7660                     }
7661
7662                   skip = (sym_sec->owner != ibfd
7663                           || sym_sec->output_section == bfd_abs_section_ptr);
7664                   if (skip)
7665                     {
7666                       if (fdh != NULL && sym_sec->owner == ibfd)
7667                         {
7668                           /* Arrange for the function descriptor sym
7669                              to be dropped.  */
7670                           fdh->elf.root.u.def.value = 0;
7671                           fdh->elf.root.u.def.section = sym_sec;
7672                         }
7673                       opd->adjust[rel->r_offset / 8] = -1;
7674                     }
7675                   else
7676                     {
7677                       /* We'll be keeping this opd entry.  */
7678
7679                       if (fdh != NULL)
7680                         {
7681                           /* Redefine the function descriptor symbol to
7682                              this location in the opd section.  It is
7683                              necessary to update the value here rather
7684                              than using an array of adjustments as we do
7685                              for local symbols, because various places
7686                              in the generic ELF code use the value
7687                              stored in u.def.value.  */
7688                           fdh->elf.root.u.def.value = wptr - new_contents;
7689                           fdh->adjust_done = 1;
7690                         }
7691
7692                       /* Local syms are a bit tricky.  We could
7693                          tweak them as they can be cached, but
7694                          we'd need to look through the local syms
7695                          for the function descriptor sym which we
7696                          don't have at the moment.  So keep an
7697                          array of adjustments.  */
7698                       opd->adjust[rel->r_offset / 8]
7699                         = (wptr - new_contents) - (rptr - sec->contents);
7700
7701                       if (wptr != rptr)
7702                         memcpy (wptr, rptr, opd_ent_size);
7703                       wptr += opd_ent_size;
7704                       if (add_aux_fields && opd_ent_size == 16)
7705                         {
7706                           memset (wptr, '\0', 8);
7707                           wptr += 8;
7708                         }
7709                     }
7710                   rptr += opd_ent_size;
7711                   offset += opd_ent_size;
7712                 }
7713
7714               if (skip)
7715                 {
7716                   if (!NO_OPD_RELOCS
7717                       && !info->relocatable
7718                       && !dec_dynrel_count (rel->r_info, sec, info,
7719                                             NULL, h, sym))
7720                     goto error_ret;
7721                 }
7722               else
7723                 {
7724                   /* We need to adjust any reloc offsets to point to the
7725                      new opd entries.  While we're at it, we may as well
7726                      remove redundant relocs.  */
7727                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7728                   if (write_rel != rel)
7729                     memcpy (write_rel, rel, sizeof (*rel));
7730                   ++write_rel;
7731                 }
7732             }
7733
7734           sec->size = wptr - new_contents;
7735           sec->reloc_count = write_rel - relstart;
7736           if (add_aux_fields)
7737             {
7738               free (sec->contents);
7739               sec->contents = new_contents;
7740             }
7741
7742           /* Fudge the header size too, as this is used later in
7743              elf_bfd_final_link if we are emitting relocs.  */
7744           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7745           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7746           some_edited = TRUE;
7747         }
7748       else if (elf_section_data (sec)->relocs != relstart)
7749         free (relstart);
7750
7751       if (local_syms != NULL
7752           && symtab_hdr->contents != (unsigned char *) local_syms)
7753         {
7754           if (!info->keep_memory)
7755             free (local_syms);
7756           else
7757             symtab_hdr->contents = (unsigned char *) local_syms;
7758         }
7759     }
7760
7761   if (some_edited)
7762     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7763
7764   /* If we are doing a final link and the last .opd entry is just 16 byte
7765      long, add a 8 byte padding after it.  */
7766   if (need_pad != NULL && !info->relocatable)
7767     {
7768       bfd_byte *p;
7769
7770       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7771         {
7772           BFD_ASSERT (need_pad->size > 0);
7773
7774           p = bfd_malloc (need_pad->size + 8);
7775           if (p == NULL)
7776             return FALSE;
7777
7778           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7779                                           p, 0, need_pad->size))
7780             return FALSE;
7781
7782           need_pad->contents = p;
7783           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7784         }
7785       else
7786         {
7787           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7788           if (p == NULL)
7789             return FALSE;
7790
7791           need_pad->contents = p;
7792         }
7793
7794       memset (need_pad->contents + need_pad->size, 0, 8);
7795       need_pad->size += 8;
7796     }
7797
7798   return TRUE;
7799 }
7800
7801 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7802
7803 asection *
7804 ppc64_elf_tls_setup (struct bfd_link_info *info,
7805                      int no_tls_get_addr_opt,
7806                      int *no_multi_toc)
7807 {
7808   struct ppc_link_hash_table *htab;
7809
7810   htab = ppc_hash_table (info);
7811   if (htab == NULL)
7812     return NULL;
7813
7814   if (abiversion (info->output_bfd) == 1)
7815     htab->opd_abi = 1;
7816
7817   if (*no_multi_toc)
7818     htab->do_multi_toc = 0;
7819   else if (!htab->do_multi_toc)
7820     *no_multi_toc = 1;
7821
7822   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7823                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7824                                               FALSE, FALSE, TRUE));
7825   /* Move dynamic linking info to the function descriptor sym.  */
7826   if (htab->tls_get_addr != NULL)
7827     func_desc_adjust (&htab->tls_get_addr->elf, info);
7828   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7829                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7830                                                  FALSE, FALSE, TRUE));
7831   if (!no_tls_get_addr_opt)
7832     {
7833       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7834
7835       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7836                                   FALSE, FALSE, TRUE);
7837       if (opt != NULL)
7838         func_desc_adjust (opt, info);
7839       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7840                                      FALSE, FALSE, TRUE);
7841       if (opt_fd != NULL
7842           && (opt_fd->root.type == bfd_link_hash_defined
7843               || opt_fd->root.type == bfd_link_hash_defweak))
7844         {
7845           /* If glibc supports an optimized __tls_get_addr call stub,
7846              signalled by the presence of __tls_get_addr_opt, and we'll
7847              be calling __tls_get_addr via a plt call stub, then
7848              make __tls_get_addr point to __tls_get_addr_opt.  */
7849           tga_fd = &htab->tls_get_addr_fd->elf;
7850           if (htab->elf.dynamic_sections_created
7851               && tga_fd != NULL
7852               && (tga_fd->type == STT_FUNC
7853                   || tga_fd->needs_plt)
7854               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7855                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7856                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7857             {
7858               struct plt_entry *ent;
7859
7860               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7861                 if (ent->plt.refcount > 0)
7862                   break;
7863               if (ent != NULL)
7864                 {
7865                   tga_fd->root.type = bfd_link_hash_indirect;
7866                   tga_fd->root.u.i.link = &opt_fd->root;
7867                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7868                   if (opt_fd->dynindx != -1)
7869                     {
7870                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7871                       opt_fd->dynindx = -1;
7872                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7873                                               opt_fd->dynstr_index);
7874                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7875                         return NULL;
7876                     }
7877                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7878                   tga = &htab->tls_get_addr->elf;
7879                   if (opt != NULL && tga != NULL)
7880                     {
7881                       tga->root.type = bfd_link_hash_indirect;
7882                       tga->root.u.i.link = &opt->root;
7883                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7884                       _bfd_elf_link_hash_hide_symbol (info, opt,
7885                                                       tga->forced_local);
7886                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7887                     }
7888                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7889                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7890                   if (htab->tls_get_addr != NULL)
7891                     {
7892                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7893                       htab->tls_get_addr->is_func = 1;
7894                     }
7895                 }
7896             }
7897         }
7898       else
7899         no_tls_get_addr_opt = TRUE;
7900     }
7901   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7902   return _bfd_elf_tls_setup (info->output_bfd, info);
7903 }
7904
7905 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7906    HASH1 or HASH2.  */
7907
7908 static bfd_boolean
7909 branch_reloc_hash_match (const bfd *ibfd,
7910                          const Elf_Internal_Rela *rel,
7911                          const struct ppc_link_hash_entry *hash1,
7912                          const struct ppc_link_hash_entry *hash2)
7913 {
7914   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7915   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7916   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7917
7918   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7919     {
7920       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7921       struct elf_link_hash_entry *h;
7922
7923       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7924       h = elf_follow_link (h);
7925       if (h == &hash1->elf || h == &hash2->elf)
7926         return TRUE;
7927     }
7928   return FALSE;
7929 }
7930
7931 /* Run through all the TLS relocs looking for optimization
7932    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7933    a preliminary section layout so that we know the TLS segment
7934    offsets.  We can't optimize earlier because some optimizations need
7935    to know the tp offset, and we need to optimize before allocating
7936    dynamic relocations.  */
7937
7938 bfd_boolean
7939 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7940 {
7941   bfd *ibfd;
7942   asection *sec;
7943   struct ppc_link_hash_table *htab;
7944   unsigned char *toc_ref;
7945   int pass;
7946
7947   if (info->relocatable || !info->executable)
7948     return TRUE;
7949
7950   htab = ppc_hash_table (info);
7951   if (htab == NULL)
7952     return FALSE;
7953
7954   /* Make two passes over the relocs.  On the first pass, mark toc
7955      entries involved with tls relocs, and check that tls relocs
7956      involved in setting up a tls_get_addr call are indeed followed by
7957      such a call.  If they are not, we can't do any tls optimization.
7958      On the second pass twiddle tls_mask flags to notify
7959      relocate_section that optimization can be done, and adjust got
7960      and plt refcounts.  */
7961   toc_ref = NULL;
7962   for (pass = 0; pass < 2; ++pass)
7963     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7964       {
7965         Elf_Internal_Sym *locsyms = NULL;
7966         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7967
7968         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7969           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7970             {
7971               Elf_Internal_Rela *relstart, *rel, *relend;
7972               bfd_boolean found_tls_get_addr_arg = 0;
7973
7974               /* Read the relocations.  */
7975               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7976                                                     info->keep_memory);
7977               if (relstart == NULL)
7978                 return FALSE;
7979
7980               relend = relstart + sec->reloc_count;
7981               for (rel = relstart; rel < relend; rel++)
7982                 {
7983                   enum elf_ppc64_reloc_type r_type;
7984                   unsigned long r_symndx;
7985                   struct elf_link_hash_entry *h;
7986                   Elf_Internal_Sym *sym;
7987                   asection *sym_sec;
7988                   unsigned char *tls_mask;
7989                   unsigned char tls_set, tls_clear, tls_type = 0;
7990                   bfd_vma value;
7991                   bfd_boolean ok_tprel, is_local;
7992                   long toc_ref_index = 0;
7993                   int expecting_tls_get_addr = 0;
7994                   bfd_boolean ret = FALSE;
7995
7996                   r_symndx = ELF64_R_SYM (rel->r_info);
7997                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7998                                   r_symndx, ibfd))
7999                     {
8000                     err_free_rel:
8001                       if (elf_section_data (sec)->relocs != relstart)
8002                         free (relstart);
8003                       if (toc_ref != NULL)
8004                         free (toc_ref);
8005                       if (locsyms != NULL
8006                           && (elf_symtab_hdr (ibfd).contents
8007                               != (unsigned char *) locsyms))
8008                         free (locsyms);
8009                       return ret;
8010                     }
8011
8012                   if (h != NULL)
8013                     {
8014                       if (h->root.type == bfd_link_hash_defined
8015                           || h->root.type == bfd_link_hash_defweak)
8016                         value = h->root.u.def.value;
8017                       else if (h->root.type == bfd_link_hash_undefweak)
8018                         value = 0;
8019                       else
8020                         {
8021                           found_tls_get_addr_arg = 0;
8022                           continue;
8023                         }
8024                     }
8025                   else
8026                     /* Symbols referenced by TLS relocs must be of type
8027                        STT_TLS.  So no need for .opd local sym adjust.  */
8028                     value = sym->st_value;
8029
8030                   ok_tprel = FALSE;
8031                   is_local = FALSE;
8032                   if (h == NULL
8033                       || !h->def_dynamic)
8034                     {
8035                       is_local = TRUE;
8036                       if (h != NULL
8037                           && h->root.type == bfd_link_hash_undefweak)
8038                         ok_tprel = TRUE;
8039                       else
8040                         {
8041                           value += sym_sec->output_offset;
8042                           value += sym_sec->output_section->vma;
8043                           value -= htab->elf.tls_sec->vma;
8044                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8045                                       < (bfd_vma) 1 << 32);
8046                         }
8047                     }
8048
8049                   r_type = ELF64_R_TYPE (rel->r_info);
8050                   /* If this section has old-style __tls_get_addr calls
8051                      without marker relocs, then check that each
8052                      __tls_get_addr call reloc is preceded by a reloc
8053                      that conceivably belongs to the __tls_get_addr arg
8054                      setup insn.  If we don't find matching arg setup
8055                      relocs, don't do any tls optimization.  */
8056                   if (pass == 0
8057                       && sec->has_tls_get_addr_call
8058                       && h != NULL
8059                       && (h == &htab->tls_get_addr->elf
8060                           || h == &htab->tls_get_addr_fd->elf)
8061                       && !found_tls_get_addr_arg
8062                       && is_branch_reloc (r_type))
8063                     {
8064                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8065                                                 "TLS optimization disabled\n"),
8066                                               ibfd, sec, rel->r_offset);
8067                       ret = TRUE;
8068                       goto err_free_rel;
8069                     }
8070
8071                   found_tls_get_addr_arg = 0;
8072                   switch (r_type)
8073                     {
8074                     case R_PPC64_GOT_TLSLD16:
8075                     case R_PPC64_GOT_TLSLD16_LO:
8076                       expecting_tls_get_addr = 1;
8077                       found_tls_get_addr_arg = 1;
8078                       /* Fall thru */
8079
8080                     case R_PPC64_GOT_TLSLD16_HI:
8081                     case R_PPC64_GOT_TLSLD16_HA:
8082                       /* These relocs should never be against a symbol
8083                          defined in a shared lib.  Leave them alone if
8084                          that turns out to be the case.  */
8085                       if (!is_local)
8086                         continue;
8087
8088                       /* LD -> LE */
8089                       tls_set = 0;
8090                       tls_clear = TLS_LD;
8091                       tls_type = TLS_TLS | TLS_LD;
8092                       break;
8093
8094                     case R_PPC64_GOT_TLSGD16:
8095                     case R_PPC64_GOT_TLSGD16_LO:
8096                       expecting_tls_get_addr = 1;
8097                       found_tls_get_addr_arg = 1;
8098                       /* Fall thru */
8099
8100                     case R_PPC64_GOT_TLSGD16_HI:
8101                     case R_PPC64_GOT_TLSGD16_HA:
8102                       if (ok_tprel)
8103                         /* GD -> LE */
8104                         tls_set = 0;
8105                       else
8106                         /* GD -> IE */
8107                         tls_set = TLS_TLS | TLS_TPRELGD;
8108                       tls_clear = TLS_GD;
8109                       tls_type = TLS_TLS | TLS_GD;
8110                       break;
8111
8112                     case R_PPC64_GOT_TPREL16_DS:
8113                     case R_PPC64_GOT_TPREL16_LO_DS:
8114                     case R_PPC64_GOT_TPREL16_HI:
8115                     case R_PPC64_GOT_TPREL16_HA:
8116                       if (ok_tprel)
8117                         {
8118                           /* IE -> LE */
8119                           tls_set = 0;
8120                           tls_clear = TLS_TPREL;
8121                           tls_type = TLS_TLS | TLS_TPREL;
8122                           break;
8123                         }
8124                       continue;
8125
8126                     case R_PPC64_TLSGD:
8127                     case R_PPC64_TLSLD:
8128                       found_tls_get_addr_arg = 1;
8129                       /* Fall thru */
8130
8131                     case R_PPC64_TLS:
8132                     case R_PPC64_TOC16:
8133                     case R_PPC64_TOC16_LO:
8134                       if (sym_sec == NULL || sym_sec != toc)
8135                         continue;
8136
8137                       /* Mark this toc entry as referenced by a TLS
8138                          code sequence.  We can do that now in the
8139                          case of R_PPC64_TLS, and after checking for
8140                          tls_get_addr for the TOC16 relocs.  */
8141                       if (toc_ref == NULL)
8142                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8143                       if (toc_ref == NULL)
8144                         goto err_free_rel;
8145
8146                       if (h != NULL)
8147                         value = h->root.u.def.value;
8148                       else
8149                         value = sym->st_value;
8150                       value += rel->r_addend;
8151                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8152                       toc_ref_index = (value + toc->output_offset) / 8;
8153                       if (r_type == R_PPC64_TLS
8154                           || r_type == R_PPC64_TLSGD
8155                           || r_type == R_PPC64_TLSLD)
8156                         {
8157                           toc_ref[toc_ref_index] = 1;
8158                           continue;
8159                         }
8160
8161                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8162                         continue;
8163
8164                       tls_set = 0;
8165                       tls_clear = 0;
8166                       expecting_tls_get_addr = 2;
8167                       break;
8168
8169                     case R_PPC64_TPREL64:
8170                       if (pass == 0
8171                           || sec != toc
8172                           || toc_ref == NULL
8173                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8174                         continue;
8175                       if (ok_tprel)
8176                         {
8177                           /* IE -> LE */
8178                           tls_set = TLS_EXPLICIT;
8179                           tls_clear = TLS_TPREL;
8180                           break;
8181                         }
8182                       continue;
8183
8184                     case R_PPC64_DTPMOD64:
8185                       if (pass == 0
8186                           || sec != toc
8187                           || toc_ref == NULL
8188                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8189                         continue;
8190                       if (rel + 1 < relend
8191                           && (rel[1].r_info
8192                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8193                           && rel[1].r_offset == rel->r_offset + 8)
8194                         {
8195                           if (ok_tprel)
8196                             /* GD -> LE */
8197                             tls_set = TLS_EXPLICIT | TLS_GD;
8198                           else
8199                             /* GD -> IE */
8200                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8201                           tls_clear = TLS_GD;
8202                         }
8203                       else
8204                         {
8205                           if (!is_local)
8206                             continue;
8207
8208                           /* LD -> LE */
8209                           tls_set = TLS_EXPLICIT;
8210                           tls_clear = TLS_LD;
8211                         }
8212                       break;
8213
8214                     default:
8215                       continue;
8216                     }
8217
8218                   if (pass == 0)
8219                     {
8220                       if (!expecting_tls_get_addr
8221                           || !sec->has_tls_get_addr_call)
8222                         continue;
8223
8224                       if (rel + 1 < relend
8225                           && branch_reloc_hash_match (ibfd, rel + 1,
8226                                                       htab->tls_get_addr,
8227                                                       htab->tls_get_addr_fd))
8228                         {
8229                           if (expecting_tls_get_addr == 2)
8230                             {
8231                               /* Check for toc tls entries.  */
8232                               unsigned char *toc_tls;
8233                               int retval;
8234
8235                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8236                                                      &locsyms,
8237                                                      rel, ibfd);
8238                               if (retval == 0)
8239                                 goto err_free_rel;
8240                               if (toc_tls != NULL)
8241                                 {
8242                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8243                                     found_tls_get_addr_arg = 1;
8244                                   if (retval > 1)
8245                                     toc_ref[toc_ref_index] = 1;
8246                                 }
8247                             }
8248                           continue;
8249                         }
8250
8251                       if (expecting_tls_get_addr != 1)
8252                         continue;
8253
8254                       /* Uh oh, we didn't find the expected call.  We
8255                          could just mark this symbol to exclude it
8256                          from tls optimization but it's safer to skip
8257                          the entire optimization.  */
8258                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8259                                                 "TLS optimization disabled\n"),
8260                                               ibfd, sec, rel->r_offset);
8261                       ret = TRUE;
8262                       goto err_free_rel;
8263                     }
8264
8265                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8266                     {
8267                       struct plt_entry *ent;
8268                       for (ent = htab->tls_get_addr->elf.plt.plist;
8269                            ent != NULL;
8270                            ent = ent->next)
8271                         if (ent->addend == 0)
8272                           {
8273                             if (ent->plt.refcount > 0)
8274                               {
8275                                 ent->plt.refcount -= 1;
8276                                 expecting_tls_get_addr = 0;
8277                               }
8278                             break;
8279                           }
8280                     }
8281
8282                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8283                     {
8284                       struct plt_entry *ent;
8285                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8286                            ent != NULL;
8287                            ent = ent->next)
8288                         if (ent->addend == 0)
8289                           {
8290                             if (ent->plt.refcount > 0)
8291                               ent->plt.refcount -= 1;
8292                             break;
8293                           }
8294                     }
8295
8296                   if (tls_clear == 0)
8297                     continue;
8298
8299                   if ((tls_set & TLS_EXPLICIT) == 0)
8300                     {
8301                       struct got_entry *ent;
8302
8303                       /* Adjust got entry for this reloc.  */
8304                       if (h != NULL)
8305                         ent = h->got.glist;
8306                       else
8307                         ent = elf_local_got_ents (ibfd)[r_symndx];
8308
8309                       for (; ent != NULL; ent = ent->next)
8310                         if (ent->addend == rel->r_addend
8311                             && ent->owner == ibfd
8312                             && ent->tls_type == tls_type)
8313                           break;
8314                       if (ent == NULL)
8315                         abort ();
8316
8317                       if (tls_set == 0)
8318                         {
8319                           /* We managed to get rid of a got entry.  */
8320                           if (ent->got.refcount > 0)
8321                             ent->got.refcount -= 1;
8322                         }
8323                     }
8324                   else
8325                     {
8326                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8327                          we'll lose one or two dyn relocs.  */
8328                       if (!dec_dynrel_count (rel->r_info, sec, info,
8329                                              NULL, h, sym))
8330                         return FALSE;
8331
8332                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8333                         {
8334                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8335                                                  NULL, h, sym))
8336                             return FALSE;
8337                         }
8338                     }
8339
8340                   *tls_mask |= tls_set;
8341                   *tls_mask &= ~tls_clear;
8342                 }
8343
8344               if (elf_section_data (sec)->relocs != relstart)
8345                 free (relstart);
8346             }
8347
8348         if (locsyms != NULL
8349             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8350           {
8351             if (!info->keep_memory)
8352               free (locsyms);
8353             else
8354               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8355           }
8356       }
8357
8358   if (toc_ref != NULL)
8359     free (toc_ref);
8360   return TRUE;
8361 }
8362
8363 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8364    the values of any global symbols in a toc section that has been
8365    edited.  Globals in toc sections should be a rarity, so this function
8366    sets a flag if any are found in toc sections other than the one just
8367    edited, so that futher hash table traversals can be avoided.  */
8368
8369 struct adjust_toc_info
8370 {
8371   asection *toc;
8372   unsigned long *skip;
8373   bfd_boolean global_toc_syms;
8374 };
8375
8376 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8377
8378 static bfd_boolean
8379 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8380 {
8381   struct ppc_link_hash_entry *eh;
8382   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8383   unsigned long i;
8384
8385   if (h->root.type != bfd_link_hash_defined
8386       && h->root.type != bfd_link_hash_defweak)
8387     return TRUE;
8388
8389   eh = (struct ppc_link_hash_entry *) h;
8390   if (eh->adjust_done)
8391     return TRUE;
8392
8393   if (eh->elf.root.u.def.section == toc_inf->toc)
8394     {
8395       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8396         i = toc_inf->toc->rawsize >> 3;
8397       else
8398         i = eh->elf.root.u.def.value >> 3;
8399
8400       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8401         {
8402           (*_bfd_error_handler)
8403             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8404           do
8405             ++i;
8406           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8407           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8408         }
8409
8410       eh->elf.root.u.def.value -= toc_inf->skip[i];
8411       eh->adjust_done = 1;
8412     }
8413   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8414     toc_inf->global_toc_syms = TRUE;
8415
8416   return TRUE;
8417 }
8418
8419 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8420
8421 static bfd_boolean
8422 ok_lo_toc_insn (unsigned int insn)
8423 {
8424   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8425           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8426           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8427           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8428           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8429           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8430           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8431           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8432           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8433           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8434           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8435           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8436           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8437           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8438           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8439               && (insn & 3) != 1)
8440           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8441               && ((insn & 3) == 0 || (insn & 3) == 3))
8442           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8443 }
8444
8445 /* Examine all relocs referencing .toc sections in order to remove
8446    unused .toc entries.  */
8447
8448 bfd_boolean
8449 ppc64_elf_edit_toc (struct bfd_link_info *info)
8450 {
8451   bfd *ibfd;
8452   struct adjust_toc_info toc_inf;
8453   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8454
8455   htab->do_toc_opt = 1;
8456   toc_inf.global_toc_syms = TRUE;
8457   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8458     {
8459       asection *toc, *sec;
8460       Elf_Internal_Shdr *symtab_hdr;
8461       Elf_Internal_Sym *local_syms;
8462       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8463       unsigned long *skip, *drop;
8464       unsigned char *used;
8465       unsigned char *keep, last, some_unused;
8466
8467       if (!is_ppc64_elf (ibfd))
8468         continue;
8469
8470       toc = bfd_get_section_by_name (ibfd, ".toc");
8471       if (toc == NULL
8472           || toc->size == 0
8473           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8474           || discarded_section (toc))
8475         continue;
8476
8477       toc_relocs = NULL;
8478       local_syms = NULL;
8479       symtab_hdr = &elf_symtab_hdr (ibfd);
8480
8481       /* Look at sections dropped from the final link.  */
8482       skip = NULL;
8483       relstart = NULL;
8484       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8485         {
8486           if (sec->reloc_count == 0
8487               || !discarded_section (sec)
8488               || get_opd_info (sec)
8489               || (sec->flags & SEC_ALLOC) == 0
8490               || (sec->flags & SEC_DEBUGGING) != 0)
8491             continue;
8492
8493           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8494           if (relstart == NULL)
8495             goto error_ret;
8496
8497           /* Run through the relocs to see which toc entries might be
8498              unused.  */
8499           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8500             {
8501               enum elf_ppc64_reloc_type r_type;
8502               unsigned long r_symndx;
8503               asection *sym_sec;
8504               struct elf_link_hash_entry *h;
8505               Elf_Internal_Sym *sym;
8506               bfd_vma val;
8507
8508               r_type = ELF64_R_TYPE (rel->r_info);
8509               switch (r_type)
8510                 {
8511                 default:
8512                   continue;
8513
8514                 case R_PPC64_TOC16:
8515                 case R_PPC64_TOC16_LO:
8516                 case R_PPC64_TOC16_HI:
8517                 case R_PPC64_TOC16_HA:
8518                 case R_PPC64_TOC16_DS:
8519                 case R_PPC64_TOC16_LO_DS:
8520                   break;
8521                 }
8522
8523               r_symndx = ELF64_R_SYM (rel->r_info);
8524               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8525                               r_symndx, ibfd))
8526                 goto error_ret;
8527
8528               if (sym_sec != toc)
8529                 continue;
8530
8531               if (h != NULL)
8532                 val = h->root.u.def.value;
8533               else
8534                 val = sym->st_value;
8535               val += rel->r_addend;
8536
8537               if (val >= toc->size)
8538                 continue;
8539
8540               /* Anything in the toc ought to be aligned to 8 bytes.
8541                  If not, don't mark as unused.  */
8542               if (val & 7)
8543                 continue;
8544
8545               if (skip == NULL)
8546                 {
8547                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8548                   if (skip == NULL)
8549                     goto error_ret;
8550                 }
8551
8552               skip[val >> 3] = ref_from_discarded;
8553             }
8554
8555           if (elf_section_data (sec)->relocs != relstart)
8556             free (relstart);
8557         }
8558
8559       /* For largetoc loads of address constants, we can convert
8560          .  addis rx,2,addr@got@ha
8561          .  ld ry,addr@got@l(rx)
8562          to
8563          .  addis rx,2,addr@toc@ha
8564          .  addi ry,rx,addr@toc@l
8565          when addr is within 2G of the toc pointer.  This then means
8566          that the word storing "addr" in the toc is no longer needed.  */
8567
8568       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8569           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8570           && toc->reloc_count != 0)
8571         {
8572           /* Read toc relocs.  */
8573           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8574                                                   info->keep_memory);
8575           if (toc_relocs == NULL)
8576             goto error_ret;
8577
8578           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8579             {
8580               enum elf_ppc64_reloc_type r_type;
8581               unsigned long r_symndx;
8582               asection *sym_sec;
8583               struct elf_link_hash_entry *h;
8584               Elf_Internal_Sym *sym;
8585               bfd_vma val, addr;
8586
8587               r_type = ELF64_R_TYPE (rel->r_info);
8588               if (r_type != R_PPC64_ADDR64)
8589                 continue;
8590
8591               r_symndx = ELF64_R_SYM (rel->r_info);
8592               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8593                               r_symndx, ibfd))
8594                 goto error_ret;
8595
8596               if (sym_sec == NULL
8597                   || discarded_section (sym_sec))
8598                 continue;
8599
8600               if (!SYMBOL_CALLS_LOCAL (info, h))
8601                 continue;
8602
8603               if (h != NULL)
8604                 {
8605                   if (h->type == STT_GNU_IFUNC)
8606                     continue;
8607                   val = h->root.u.def.value;
8608                 }
8609               else
8610                 {
8611                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8612                     continue;
8613                   val = sym->st_value;
8614                 }
8615               val += rel->r_addend;
8616               val += sym_sec->output_section->vma + sym_sec->output_offset;
8617
8618               /* We don't yet know the exact toc pointer value, but we
8619                  know it will be somewhere in the toc section.  Don't
8620                  optimize if the difference from any possible toc
8621                  pointer is outside [ff..f80008000, 7fff7fff].  */
8622               addr = toc->output_section->vma + TOC_BASE_OFF;
8623               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8624                 continue;
8625
8626               addr = toc->output_section->vma + toc->output_section->rawsize;
8627               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8628                 continue;
8629
8630               if (skip == NULL)
8631                 {
8632                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8633                   if (skip == NULL)
8634                     goto error_ret;
8635                 }
8636
8637               skip[rel->r_offset >> 3]
8638                 |= can_optimize | ((rel - toc_relocs) << 2);
8639             }
8640         }
8641
8642       if (skip == NULL)
8643         continue;
8644
8645       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8646       if (used == NULL)
8647         {
8648         error_ret:
8649           if (local_syms != NULL
8650               && symtab_hdr->contents != (unsigned char *) local_syms)
8651             free (local_syms);
8652           if (sec != NULL
8653               && relstart != NULL
8654               && elf_section_data (sec)->relocs != relstart)
8655             free (relstart);
8656           if (toc_relocs != NULL
8657               && elf_section_data (toc)->relocs != toc_relocs)
8658             free (toc_relocs);
8659           if (skip != NULL)
8660             free (skip);
8661           return FALSE;
8662         }
8663
8664       /* Now check all kept sections that might reference the toc.
8665          Check the toc itself last.  */
8666       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8667                   : ibfd->sections);
8668            sec != NULL;
8669            sec = (sec == toc ? NULL
8670                   : sec->next == NULL ? toc
8671                   : sec->next == toc && toc->next ? toc->next
8672                   : sec->next))
8673         {
8674           int repeat;
8675
8676           if (sec->reloc_count == 0
8677               || discarded_section (sec)
8678               || get_opd_info (sec)
8679               || (sec->flags & SEC_ALLOC) == 0
8680               || (sec->flags & SEC_DEBUGGING) != 0)
8681             continue;
8682
8683           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8684                                                 info->keep_memory);
8685           if (relstart == NULL)
8686             goto error_ret;
8687
8688           /* Mark toc entries referenced as used.  */
8689           do
8690             {
8691               repeat = 0;
8692               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8693                 {
8694                   enum elf_ppc64_reloc_type r_type;
8695                   unsigned long r_symndx;
8696                   asection *sym_sec;
8697                   struct elf_link_hash_entry *h;
8698                   Elf_Internal_Sym *sym;
8699                   bfd_vma val;
8700                   enum {no_check, check_lo, check_ha} insn_check;
8701
8702                   r_type = ELF64_R_TYPE (rel->r_info);
8703                   switch (r_type)
8704                     {
8705                     default:
8706                       insn_check = no_check;
8707                       break;
8708
8709                     case R_PPC64_GOT_TLSLD16_HA:
8710                     case R_PPC64_GOT_TLSGD16_HA:
8711                     case R_PPC64_GOT_TPREL16_HA:
8712                     case R_PPC64_GOT_DTPREL16_HA:
8713                     case R_PPC64_GOT16_HA:
8714                     case R_PPC64_TOC16_HA:
8715                       insn_check = check_ha;
8716                       break;
8717
8718                     case R_PPC64_GOT_TLSLD16_LO:
8719                     case R_PPC64_GOT_TLSGD16_LO:
8720                     case R_PPC64_GOT_TPREL16_LO_DS:
8721                     case R_PPC64_GOT_DTPREL16_LO_DS:
8722                     case R_PPC64_GOT16_LO:
8723                     case R_PPC64_GOT16_LO_DS:
8724                     case R_PPC64_TOC16_LO:
8725                     case R_PPC64_TOC16_LO_DS:
8726                       insn_check = check_lo;
8727                       break;
8728                     }
8729
8730                   if (insn_check != no_check)
8731                     {
8732                       bfd_vma off = rel->r_offset & ~3;
8733                       unsigned char buf[4];
8734                       unsigned int insn;
8735
8736                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8737                         {
8738                           free (used);
8739                           goto error_ret;
8740                         }
8741                       insn = bfd_get_32 (ibfd, buf);
8742                       if (insn_check == check_lo
8743                           ? !ok_lo_toc_insn (insn)
8744                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8745                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8746                         {
8747                           char str[12];
8748
8749                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8750                           sprintf (str, "%#08x", insn);
8751                           info->callbacks->einfo
8752                             (_("%P: %H: toc optimization is not supported for"
8753                                " %s instruction.\n"),
8754                              ibfd, sec, rel->r_offset & ~3, str);
8755                         }
8756                     }
8757
8758                   switch (r_type)
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                       /* In case we're taking addresses of toc entries.  */
8767                     case R_PPC64_ADDR64:
8768                       break;
8769
8770                     default:
8771                       continue;
8772                     }
8773
8774                   r_symndx = ELF64_R_SYM (rel->r_info);
8775                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8776                                   r_symndx, ibfd))
8777                     {
8778                       free (used);
8779                       goto error_ret;
8780                     }
8781
8782                   if (sym_sec != toc)
8783                     continue;
8784
8785                   if (h != NULL)
8786                     val = h->root.u.def.value;
8787                   else
8788                     val = sym->st_value;
8789                   val += rel->r_addend;
8790
8791                   if (val >= toc->size)
8792                     continue;
8793
8794                   if ((skip[val >> 3] & can_optimize) != 0)
8795                     {
8796                       bfd_vma off;
8797                       unsigned char opc;
8798
8799                       switch (r_type)
8800                         {
8801                         case R_PPC64_TOC16_HA:
8802                           break;
8803
8804                         case R_PPC64_TOC16_LO_DS:
8805                           off = rel->r_offset;
8806                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8807                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8808                                                          off, 1))
8809                             {
8810                               free (used);
8811                               goto error_ret;
8812                             }
8813                           if ((opc & (0x3f << 2)) == (58u << 2))
8814                             break;
8815                           /* Fall thru */
8816
8817                         default:
8818                           /* Wrong sort of reloc, or not a ld.  We may
8819                              as well clear ref_from_discarded too.  */
8820                           skip[val >> 3] = 0;
8821                         }
8822                     }
8823
8824                   if (sec != toc)
8825                     used[val >> 3] = 1;
8826                   /* For the toc section, we only mark as used if this
8827                      entry itself isn't unused.  */
8828                   else if ((used[rel->r_offset >> 3]
8829                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8830                            && !used[val >> 3])
8831                     {
8832                       /* Do all the relocs again, to catch reference
8833                          chains.  */
8834                       repeat = 1;
8835                       used[val >> 3] = 1;
8836                     }
8837                 }
8838             }
8839           while (repeat);
8840
8841           if (elf_section_data (sec)->relocs != relstart)
8842             free (relstart);
8843         }
8844
8845       /* Merge the used and skip arrays.  Assume that TOC
8846          doublewords not appearing as either used or unused belong
8847          to to an entry more than one doubleword in size.  */
8848       for (drop = skip, keep = used, last = 0, some_unused = 0;
8849            drop < skip + (toc->size + 7) / 8;
8850            ++drop, ++keep)
8851         {
8852           if (*keep)
8853             {
8854               *drop &= ~ref_from_discarded;
8855               if ((*drop & can_optimize) != 0)
8856                 some_unused = 1;
8857               last = 0;
8858             }
8859           else if ((*drop & ref_from_discarded) != 0)
8860             {
8861               some_unused = 1;
8862               last = ref_from_discarded;
8863             }
8864           else
8865             *drop = last;
8866         }
8867
8868       free (used);
8869
8870       if (some_unused)
8871         {
8872           bfd_byte *contents, *src;
8873           unsigned long off;
8874           Elf_Internal_Sym *sym;
8875           bfd_boolean local_toc_syms = FALSE;
8876
8877           /* Shuffle the toc contents, and at the same time convert the
8878              skip array from booleans into offsets.  */
8879           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8880             goto error_ret;
8881
8882           elf_section_data (toc)->this_hdr.contents = contents;
8883
8884           for (src = contents, off = 0, drop = skip;
8885                src < contents + toc->size;
8886                src += 8, ++drop)
8887             {
8888               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8889                 off += 8;
8890               else if (off != 0)
8891                 {
8892                   *drop = off;
8893                   memcpy (src - off, src, 8);
8894                 }
8895             }
8896           *drop = off;
8897           toc->rawsize = toc->size;
8898           toc->size = src - contents - off;
8899
8900           /* Adjust addends for relocs against the toc section sym,
8901              and optimize any accesses we can.  */
8902           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8903             {
8904               if (sec->reloc_count == 0
8905                   || discarded_section (sec))
8906                 continue;
8907
8908               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8909                                                     info->keep_memory);
8910               if (relstart == NULL)
8911                 goto error_ret;
8912
8913               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8914                 {
8915                   enum elf_ppc64_reloc_type r_type;
8916                   unsigned long r_symndx;
8917                   asection *sym_sec;
8918                   struct elf_link_hash_entry *h;
8919                   bfd_vma val;
8920
8921                   r_type = ELF64_R_TYPE (rel->r_info);
8922                   switch (r_type)
8923                     {
8924                     default:
8925                       continue;
8926
8927                     case R_PPC64_TOC16:
8928                     case R_PPC64_TOC16_LO:
8929                     case R_PPC64_TOC16_HI:
8930                     case R_PPC64_TOC16_HA:
8931                     case R_PPC64_TOC16_DS:
8932                     case R_PPC64_TOC16_LO_DS:
8933                     case R_PPC64_ADDR64:
8934                       break;
8935                     }
8936
8937                   r_symndx = ELF64_R_SYM (rel->r_info);
8938                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8939                                   r_symndx, ibfd))
8940                     goto error_ret;
8941
8942                   if (sym_sec != toc)
8943                     continue;
8944
8945                   if (h != NULL)
8946                     val = h->root.u.def.value;
8947                   else
8948                     {
8949                       val = sym->st_value;
8950                       if (val != 0)
8951                         local_toc_syms = TRUE;
8952                     }
8953
8954                   val += rel->r_addend;
8955
8956                   if (val > toc->rawsize)
8957                     val = toc->rawsize;
8958                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8959                     continue;
8960                   else if ((skip[val >> 3] & can_optimize) != 0)
8961                     {
8962                       Elf_Internal_Rela *tocrel
8963                         = toc_relocs + (skip[val >> 3] >> 2);
8964                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8965
8966                       switch (r_type)
8967                         {
8968                         case R_PPC64_TOC16_HA:
8969                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8970                           break;
8971
8972                         case R_PPC64_TOC16_LO_DS:
8973                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8974                           break;
8975
8976                         default:
8977                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8978                             ppc_howto_init ();
8979                           info->callbacks->einfo
8980                             (_("%P: %H: %s references "
8981                                "optimized away TOC entry\n"),
8982                              ibfd, sec, rel->r_offset,
8983                              ppc64_elf_howto_table[r_type]->name);
8984                           bfd_set_error (bfd_error_bad_value);
8985                           goto error_ret;
8986                         }
8987                       rel->r_addend = tocrel->r_addend;
8988                       elf_section_data (sec)->relocs = relstart;
8989                       continue;
8990                     }
8991
8992                   if (h != NULL || sym->st_value != 0)
8993                     continue;
8994
8995                   rel->r_addend -= skip[val >> 3];
8996                   elf_section_data (sec)->relocs = relstart;
8997                 }
8998
8999               if (elf_section_data (sec)->relocs != relstart)
9000                 free (relstart);
9001             }
9002
9003           /* We shouldn't have local or global symbols defined in the TOC,
9004              but handle them anyway.  */
9005           if (local_syms != NULL)
9006             for (sym = local_syms;
9007                  sym < local_syms + symtab_hdr->sh_info;
9008                  ++sym)
9009               if (sym->st_value != 0
9010                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9011                 {
9012                   unsigned long i;
9013
9014                   if (sym->st_value > toc->rawsize)
9015                     i = toc->rawsize >> 3;
9016                   else
9017                     i = sym->st_value >> 3;
9018
9019                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9020                     {
9021                       if (local_toc_syms)
9022                         (*_bfd_error_handler)
9023                           (_("%s defined on removed toc entry"),
9024                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9025                       do
9026                         ++i;
9027                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9028                       sym->st_value = (bfd_vma) i << 3;
9029                     }
9030
9031                   sym->st_value -= skip[i];
9032                   symtab_hdr->contents = (unsigned char *) local_syms;
9033                 }
9034
9035           /* Adjust any global syms defined in this toc input section.  */
9036           if (toc_inf.global_toc_syms)
9037             {
9038               toc_inf.toc = toc;
9039               toc_inf.skip = skip;
9040               toc_inf.global_toc_syms = FALSE;
9041               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9042                                       &toc_inf);
9043             }
9044
9045           if (toc->reloc_count != 0)
9046             {
9047               Elf_Internal_Shdr *rel_hdr;
9048               Elf_Internal_Rela *wrel;
9049               bfd_size_type sz;
9050
9051               /* Remove unused toc relocs, and adjust those we keep.  */
9052               if (toc_relocs == NULL)
9053                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9054                                                         info->keep_memory);
9055               if (toc_relocs == NULL)
9056                 goto error_ret;
9057
9058               wrel = toc_relocs;
9059               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9060                 if ((skip[rel->r_offset >> 3]
9061                      & (ref_from_discarded | can_optimize)) == 0)
9062                   {
9063                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9064                     wrel->r_info = rel->r_info;
9065                     wrel->r_addend = rel->r_addend;
9066                     ++wrel;
9067                   }
9068                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9069                                             &local_syms, NULL, NULL))
9070                   goto error_ret;
9071
9072               elf_section_data (toc)->relocs = toc_relocs;
9073               toc->reloc_count = wrel - toc_relocs;
9074               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9075               sz = rel_hdr->sh_entsize;
9076               rel_hdr->sh_size = toc->reloc_count * sz;
9077             }
9078         }
9079       else if (toc_relocs != NULL
9080                && elf_section_data (toc)->relocs != toc_relocs)
9081         free (toc_relocs);
9082
9083       if (local_syms != NULL
9084           && symtab_hdr->contents != (unsigned char *) local_syms)
9085         {
9086           if (!info->keep_memory)
9087             free (local_syms);
9088           else
9089             symtab_hdr->contents = (unsigned char *) local_syms;
9090         }
9091       free (skip);
9092     }
9093
9094   return TRUE;
9095 }
9096
9097 /* Return true iff input section I references the TOC using
9098    instructions limited to +/-32k offsets.  */
9099
9100 bfd_boolean
9101 ppc64_elf_has_small_toc_reloc (asection *i)
9102 {
9103   return (is_ppc64_elf (i->owner)
9104           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9105 }
9106
9107 /* Allocate space for one GOT entry.  */
9108
9109 static void
9110 allocate_got (struct elf_link_hash_entry *h,
9111               struct bfd_link_info *info,
9112               struct got_entry *gent)
9113 {
9114   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9115   bfd_boolean dyn;
9116   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9117   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9118                  ? 16 : 8);
9119   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9120                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9121   asection *got = ppc64_elf_tdata (gent->owner)->got;
9122
9123   gent->got.offset = got->size;
9124   got->size += entsize;
9125
9126   dyn = htab->elf.dynamic_sections_created;
9127   if (h->type == STT_GNU_IFUNC)
9128     {
9129       htab->reliplt->size += rentsize;
9130       htab->got_reli_size += rentsize;
9131     }
9132   else if ((info->shared
9133             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9134            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9135                || h->root.type != bfd_link_hash_undefweak))
9136     {
9137       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9138       relgot->size += rentsize;
9139     }
9140 }
9141
9142 /* This function merges got entries in the same toc group.  */
9143
9144 static void
9145 merge_got_entries (struct got_entry **pent)
9146 {
9147   struct got_entry *ent, *ent2;
9148
9149   for (ent = *pent; ent != NULL; ent = ent->next)
9150     if (!ent->is_indirect)
9151       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9152         if (!ent2->is_indirect
9153             && ent2->addend == ent->addend
9154             && ent2->tls_type == ent->tls_type
9155             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9156           {
9157             ent2->is_indirect = TRUE;
9158             ent2->got.ent = ent;
9159           }
9160 }
9161
9162 /* Allocate space in .plt, .got and associated reloc sections for
9163    dynamic relocs.  */
9164
9165 static bfd_boolean
9166 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9167 {
9168   struct bfd_link_info *info;
9169   struct ppc_link_hash_table *htab;
9170   asection *s;
9171   struct ppc_link_hash_entry *eh;
9172   struct elf_dyn_relocs *p;
9173   struct got_entry **pgent, *gent;
9174
9175   if (h->root.type == bfd_link_hash_indirect)
9176     return TRUE;
9177
9178   info = (struct bfd_link_info *) inf;
9179   htab = ppc_hash_table (info);
9180   if (htab == NULL)
9181     return FALSE;
9182
9183   if ((htab->elf.dynamic_sections_created
9184        && h->dynindx != -1
9185        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9186       || h->type == STT_GNU_IFUNC)
9187     {
9188       struct plt_entry *pent;
9189       bfd_boolean doneone = FALSE;
9190       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9191         if (pent->plt.refcount > 0)
9192           {
9193             if (!htab->elf.dynamic_sections_created
9194                 || h->dynindx == -1)
9195               {
9196                 s = htab->iplt;
9197                 pent->plt.offset = s->size;
9198                 s->size += PLT_ENTRY_SIZE;
9199                 s = htab->reliplt;
9200               }
9201             else
9202               {
9203                 /* If this is the first .plt entry, make room for the special
9204                    first entry.  */
9205                 s = htab->plt;
9206                 if (s->size == 0)
9207                   s->size += PLT_INITIAL_ENTRY_SIZE;
9208
9209                 pent->plt.offset = s->size;
9210
9211                 /* Make room for this entry.  */
9212                 s->size += PLT_ENTRY_SIZE;
9213
9214                 /* Make room for the .glink code.  */
9215                 s = htab->glink;
9216                 if (s->size == 0)
9217                   s->size += GLINK_CALL_STUB_SIZE;
9218                 /* We need bigger stubs past index 32767.  */
9219                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9220                   s->size += 4;
9221                 s->size += 2*4;
9222
9223                 /* We also need to make an entry in the .rela.plt section.  */
9224                 s = htab->relplt;
9225               }
9226             s->size += sizeof (Elf64_External_Rela);
9227             doneone = TRUE;
9228           }
9229         else
9230           pent->plt.offset = (bfd_vma) -1;
9231       if (!doneone)
9232         {
9233           h->plt.plist = NULL;
9234           h->needs_plt = 0;
9235         }
9236     }
9237   else
9238     {
9239       h->plt.plist = NULL;
9240       h->needs_plt = 0;
9241     }
9242
9243   eh = (struct ppc_link_hash_entry *) h;
9244   /* Run through the TLS GD got entries first if we're changing them
9245      to TPREL.  */
9246   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9247     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9248       if (gent->got.refcount > 0
9249           && (gent->tls_type & TLS_GD) != 0)
9250         {
9251           /* This was a GD entry that has been converted to TPREL.  If
9252              there happens to be a TPREL entry we can use that one.  */
9253           struct got_entry *ent;
9254           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9255             if (ent->got.refcount > 0
9256                 && (ent->tls_type & TLS_TPREL) != 0
9257                 && ent->addend == gent->addend
9258                 && ent->owner == gent->owner)
9259               {
9260                 gent->got.refcount = 0;
9261                 break;
9262               }
9263
9264           /* If not, then we'll be using our own TPREL entry.  */
9265           if (gent->got.refcount != 0)
9266             gent->tls_type = TLS_TLS | TLS_TPREL;
9267         }
9268
9269   /* Remove any list entry that won't generate a word in the GOT before
9270      we call merge_got_entries.  Otherwise we risk merging to empty
9271      entries.  */
9272   pgent = &h->got.glist;
9273   while ((gent = *pgent) != NULL)
9274     if (gent->got.refcount > 0)
9275       {
9276         if ((gent->tls_type & TLS_LD) != 0
9277             && !h->def_dynamic)
9278           {
9279             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9280             *pgent = gent->next;
9281           }
9282         else
9283           pgent = &gent->next;
9284       }
9285     else
9286       *pgent = gent->next;
9287
9288   if (!htab->do_multi_toc)
9289     merge_got_entries (&h->got.glist);
9290
9291   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9292     if (!gent->is_indirect)
9293       {
9294         /* Make sure this symbol is output as a dynamic symbol.
9295            Undefined weak syms won't yet be marked as dynamic,
9296            nor will all TLS symbols.  */
9297         if (h->dynindx == -1
9298             && !h->forced_local
9299             && h->type != STT_GNU_IFUNC
9300             && htab->elf.dynamic_sections_created)
9301           {
9302             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9303               return FALSE;
9304           }
9305
9306         if (!is_ppc64_elf (gent->owner))
9307           abort ();
9308
9309         allocate_got (h, info, gent);
9310       }
9311
9312   if (eh->dyn_relocs == NULL
9313       || (!htab->elf.dynamic_sections_created
9314           && h->type != STT_GNU_IFUNC))
9315     return TRUE;
9316
9317   /* In the shared -Bsymbolic case, discard space allocated for
9318      dynamic pc-relative relocs against symbols which turn out to be
9319      defined in regular objects.  For the normal shared case, discard
9320      space for relocs that have become local due to symbol visibility
9321      changes.  */
9322
9323   if (info->shared)
9324     {
9325       /* Relocs that use pc_count are those that appear on a call insn,
9326          or certain REL relocs (see must_be_dyn_reloc) that can be
9327          generated via assembly.  We want calls to protected symbols to
9328          resolve directly to the function rather than going via the plt.
9329          If people want function pointer comparisons to work as expected
9330          then they should avoid writing weird assembly.  */
9331       if (SYMBOL_CALLS_LOCAL (info, h))
9332         {
9333           struct elf_dyn_relocs **pp;
9334
9335           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9336             {
9337               p->count -= p->pc_count;
9338               p->pc_count = 0;
9339               if (p->count == 0)
9340                 *pp = p->next;
9341               else
9342                 pp = &p->next;
9343             }
9344         }
9345
9346       /* Also discard relocs on undefined weak syms with non-default
9347          visibility.  */
9348       if (eh->dyn_relocs != NULL
9349           && h->root.type == bfd_link_hash_undefweak)
9350         {
9351           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9352             eh->dyn_relocs = NULL;
9353
9354           /* Make sure this symbol is output as a dynamic symbol.
9355              Undefined weak syms won't yet be marked as dynamic.  */
9356           else if (h->dynindx == -1
9357                    && !h->forced_local)
9358             {
9359               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9360                 return FALSE;
9361             }
9362         }
9363     }
9364   else if (h->type == STT_GNU_IFUNC)
9365     {
9366       if (!h->non_got_ref)
9367         eh->dyn_relocs = NULL;
9368     }
9369   else if (ELIMINATE_COPY_RELOCS)
9370     {
9371       /* For the non-shared case, discard space for relocs against
9372          symbols which turn out to need copy relocs or are not
9373          dynamic.  */
9374
9375       if (!h->non_got_ref
9376           && !h->def_regular)
9377         {
9378           /* Make sure this symbol is output as a dynamic symbol.
9379              Undefined weak syms won't yet be marked as dynamic.  */
9380           if (h->dynindx == -1
9381               && !h->forced_local)
9382             {
9383               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9384                 return FALSE;
9385             }
9386
9387           /* If that succeeded, we know we'll be keeping all the
9388              relocs.  */
9389           if (h->dynindx != -1)
9390             goto keep;
9391         }
9392
9393       eh->dyn_relocs = NULL;
9394
9395     keep: ;
9396     }
9397
9398   /* Finally, allocate space.  */
9399   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9400     {
9401       asection *sreloc = elf_section_data (p->sec)->sreloc;
9402       if (eh->elf.type == STT_GNU_IFUNC)
9403         sreloc = htab->reliplt;
9404       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9405     }
9406
9407   return TRUE;
9408 }
9409
9410 /* Find any dynamic relocs that apply to read-only sections.  */
9411
9412 static bfd_boolean
9413 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9414 {
9415   struct ppc_link_hash_entry *eh;
9416   struct elf_dyn_relocs *p;
9417
9418   eh = (struct ppc_link_hash_entry *) h;
9419   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9420     {
9421       asection *s = p->sec->output_section;
9422
9423       if (s != NULL && (s->flags & SEC_READONLY) != 0)
9424         {
9425           struct bfd_link_info *info = inf;
9426
9427           info->flags |= DF_TEXTREL;
9428
9429           /* Not an error, just cut short the traversal.  */
9430           return FALSE;
9431         }
9432     }
9433   return TRUE;
9434 }
9435
9436 /* Set the sizes of the dynamic sections.  */
9437
9438 static bfd_boolean
9439 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9440                                  struct bfd_link_info *info)
9441 {
9442   struct ppc_link_hash_table *htab;
9443   bfd *dynobj;
9444   asection *s;
9445   bfd_boolean relocs;
9446   bfd *ibfd;
9447   struct got_entry *first_tlsld;
9448
9449   htab = ppc_hash_table (info);
9450   if (htab == NULL)
9451     return FALSE;
9452
9453   dynobj = htab->elf.dynobj;
9454   if (dynobj == NULL)
9455     abort ();
9456
9457   if (htab->elf.dynamic_sections_created)
9458     {
9459       /* Set the contents of the .interp section to the interpreter.  */
9460       if (info->executable)
9461         {
9462           s = bfd_get_linker_section (dynobj, ".interp");
9463           if (s == NULL)
9464             abort ();
9465           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9466           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9467         }
9468     }
9469
9470   /* Set up .got offsets for local syms, and space for local dynamic
9471      relocs.  */
9472   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9473     {
9474       struct got_entry **lgot_ents;
9475       struct got_entry **end_lgot_ents;
9476       struct plt_entry **local_plt;
9477       struct plt_entry **end_local_plt;
9478       unsigned char *lgot_masks;
9479       bfd_size_type locsymcount;
9480       Elf_Internal_Shdr *symtab_hdr;
9481
9482       if (!is_ppc64_elf (ibfd))
9483         continue;
9484
9485       for (s = ibfd->sections; s != NULL; s = s->next)
9486         {
9487           struct ppc_dyn_relocs *p;
9488
9489           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9490             {
9491               if (!bfd_is_abs_section (p->sec)
9492                   && bfd_is_abs_section (p->sec->output_section))
9493                 {
9494                   /* Input section has been discarded, either because
9495                      it is a copy of a linkonce section or due to
9496                      linker script /DISCARD/, so we'll be discarding
9497                      the relocs too.  */
9498                 }
9499               else if (p->count != 0)
9500                 {
9501                   asection *srel = elf_section_data (p->sec)->sreloc;
9502                   if (p->ifunc)
9503                     srel = htab->reliplt;
9504                   srel->size += p->count * sizeof (Elf64_External_Rela);
9505                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9506                     info->flags |= DF_TEXTREL;
9507                 }
9508             }
9509         }
9510
9511       lgot_ents = elf_local_got_ents (ibfd);
9512       if (!lgot_ents)
9513         continue;
9514
9515       symtab_hdr = &elf_symtab_hdr (ibfd);
9516       locsymcount = symtab_hdr->sh_info;
9517       end_lgot_ents = lgot_ents + locsymcount;
9518       local_plt = (struct plt_entry **) end_lgot_ents;
9519       end_local_plt = local_plt + locsymcount;
9520       lgot_masks = (unsigned char *) end_local_plt;
9521       s = ppc64_elf_tdata (ibfd)->got;
9522       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9523         {
9524           struct got_entry **pent, *ent;
9525
9526           pent = lgot_ents;
9527           while ((ent = *pent) != NULL)
9528             if (ent->got.refcount > 0)
9529               {
9530                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9531                   {
9532                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9533                     *pent = ent->next;
9534                   }
9535                 else
9536                   {
9537                     unsigned int ent_size = 8;
9538                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9539
9540                     ent->got.offset = s->size;
9541                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9542                       {
9543                         ent_size *= 2;
9544                         rel_size *= 2;
9545                       }
9546                     s->size += ent_size;
9547                     if ((*lgot_masks & PLT_IFUNC) != 0)
9548                       {
9549                         htab->reliplt->size += rel_size;
9550                         htab->got_reli_size += rel_size;
9551                       }
9552                     else if (info->shared)
9553                       {
9554                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9555                         srel->size += rel_size;
9556                       }
9557                     pent = &ent->next;
9558                   }
9559               }
9560             else
9561               *pent = ent->next;
9562         }
9563
9564       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9565       for (; local_plt < end_local_plt; ++local_plt)
9566         {
9567           struct plt_entry *ent;
9568
9569           for (ent = *local_plt; ent != NULL; ent = ent->next)
9570             if (ent->plt.refcount > 0)
9571               {
9572                 s = htab->iplt;
9573                 ent->plt.offset = s->size;
9574                 s->size += PLT_ENTRY_SIZE;
9575
9576                 htab->reliplt->size += sizeof (Elf64_External_Rela);
9577               }
9578             else
9579               ent->plt.offset = (bfd_vma) -1;
9580         }
9581     }
9582
9583   /* Allocate global sym .plt and .got entries, and space for global
9584      sym dynamic relocs.  */
9585   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9586
9587   first_tlsld = NULL;
9588   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9589     {
9590       struct got_entry *ent;
9591
9592       if (!is_ppc64_elf (ibfd))
9593         continue;
9594
9595       ent = ppc64_tlsld_got (ibfd);
9596       if (ent->got.refcount > 0)
9597         {
9598           if (!htab->do_multi_toc && first_tlsld != NULL)
9599             {
9600               ent->is_indirect = TRUE;
9601               ent->got.ent = first_tlsld;
9602             }
9603           else
9604             {
9605               if (first_tlsld == NULL)
9606                 first_tlsld = ent;
9607               s = ppc64_elf_tdata (ibfd)->got;
9608               ent->got.offset = s->size;
9609               ent->owner = ibfd;
9610               s->size += 16;
9611               if (info->shared)
9612                 {
9613                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9614                   srel->size += sizeof (Elf64_External_Rela);
9615                 }
9616             }
9617         }
9618       else
9619         ent->got.offset = (bfd_vma) -1;
9620     }
9621
9622   /* We now have determined the sizes of the various dynamic sections.
9623      Allocate memory for them.  */
9624   relocs = FALSE;
9625   for (s = dynobj->sections; s != NULL; s = s->next)
9626     {
9627       if ((s->flags & SEC_LINKER_CREATED) == 0)
9628         continue;
9629
9630       if (s == htab->brlt || s == htab->relbrlt)
9631         /* These haven't been allocated yet;  don't strip.  */
9632         continue;
9633       else if (s == htab->got
9634                || s == htab->plt
9635                || s == htab->iplt
9636                || s == htab->glink
9637                || s == htab->dynbss)
9638         {
9639           /* Strip this section if we don't need it; see the
9640              comment below.  */
9641         }
9642       else if (s == htab->glink_eh_frame)
9643         {
9644           if (!bfd_is_abs_section (s->output_section))
9645             /* Not sized yet.  */
9646             continue;
9647         }
9648       else if (CONST_STRNEQ (s->name, ".rela"))
9649         {
9650           if (s->size != 0)
9651             {
9652               if (s != htab->relplt)
9653                 relocs = TRUE;
9654
9655               /* We use the reloc_count field as a counter if we need
9656                  to copy relocs into the output file.  */
9657               s->reloc_count = 0;
9658             }
9659         }
9660       else
9661         {
9662           /* It's not one of our sections, so don't allocate space.  */
9663           continue;
9664         }
9665
9666       if (s->size == 0)
9667         {
9668           /* If we don't need this section, strip it from the
9669              output file.  This is mostly to handle .rela.bss and
9670              .rela.plt.  We must create both sections in
9671              create_dynamic_sections, because they must be created
9672              before the linker maps input sections to output
9673              sections.  The linker does that before
9674              adjust_dynamic_symbol is called, and it is that
9675              function which decides whether anything needs to go
9676              into these sections.  */
9677           s->flags |= SEC_EXCLUDE;
9678           continue;
9679         }
9680
9681       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9682         continue;
9683
9684       /* Allocate memory for the section contents.  We use bfd_zalloc
9685          here in case unused entries are not reclaimed before the
9686          section's contents are written out.  This should not happen,
9687          but this way if it does we get a R_PPC64_NONE reloc in .rela
9688          sections instead of garbage.
9689          We also rely on the section contents being zero when writing
9690          the GOT.  */
9691       s->contents = bfd_zalloc (dynobj, s->size);
9692       if (s->contents == NULL)
9693         return FALSE;
9694     }
9695
9696   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9697     {
9698       if (!is_ppc64_elf (ibfd))
9699         continue;
9700
9701       s = ppc64_elf_tdata (ibfd)->got;
9702       if (s != NULL && s != htab->got)
9703         {
9704           if (s->size == 0)
9705             s->flags |= SEC_EXCLUDE;
9706           else
9707             {
9708               s->contents = bfd_zalloc (ibfd, s->size);
9709               if (s->contents == NULL)
9710                 return FALSE;
9711             }
9712         }
9713       s = ppc64_elf_tdata (ibfd)->relgot;
9714       if (s != NULL)
9715         {
9716           if (s->size == 0)
9717             s->flags |= SEC_EXCLUDE;
9718           else
9719             {
9720               s->contents = bfd_zalloc (ibfd, s->size);
9721               if (s->contents == NULL)
9722                 return FALSE;
9723               relocs = TRUE;
9724               s->reloc_count = 0;
9725             }
9726         }
9727     }
9728
9729   if (htab->elf.dynamic_sections_created)
9730     {
9731       /* Add some entries to the .dynamic section.  We fill in the
9732          values later, in ppc64_elf_finish_dynamic_sections, but we
9733          must add the entries now so that we get the correct size for
9734          the .dynamic section.  The DT_DEBUG entry is filled in by the
9735          dynamic linker and used by the debugger.  */
9736 #define add_dynamic_entry(TAG, VAL) \
9737   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9738
9739       if (info->executable)
9740         {
9741           if (!add_dynamic_entry (DT_DEBUG, 0))
9742             return FALSE;
9743         }
9744
9745       if (htab->plt != NULL && htab->plt->size != 0)
9746         {
9747           if (!add_dynamic_entry (DT_PLTGOT, 0)
9748               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9749               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9750               || !add_dynamic_entry (DT_JMPREL, 0)
9751               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9752             return FALSE;
9753         }
9754
9755       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9756         {
9757           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9758               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9759             return FALSE;
9760         }
9761
9762       if (!htab->no_tls_get_addr_opt
9763           && htab->tls_get_addr_fd != NULL
9764           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9765           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9766         return FALSE;
9767
9768       if (relocs)
9769         {
9770           if (!add_dynamic_entry (DT_RELA, 0)
9771               || !add_dynamic_entry (DT_RELASZ, 0)
9772               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9773             return FALSE;
9774
9775           /* If any dynamic relocs apply to a read-only section,
9776              then we need a DT_TEXTREL entry.  */
9777           if ((info->flags & DF_TEXTREL) == 0)
9778             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9779
9780           if ((info->flags & DF_TEXTREL) != 0)
9781             {
9782               if (!add_dynamic_entry (DT_TEXTREL, 0))
9783                 return FALSE;
9784             }
9785         }
9786     }
9787 #undef add_dynamic_entry
9788
9789   return TRUE;
9790 }
9791
9792 /* Determine the type of stub needed, if any, for a call.  */
9793
9794 static inline enum ppc_stub_type
9795 ppc_type_of_stub (asection *input_sec,
9796                   const Elf_Internal_Rela *rel,
9797                   struct ppc_link_hash_entry **hash,
9798                   struct plt_entry **plt_ent,
9799                   bfd_vma destination)
9800 {
9801   struct ppc_link_hash_entry *h = *hash;
9802   bfd_vma location;
9803   bfd_vma branch_offset;
9804   bfd_vma max_branch_offset;
9805   enum elf_ppc64_reloc_type r_type;
9806
9807   if (h != NULL)
9808     {
9809       struct plt_entry *ent;
9810       struct ppc_link_hash_entry *fdh = h;
9811       if (h->oh != NULL
9812           && h->oh->is_func_descriptor)
9813         {
9814           fdh = ppc_follow_link (h->oh);
9815           *hash = fdh;
9816         }
9817
9818       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9819         if (ent->addend == rel->r_addend
9820             && ent->plt.offset != (bfd_vma) -1)
9821           {
9822             *plt_ent = ent;
9823             return ppc_stub_plt_call;
9824           }
9825
9826       /* Here, we know we don't have a plt entry.  If we don't have a
9827          either a defined function descriptor or a defined entry symbol
9828          in a regular object file, then it is pointless trying to make
9829          any other type of stub.  */
9830       if (!is_static_defined (&fdh->elf)
9831           && !is_static_defined (&h->elf))
9832         return ppc_stub_none;
9833     }
9834   else if (elf_local_got_ents (input_sec->owner) != NULL)
9835     {
9836       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9837       struct plt_entry **local_plt = (struct plt_entry **)
9838         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9839       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9840
9841       if (local_plt[r_symndx] != NULL)
9842         {
9843           struct plt_entry *ent;
9844
9845           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9846             if (ent->addend == rel->r_addend
9847                 && ent->plt.offset != (bfd_vma) -1)
9848               {
9849                 *plt_ent = ent;
9850                 return ppc_stub_plt_call;
9851               }
9852         }
9853     }
9854
9855   /* Determine where the call point is.  */
9856   location = (input_sec->output_offset
9857               + input_sec->output_section->vma
9858               + rel->r_offset);
9859
9860   branch_offset = destination - location;
9861   r_type = ELF64_R_TYPE (rel->r_info);
9862
9863   /* Determine if a long branch stub is needed.  */
9864   max_branch_offset = 1 << 25;
9865   if (r_type != R_PPC64_REL24)
9866     max_branch_offset = 1 << 15;
9867
9868   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9869     /* We need a stub.  Figure out whether a long_branch or plt_branch
9870        is needed later.  */
9871     return ppc_stub_long_branch;
9872
9873   return ppc_stub_none;
9874 }
9875
9876 /* With power7 weakly ordered memory model, it is possible for ld.so
9877    to update a plt entry in one thread and have another thread see a
9878    stale zero toc entry.  To avoid this we need some sort of acquire
9879    barrier in the call stub.  One solution is to make the load of the
9880    toc word seem to appear to depend on the load of the function entry
9881    word.  Another solution is to test for r2 being zero, and branch to
9882    the appropriate glink entry if so.
9883
9884    .    fake dep barrier        compare
9885    .    ld 12,xxx(2)            ld 12,xxx(2)
9886    .    mtctr 12                mtctr 12
9887    .    xor 11,12,12            ld 2,xxx+8(2)
9888    .    add 2,2,11              cmpldi 2,0
9889    .    ld 2,xxx+8(2)           bnectr+
9890    .    bctr                    b <glink_entry>
9891
9892    The solution involving the compare turns out to be faster, so
9893    that's what we use unless the branch won't reach.  */
9894
9895 #define ALWAYS_USE_FAKE_DEP 0
9896 #define ALWAYS_EMIT_R2SAVE 0
9897
9898 #define PPC_LO(v) ((v) & 0xffff)
9899 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9900 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9901
9902 static inline unsigned int
9903 plt_stub_size (struct ppc_link_hash_table *htab,
9904                struct ppc_stub_hash_entry *stub_entry,
9905                bfd_vma off)
9906 {
9907   unsigned size = PLT_CALL_STUB_SIZE;
9908
9909   if (!(ALWAYS_EMIT_R2SAVE
9910         || stub_entry->stub_type == ppc_stub_plt_call_r2save))
9911     size -= 4;
9912   if (!htab->plt_static_chain)
9913     size -= 4;
9914   if (htab->plt_thread_safe)
9915     size += 8;
9916   if (PPC_HA (off) == 0)
9917     size -= 4;
9918   if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9919     size += 4;
9920   if (stub_entry->h != NULL
9921       && (stub_entry->h == htab->tls_get_addr_fd
9922           || stub_entry->h == htab->tls_get_addr)
9923       && !htab->no_tls_get_addr_opt)
9924     size += 13 * 4;
9925   return size;
9926 }
9927
9928 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
9929    then return the padding needed to do so.  */
9930 static inline unsigned int
9931 plt_stub_pad (struct ppc_link_hash_table *htab,
9932               struct ppc_stub_hash_entry *stub_entry,
9933               bfd_vma plt_off)
9934 {
9935   int stub_align = 1 << htab->plt_stub_align;
9936   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
9937   bfd_vma stub_off = stub_entry->stub_sec->size;
9938
9939   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
9940       > (stub_size & -stub_align))
9941     return stub_align - (stub_off & (stub_align - 1));
9942   return 0;
9943 }
9944
9945 /* Build a .plt call stub.  */
9946
9947 static inline bfd_byte *
9948 build_plt_stub (struct ppc_link_hash_table *htab,
9949                 struct ppc_stub_hash_entry *stub_entry,
9950                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9951 {
9952   bfd *obfd = htab->stub_bfd;
9953   bfd_boolean plt_static_chain = htab->plt_static_chain;
9954   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
9955   bfd_boolean use_fake_dep = plt_thread_safe;
9956   bfd_vma cmp_branch_off = 0;
9957
9958   if (!ALWAYS_USE_FAKE_DEP
9959       && plt_thread_safe
9960       && !(stub_entry->h != NULL
9961            && (stub_entry->h == htab->tls_get_addr_fd
9962                || stub_entry->h == htab->tls_get_addr)
9963            && !htab->no_tls_get_addr_opt))
9964     {
9965       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
9966       bfd_vma pltindex = (pltoff - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
9967       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
9968       bfd_vma to, from;
9969
9970       if (pltindex > 32768)
9971         glinkoff += (pltindex - 32768) * 4;
9972       to = (glinkoff
9973             + htab->glink->output_offset
9974             + htab->glink->output_section->vma);
9975       from = (p - stub_entry->stub_sec->contents
9976               + 4 * (ALWAYS_EMIT_R2SAVE
9977                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9978               + 4 * (PPC_HA (offset) != 0)
9979               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
9980                      != PPC_HA (offset))
9981               + 4 * (plt_static_chain != 0)
9982               + 20
9983               + stub_entry->stub_sec->output_offset
9984               + stub_entry->stub_sec->output_section->vma);
9985       cmp_branch_off = to - from;
9986       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
9987     }
9988
9989   if (PPC_HA (offset) != 0)
9990     {
9991       if (r != NULL)
9992         {
9993           if (ALWAYS_EMIT_R2SAVE
9994               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9995             r[0].r_offset += 4;
9996           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9997           r[1].r_offset = r[0].r_offset + 4;
9998           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9999           r[1].r_addend = r[0].r_addend;
10000           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10001             {
10002               r[2].r_offset = r[1].r_offset + 4;
10003               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10004               r[2].r_addend = r[0].r_addend;
10005             }
10006           else
10007             {
10008               r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10009               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10010               r[2].r_addend = r[0].r_addend + 8;
10011               if (plt_static_chain)
10012                 {
10013                   r[3].r_offset = r[2].r_offset + 4;
10014                   r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10015                   r[3].r_addend = r[0].r_addend + 16;
10016                 }
10017             }
10018         }
10019       if (ALWAYS_EMIT_R2SAVE
10020           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10021         bfd_put_32 (obfd, STD_R2_40R1, p),                      p += 4;
10022       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10023       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10024       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10025         {
10026           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10027           offset = 0;
10028         }
10029       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10030       if (use_fake_dep)
10031         {
10032           bfd_put_32 (obfd, XOR_R2_R12_R12, p),                 p += 4;
10033           bfd_put_32 (obfd, ADD_R11_R11_R2, p),                 p += 4;
10034         }
10035       bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p),   p += 4;
10036       if (plt_static_chain)
10037         bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10038     }
10039   else
10040     {
10041       if (r != NULL)
10042         {
10043           if (ALWAYS_EMIT_R2SAVE
10044               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10045             r[0].r_offset += 4;
10046           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10047           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10048             {
10049               r[1].r_offset = r[0].r_offset + 4;
10050               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10051               r[1].r_addend = r[0].r_addend;
10052             }
10053           else
10054             {
10055               r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10056               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10057               r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10058               if (plt_static_chain)
10059                 {
10060                   r[2].r_offset = r[1].r_offset + 4;
10061                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10062                   r[2].r_addend = r[0].r_addend + 8;
10063                 }
10064             }
10065         }
10066       if (ALWAYS_EMIT_R2SAVE
10067           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10068         bfd_put_32 (obfd, STD_R2_40R1, p),                      p += 4;
10069       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10070       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10071         {
10072           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10073           offset = 0;
10074         }
10075       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10076       if (use_fake_dep)
10077         {
10078           bfd_put_32 (obfd, XOR_R11_R12_R12, p),                p += 4;
10079           bfd_put_32 (obfd, ADD_R2_R2_R11, p),                  p += 4;
10080         }
10081       if (plt_static_chain)
10082         bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10083       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
10084     }
10085   if (plt_thread_safe && !use_fake_dep)
10086     {
10087       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10088       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10089       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10090     }
10091   else
10092     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10093   return p;
10094 }
10095
10096 /* Build a special .plt call stub for __tls_get_addr.  */
10097
10098 #define LD_R11_0R3      0xe9630000
10099 #define LD_R12_0R3      0xe9830000
10100 #define MR_R0_R3        0x7c601b78
10101 #define CMPDI_R11_0     0x2c2b0000
10102 #define ADD_R3_R12_R13  0x7c6c6a14
10103 #define BEQLR           0x4d820020
10104 #define MR_R3_R0        0x7c030378
10105 #define MFLR_R11        0x7d6802a6
10106 #define STD_R11_0R1     0xf9610000
10107 #define BCTRL           0x4e800421
10108 #define LD_R11_0R1      0xe9610000
10109 #define LD_R2_0R1       0xe8410000
10110 #define MTLR_R11        0x7d6803a6
10111
10112 static inline bfd_byte *
10113 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10114                          struct ppc_stub_hash_entry *stub_entry,
10115                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10116 {
10117   bfd *obfd = htab->stub_bfd;
10118
10119   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10120   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10121   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10122   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10123   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10124   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10125   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10126   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10127   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
10128
10129   if (r != NULL)
10130     r[0].r_offset += 9 * 4;
10131   p = build_plt_stub (htab, stub_entry, p, offset, r);
10132   bfd_put_32 (obfd, BCTRL, p - 4);
10133
10134   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
10135   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
10136   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10137   bfd_put_32 (obfd, BLR, p),                    p += 4;
10138
10139   return p;
10140 }
10141
10142 static Elf_Internal_Rela *
10143 get_relocs (asection *sec, int count)
10144 {
10145   Elf_Internal_Rela *relocs;
10146   struct bfd_elf_section_data *elfsec_data;
10147
10148   elfsec_data = elf_section_data (sec);
10149   relocs = elfsec_data->relocs;
10150   if (relocs == NULL)
10151     {
10152       bfd_size_type relsize;
10153       relsize = sec->reloc_count * sizeof (*relocs);
10154       relocs = bfd_alloc (sec->owner, relsize);
10155       if (relocs == NULL)
10156         return NULL;
10157       elfsec_data->relocs = relocs;
10158       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10159                                           sizeof (Elf_Internal_Shdr));
10160       if (elfsec_data->rela.hdr == NULL)
10161         return NULL;
10162       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10163                                         * sizeof (Elf64_External_Rela));
10164       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10165       sec->reloc_count = 0;
10166     }
10167   relocs += sec->reloc_count;
10168   sec->reloc_count += count;
10169   return relocs;
10170 }
10171
10172 static bfd_vma
10173 get_r2off (struct bfd_link_info *info,
10174            struct ppc_stub_hash_entry *stub_entry)
10175 {
10176   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10177   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10178
10179   if (r2off == 0)
10180     {
10181       /* Support linking -R objects.  Get the toc pointer from the
10182          opd entry.  */
10183       char buf[8];
10184       asection *opd = stub_entry->h->elf.root.u.def.section;
10185       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10186
10187       if (strcmp (opd->name, ".opd") != 0
10188           || opd->reloc_count != 0)
10189         {
10190           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10191                                   stub_entry->h->elf.root.root.string);
10192           bfd_set_error (bfd_error_bad_value);
10193           return 0;
10194         }
10195       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10196         return 0;
10197       r2off = bfd_get_64 (opd->owner, buf);
10198       r2off -= elf_gp (info->output_bfd);
10199     }
10200   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10201   return r2off;
10202 }
10203
10204 static bfd_boolean
10205 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10206 {
10207   struct ppc_stub_hash_entry *stub_entry;
10208   struct ppc_branch_hash_entry *br_entry;
10209   struct bfd_link_info *info;
10210   struct ppc_link_hash_table *htab;
10211   bfd_byte *loc;
10212   bfd_byte *p;
10213   bfd_vma dest, off;
10214   int size;
10215   Elf_Internal_Rela *r;
10216   asection *plt;
10217
10218   /* Massage our args to the form they really have.  */
10219   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10220   info = in_arg;
10221
10222   htab = ppc_hash_table (info);
10223   if (htab == NULL)
10224     return FALSE;
10225
10226   /* Make a note of the offset within the stubs for this entry.  */
10227   stub_entry->stub_offset = stub_entry->stub_sec->size;
10228   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10229
10230   htab->stub_count[stub_entry->stub_type - 1] += 1;
10231   switch (stub_entry->stub_type)
10232     {
10233     case ppc_stub_long_branch:
10234     case ppc_stub_long_branch_r2off:
10235       /* Branches are relative.  This is where we are going to.  */
10236       off = dest = (stub_entry->target_value
10237                     + stub_entry->target_section->output_offset
10238                     + stub_entry->target_section->output_section->vma);
10239
10240       /* And this is where we are coming from.  */
10241       off -= (stub_entry->stub_offset
10242               + stub_entry->stub_sec->output_offset
10243               + stub_entry->stub_sec->output_section->vma);
10244
10245       size = 4;
10246       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10247         {
10248           bfd_vma r2off = get_r2off (info, stub_entry);
10249
10250           if (r2off == 0)
10251             {
10252               htab->stub_error = TRUE;
10253               return FALSE;
10254             }
10255           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10256           loc += 4;
10257           size = 12;
10258           if (PPC_HA (r2off) != 0)
10259             {
10260               size = 16;
10261               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10262               loc += 4;
10263             }
10264           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10265           loc += 4;
10266           off -= size - 4;
10267         }
10268       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10269
10270       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10271         {
10272           info->callbacks->einfo
10273             (_("%P: long branch stub `%s' offset overflow\n"),
10274              stub_entry->root.string);
10275           htab->stub_error = TRUE;
10276           return FALSE;
10277         }
10278
10279       if (info->emitrelocations)
10280         {
10281           r = get_relocs (stub_entry->stub_sec, 1);
10282           if (r == NULL)
10283             return FALSE;
10284           r->r_offset = loc - stub_entry->stub_sec->contents;
10285           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10286           r->r_addend = dest;
10287           if (stub_entry->h != NULL)
10288             {
10289               struct elf_link_hash_entry **hashes;
10290               unsigned long symndx;
10291               struct ppc_link_hash_entry *h;
10292
10293               hashes = elf_sym_hashes (htab->stub_bfd);
10294               if (hashes == NULL)
10295                 {
10296                   bfd_size_type hsize;
10297
10298                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10299                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
10300                   if (hashes == NULL)
10301                     return FALSE;
10302                   elf_sym_hashes (htab->stub_bfd) = hashes;
10303                   htab->stub_globals = 1;
10304                 }
10305               symndx = htab->stub_globals++;
10306               h = stub_entry->h;
10307               hashes[symndx] = &h->elf;
10308               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10309               if (h->oh != NULL && h->oh->is_func)
10310                 h = ppc_follow_link (h->oh);
10311               if (h->elf.root.u.def.section != stub_entry->target_section)
10312                 /* H is an opd symbol.  The addend must be zero.  */
10313                 r->r_addend = 0;
10314               else
10315                 {
10316                   off = (h->elf.root.u.def.value
10317                          + h->elf.root.u.def.section->output_offset
10318                          + h->elf.root.u.def.section->output_section->vma);
10319                   r->r_addend -= off;
10320                 }
10321             }
10322         }
10323       break;
10324
10325     case ppc_stub_plt_branch:
10326     case ppc_stub_plt_branch_r2off:
10327       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10328                                          stub_entry->root.string + 9,
10329                                          FALSE, FALSE);
10330       if (br_entry == NULL)
10331         {
10332           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10333                                   stub_entry->root.string);
10334           htab->stub_error = TRUE;
10335           return FALSE;
10336         }
10337
10338       dest = (stub_entry->target_value
10339               + stub_entry->target_section->output_offset
10340               + stub_entry->target_section->output_section->vma);
10341
10342       bfd_put_64 (htab->brlt->owner, dest,
10343                   htab->brlt->contents + br_entry->offset);
10344
10345       if (br_entry->iter == htab->stub_iteration)
10346         {
10347           br_entry->iter = 0;
10348
10349           if (htab->relbrlt != NULL)
10350             {
10351               /* Create a reloc for the branch lookup table entry.  */
10352               Elf_Internal_Rela rela;
10353               bfd_byte *rl;
10354
10355               rela.r_offset = (br_entry->offset
10356                                + htab->brlt->output_offset
10357                                + htab->brlt->output_section->vma);
10358               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10359               rela.r_addend = dest;
10360
10361               rl = htab->relbrlt->contents;
10362               rl += (htab->relbrlt->reloc_count++
10363                      * sizeof (Elf64_External_Rela));
10364               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10365             }
10366           else if (info->emitrelocations)
10367             {
10368               r = get_relocs (htab->brlt, 1);
10369               if (r == NULL)
10370                 return FALSE;
10371               /* brlt, being SEC_LINKER_CREATED does not go through the
10372                  normal reloc processing.  Symbols and offsets are not
10373                  translated from input file to output file form, so
10374                  set up the offset per the output file.  */
10375               r->r_offset = (br_entry->offset
10376                              + htab->brlt->output_offset
10377                              + htab->brlt->output_section->vma);
10378               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10379               r->r_addend = dest;
10380             }
10381         }
10382
10383       dest = (br_entry->offset
10384               + htab->brlt->output_offset
10385               + htab->brlt->output_section->vma);
10386
10387       off = (dest
10388              - elf_gp (htab->brlt->output_section->owner)
10389              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10390
10391       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10392         {
10393           info->callbacks->einfo
10394             (_("%P: linkage table error against `%T'\n"),
10395              stub_entry->root.string);
10396           bfd_set_error (bfd_error_bad_value);
10397           htab->stub_error = TRUE;
10398           return FALSE;
10399         }
10400
10401       if (info->emitrelocations)
10402         {
10403           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10404           if (r == NULL)
10405             return FALSE;
10406           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10407           if (bfd_big_endian (info->output_bfd))
10408             r[0].r_offset += 2;
10409           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10410             r[0].r_offset += 4;
10411           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10412           r[0].r_addend = dest;
10413           if (PPC_HA (off) != 0)
10414             {
10415               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10416               r[1].r_offset = r[0].r_offset + 4;
10417               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10418               r[1].r_addend = r[0].r_addend;
10419             }
10420         }
10421
10422       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10423         {
10424           if (PPC_HA (off) != 0)
10425             {
10426               size = 16;
10427               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10428               loc += 4;
10429               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10430             }
10431           else
10432             {
10433               size = 12;
10434               bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10435             }
10436         }
10437       else
10438         {
10439           bfd_vma r2off = get_r2off (info, stub_entry);
10440
10441           if (r2off == 0)
10442             {
10443               htab->stub_error = TRUE;
10444               return FALSE;
10445             }
10446
10447           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10448           loc += 4;
10449           size = 20;
10450           if (PPC_HA (off) != 0)
10451             {
10452               size += 4;
10453               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10454               loc += 4;
10455               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10456               loc += 4;
10457             }
10458           else
10459             {
10460               bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10461               loc += 4;
10462             }
10463
10464           if (PPC_HA (r2off) != 0)
10465             {
10466               size += 4;
10467               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10468               loc += 4;
10469             }
10470           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10471         }
10472       loc += 4;
10473       bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10474       loc += 4;
10475       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10476       break;
10477
10478     case ppc_stub_plt_call:
10479     case ppc_stub_plt_call_r2save:
10480       if (stub_entry->h != NULL
10481           && stub_entry->h->is_func_descriptor
10482           && stub_entry->h->oh != NULL)
10483         {
10484           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10485
10486           /* If the old-ABI "dot-symbol" is undefined make it weak so
10487              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10488              FIXME: We used to define the symbol on one of the call
10489              stubs instead, which is why we test symbol section id
10490              against htab->top_id in various places.  Likely all
10491              these checks could now disappear.  */
10492           if (fh->elf.root.type == bfd_link_hash_undefined)
10493             fh->elf.root.type = bfd_link_hash_undefweak;
10494           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10495           fh->was_undefined = 0;
10496         }
10497
10498       /* Now build the stub.  */
10499       dest = stub_entry->plt_ent->plt.offset & ~1;
10500       if (dest >= (bfd_vma) -2)
10501         abort ();
10502
10503       plt = htab->plt;
10504       if (!htab->elf.dynamic_sections_created
10505           || stub_entry->h == NULL
10506           || stub_entry->h->elf.dynindx == -1)
10507         plt = htab->iplt;
10508
10509       dest += plt->output_offset + plt->output_section->vma;
10510
10511       if (stub_entry->h == NULL
10512           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10513         {
10514           Elf_Internal_Rela rela;
10515           bfd_byte *rl;
10516
10517           rela.r_offset = dest;
10518           if (htab->opd_abi)
10519             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10520           else
10521             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10522           rela.r_addend = (stub_entry->target_value
10523                            + stub_entry->target_section->output_offset
10524                            + stub_entry->target_section->output_section->vma);
10525
10526           rl = (htab->reliplt->contents
10527                 + (htab->reliplt->reloc_count++
10528                    * sizeof (Elf64_External_Rela)));
10529           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10530           stub_entry->plt_ent->plt.offset |= 1;
10531         }
10532
10533       off = (dest
10534              - elf_gp (plt->output_section->owner)
10535              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10536
10537       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10538         {
10539           info->callbacks->einfo
10540             (_("%P: linkage table error against `%T'\n"),
10541              stub_entry->h != NULL
10542              ? stub_entry->h->elf.root.root.string
10543              : "<local sym>");
10544           bfd_set_error (bfd_error_bad_value);
10545           htab->stub_error = TRUE;
10546           return FALSE;
10547         }
10548
10549       if (htab->plt_stub_align != 0)
10550         {
10551           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10552
10553           stub_entry->stub_sec->size += pad;
10554           stub_entry->stub_offset = stub_entry->stub_sec->size;
10555           loc += pad;
10556         }
10557
10558       r = NULL;
10559       if (info->emitrelocations)
10560         {
10561           r = get_relocs (stub_entry->stub_sec,
10562                           (2
10563                            + (PPC_HA (off) != 0)
10564                            + (htab->plt_static_chain
10565                               && PPC_HA (off + 16) == PPC_HA (off))));
10566           if (r == NULL)
10567             return FALSE;
10568           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10569           if (bfd_big_endian (info->output_bfd))
10570             r[0].r_offset += 2;
10571           r[0].r_addend = dest;
10572         }
10573       if (stub_entry->h != NULL
10574           && (stub_entry->h == htab->tls_get_addr_fd
10575               || stub_entry->h == htab->tls_get_addr)
10576           && !htab->no_tls_get_addr_opt)
10577         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10578       else
10579         p = build_plt_stub (htab, stub_entry, loc, off, r);
10580       size = p - loc;
10581       break;
10582
10583     default:
10584       BFD_FAIL ();
10585       return FALSE;
10586     }
10587
10588   stub_entry->stub_sec->size += size;
10589
10590   if (htab->emit_stub_syms)
10591     {
10592       struct elf_link_hash_entry *h;
10593       size_t len1, len2;
10594       char *name;
10595       const char *const stub_str[] = { "long_branch",
10596                                        "long_branch_r2off",
10597                                        "plt_branch",
10598                                        "plt_branch_r2off",
10599                                        "plt_call",
10600                                        "plt_call" };
10601
10602       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10603       len2 = strlen (stub_entry->root.string);
10604       name = bfd_malloc (len1 + len2 + 2);
10605       if (name == NULL)
10606         return FALSE;
10607       memcpy (name, stub_entry->root.string, 9);
10608       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10609       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10610       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10611       if (h == NULL)
10612         return FALSE;
10613       if (h->root.type == bfd_link_hash_new)
10614         {
10615           h->root.type = bfd_link_hash_defined;
10616           h->root.u.def.section = stub_entry->stub_sec;
10617           h->root.u.def.value = stub_entry->stub_offset;
10618           h->ref_regular = 1;
10619           h->def_regular = 1;
10620           h->ref_regular_nonweak = 1;
10621           h->forced_local = 1;
10622           h->non_elf = 0;
10623         }
10624     }
10625
10626   return TRUE;
10627 }
10628
10629 /* As above, but don't actually build the stub.  Just bump offset so
10630    we know stub section sizes, and select plt_branch stubs where
10631    long_branch stubs won't do.  */
10632
10633 static bfd_boolean
10634 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10635 {
10636   struct ppc_stub_hash_entry *stub_entry;
10637   struct bfd_link_info *info;
10638   struct ppc_link_hash_table *htab;
10639   bfd_vma off;
10640   int size;
10641
10642   /* Massage our args to the form they really have.  */
10643   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10644   info = in_arg;
10645
10646   htab = ppc_hash_table (info);
10647   if (htab == NULL)
10648     return FALSE;
10649
10650   if (stub_entry->stub_type == ppc_stub_plt_call
10651       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10652     {
10653       asection *plt;
10654       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10655       if (off >= (bfd_vma) -2)
10656         abort ();
10657       plt = htab->plt;
10658       if (!htab->elf.dynamic_sections_created
10659           || stub_entry->h == NULL
10660           || stub_entry->h->elf.dynindx == -1)
10661         plt = htab->iplt;
10662       off += (plt->output_offset
10663               + plt->output_section->vma
10664               - elf_gp (plt->output_section->owner)
10665               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10666
10667       size = plt_stub_size (htab, stub_entry, off);
10668       if (htab->plt_stub_align)
10669         size += plt_stub_pad (htab, stub_entry, off);
10670       if (info->emitrelocations)
10671         {
10672           stub_entry->stub_sec->reloc_count
10673             += (2
10674                 + (PPC_HA (off) != 0)
10675                 + (htab->plt_static_chain
10676                    && PPC_HA (off + 16) == PPC_HA (off)));
10677           stub_entry->stub_sec->flags |= SEC_RELOC;
10678         }
10679     }
10680   else
10681     {
10682       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10683          variants.  */
10684       bfd_vma r2off = 0;
10685
10686       off = (stub_entry->target_value
10687              + stub_entry->target_section->output_offset
10688              + stub_entry->target_section->output_section->vma);
10689       off -= (stub_entry->stub_sec->size
10690               + stub_entry->stub_sec->output_offset
10691               + stub_entry->stub_sec->output_section->vma);
10692
10693       /* Reset the stub type from the plt variant in case we now
10694          can reach with a shorter stub.  */
10695       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10696         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10697
10698       size = 4;
10699       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10700         {
10701           r2off = get_r2off (info, stub_entry);
10702           if (r2off == 0)
10703             {
10704               htab->stub_error = TRUE;
10705               return FALSE;
10706             }
10707           size = 12;
10708           if (PPC_HA (r2off) != 0)
10709             size = 16;
10710           off -= size - 4;
10711         }
10712
10713       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
10714       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10715         {
10716           struct ppc_branch_hash_entry *br_entry;
10717
10718           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10719                                              stub_entry->root.string + 9,
10720                                              TRUE, FALSE);
10721           if (br_entry == NULL)
10722             {
10723               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10724                                       stub_entry->root.string);
10725               htab->stub_error = TRUE;
10726               return FALSE;
10727             }
10728
10729           if (br_entry->iter != htab->stub_iteration)
10730             {
10731               br_entry->iter = htab->stub_iteration;
10732               br_entry->offset = htab->brlt->size;
10733               htab->brlt->size += 8;
10734
10735               if (htab->relbrlt != NULL)
10736                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10737               else if (info->emitrelocations)
10738                 {
10739                   htab->brlt->reloc_count += 1;
10740                   htab->brlt->flags |= SEC_RELOC;
10741                 }
10742             }
10743
10744           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10745           off = (br_entry->offset
10746                  + htab->brlt->output_offset
10747                  + htab->brlt->output_section->vma
10748                  - elf_gp (htab->brlt->output_section->owner)
10749                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10750
10751           if (info->emitrelocations)
10752             {
10753               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10754               stub_entry->stub_sec->flags |= SEC_RELOC;
10755             }
10756
10757           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10758             {
10759               size = 12;
10760               if (PPC_HA (off) != 0)
10761                 size = 16;
10762             }
10763           else
10764             {
10765               size = 20;
10766               if (PPC_HA (off) != 0)
10767                 size += 4;
10768
10769               if (PPC_HA (r2off) != 0)
10770                 size += 4;
10771             }
10772         }
10773       else if (info->emitrelocations)
10774         {
10775           stub_entry->stub_sec->reloc_count += 1;
10776           stub_entry->stub_sec->flags |= SEC_RELOC;
10777         }
10778     }
10779
10780   stub_entry->stub_sec->size += size;
10781   return TRUE;
10782 }
10783
10784 /* Set up various things so that we can make a list of input sections
10785    for each output section included in the link.  Returns -1 on error,
10786    0 when no stubs will be needed, and 1 on success.  */
10787
10788 int
10789 ppc64_elf_setup_section_lists
10790   (struct bfd_link_info *info,
10791    asection *(*add_stub_section) (const char *, asection *),
10792    void (*layout_sections_again) (void))
10793 {
10794   bfd *input_bfd;
10795   int top_id, top_index, id;
10796   asection *section;
10797   asection **input_list;
10798   bfd_size_type amt;
10799   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10800
10801   if (htab == NULL)
10802     return -1;
10803   /* Stash our params away.  */
10804   htab->add_stub_section = add_stub_section;
10805   htab->layout_sections_again = layout_sections_again;
10806
10807   /* Find the top input section id.  */
10808   for (input_bfd = info->input_bfds, top_id = 3;
10809        input_bfd != NULL;
10810        input_bfd = input_bfd->link_next)
10811     {
10812       for (section = input_bfd->sections;
10813            section != NULL;
10814            section = section->next)
10815         {
10816           if (top_id < section->id)
10817             top_id = section->id;
10818         }
10819     }
10820
10821   htab->top_id = top_id;
10822   amt = sizeof (struct map_stub) * (top_id + 1);
10823   htab->stub_group = bfd_zmalloc (amt);
10824   if (htab->stub_group == NULL)
10825     return -1;
10826
10827   /* Set toc_off for com, und, abs and ind sections.  */
10828   for (id = 0; id < 3; id++)
10829     htab->stub_group[id].toc_off = TOC_BASE_OFF;
10830
10831   /* We can't use output_bfd->section_count here to find the top output
10832      section index as some sections may have been removed, and
10833      strip_excluded_output_sections doesn't renumber the indices.  */
10834   for (section = info->output_bfd->sections, top_index = 0;
10835        section != NULL;
10836        section = section->next)
10837     {
10838       if (top_index < section->index)
10839         top_index = section->index;
10840     }
10841
10842   htab->top_index = top_index;
10843   amt = sizeof (asection *) * (top_index + 1);
10844   input_list = bfd_zmalloc (amt);
10845   htab->input_list = input_list;
10846   if (input_list == NULL)
10847     return -1;
10848
10849   return 1;
10850 }
10851
10852 /* Set up for first pass at multitoc partitioning.  */
10853
10854 void
10855 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10856 {
10857   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10858
10859   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
10860   htab->toc_bfd = NULL;
10861   htab->toc_first_sec = NULL;
10862 }
10863
10864 /* The linker repeatedly calls this function for each TOC input section
10865    and linker generated GOT section.  Group input bfds such that the toc
10866    within a group is less than 64k in size.  */
10867
10868 bfd_boolean
10869 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10870 {
10871   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10872   bfd_vma addr, off, limit;
10873
10874   if (htab == NULL)
10875     return FALSE;
10876
10877   if (!htab->second_toc_pass)
10878     {
10879       /* Keep track of the first .toc or .got section for this input bfd.  */
10880       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
10881
10882       if (new_bfd)
10883         {
10884           htab->toc_bfd = isec->owner;
10885           htab->toc_first_sec = isec;
10886         }
10887
10888       addr = isec->output_offset + isec->output_section->vma;
10889       off = addr - htab->toc_curr;
10890       limit = 0x80008000;
10891       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10892         limit = 0x10000;
10893       if (off + isec->size > limit)
10894         {
10895           addr = (htab->toc_first_sec->output_offset
10896                   + htab->toc_first_sec->output_section->vma);
10897           htab->toc_curr = addr;
10898         }
10899
10900       /* toc_curr is the base address of this toc group.  Set elf_gp
10901          for the input section to be the offset relative to the
10902          output toc base plus 0x8000.  Making the input elf_gp an
10903          offset allows us to move the toc as a whole without
10904          recalculating input elf_gp.  */
10905       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10906       off += TOC_BASE_OFF;
10907
10908       /* Die if someone uses a linker script that doesn't keep input
10909          file .toc and .got together.  */
10910       if (new_bfd
10911           && elf_gp (isec->owner) != 0
10912           && elf_gp (isec->owner) != off)
10913         return FALSE;
10914
10915       elf_gp (isec->owner) = off;
10916       return TRUE;
10917     }
10918
10919   /* During the second pass toc_first_sec points to the start of
10920      a toc group, and toc_curr is used to track the old elf_gp.
10921      We use toc_bfd to ensure we only look at each bfd once.  */
10922   if (htab->toc_bfd == isec->owner)
10923     return TRUE;
10924   htab->toc_bfd = isec->owner;
10925
10926   if (htab->toc_first_sec == NULL
10927       || htab->toc_curr != elf_gp (isec->owner))
10928     {
10929       htab->toc_curr = elf_gp (isec->owner);
10930       htab->toc_first_sec = isec;
10931     }
10932   addr = (htab->toc_first_sec->output_offset
10933           + htab->toc_first_sec->output_section->vma);
10934   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10935   elf_gp (isec->owner) = off;
10936
10937   return TRUE;
10938 }
10939
10940 /* Called via elf_link_hash_traverse to merge GOT entries for global
10941    symbol H.  */
10942
10943 static bfd_boolean
10944 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10945 {
10946   if (h->root.type == bfd_link_hash_indirect)
10947     return TRUE;
10948
10949   merge_got_entries (&h->got.glist);
10950
10951   return TRUE;
10952 }
10953
10954 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10955    symbol H.  */
10956
10957 static bfd_boolean
10958 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10959 {
10960   struct got_entry *gent;
10961
10962   if (h->root.type == bfd_link_hash_indirect)
10963     return TRUE;
10964
10965   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10966     if (!gent->is_indirect)
10967       allocate_got (h, (struct bfd_link_info *) inf, gent);
10968   return TRUE;
10969 }
10970
10971 /* Called on the first multitoc pass after the last call to
10972    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10973    entries.  */
10974
10975 bfd_boolean
10976 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10977 {
10978   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10979   struct bfd *ibfd, *ibfd2;
10980   bfd_boolean done_something;
10981
10982   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10983
10984   if (!htab->do_multi_toc)
10985     return FALSE;
10986
10987   /* Merge global sym got entries within a toc group.  */
10988   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10989
10990   /* And tlsld_got.  */
10991   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10992     {
10993       struct got_entry *ent, *ent2;
10994
10995       if (!is_ppc64_elf (ibfd))
10996         continue;
10997
10998       ent = ppc64_tlsld_got (ibfd);
10999       if (!ent->is_indirect
11000           && ent->got.offset != (bfd_vma) -1)
11001         {
11002           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11003             {
11004               if (!is_ppc64_elf (ibfd2))
11005                 continue;
11006
11007               ent2 = ppc64_tlsld_got (ibfd2);
11008               if (!ent2->is_indirect
11009                   && ent2->got.offset != (bfd_vma) -1
11010                   && elf_gp (ibfd2) == elf_gp (ibfd))
11011                 {
11012                   ent2->is_indirect = TRUE;
11013                   ent2->got.ent = ent;
11014                 }
11015             }
11016         }
11017     }
11018
11019   /* Zap sizes of got sections.  */
11020   htab->reliplt->rawsize = htab->reliplt->size;
11021   htab->reliplt->size -= htab->got_reli_size;
11022   htab->got_reli_size = 0;
11023
11024   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11025     {
11026       asection *got, *relgot;
11027
11028       if (!is_ppc64_elf (ibfd))
11029         continue;
11030
11031       got = ppc64_elf_tdata (ibfd)->got;
11032       if (got != NULL)
11033         {
11034           got->rawsize = got->size;
11035           got->size = 0;
11036           relgot = ppc64_elf_tdata (ibfd)->relgot;
11037           relgot->rawsize = relgot->size;
11038           relgot->size = 0;
11039         }
11040     }
11041
11042   /* Now reallocate the got, local syms first.  We don't need to
11043      allocate section contents again since we never increase size.  */
11044   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11045     {
11046       struct got_entry **lgot_ents;
11047       struct got_entry **end_lgot_ents;
11048       struct plt_entry **local_plt;
11049       struct plt_entry **end_local_plt;
11050       unsigned char *lgot_masks;
11051       bfd_size_type locsymcount;
11052       Elf_Internal_Shdr *symtab_hdr;
11053       asection *s;
11054
11055       if (!is_ppc64_elf (ibfd))
11056         continue;
11057
11058       lgot_ents = elf_local_got_ents (ibfd);
11059       if (!lgot_ents)
11060         continue;
11061
11062       symtab_hdr = &elf_symtab_hdr (ibfd);
11063       locsymcount = symtab_hdr->sh_info;
11064       end_lgot_ents = lgot_ents + locsymcount;
11065       local_plt = (struct plt_entry **) end_lgot_ents;
11066       end_local_plt = local_plt + locsymcount;
11067       lgot_masks = (unsigned char *) end_local_plt;
11068       s = ppc64_elf_tdata (ibfd)->got;
11069       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11070         {
11071           struct got_entry *ent;
11072
11073           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11074             {
11075               unsigned int ent_size = 8;
11076               unsigned int rel_size = sizeof (Elf64_External_Rela);
11077
11078               ent->got.offset = s->size;
11079               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11080                 {
11081                   ent_size *= 2;
11082                   rel_size *= 2;
11083                 }
11084               s->size += ent_size;
11085               if ((*lgot_masks & PLT_IFUNC) != 0)
11086                 {
11087                   htab->reliplt->size += rel_size;
11088                   htab->got_reli_size += rel_size;
11089                 }
11090               else if (info->shared)
11091                 {
11092                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11093                   srel->size += rel_size;
11094                 }
11095             }
11096         }
11097     }
11098
11099   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11100
11101   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11102     {
11103       struct got_entry *ent;
11104
11105       if (!is_ppc64_elf (ibfd))
11106         continue;
11107
11108       ent = ppc64_tlsld_got (ibfd);
11109       if (!ent->is_indirect
11110           && ent->got.offset != (bfd_vma) -1)
11111         {
11112           asection *s = ppc64_elf_tdata (ibfd)->got;
11113           ent->got.offset = s->size;
11114           s->size += 16;
11115           if (info->shared)
11116             {
11117               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11118               srel->size += sizeof (Elf64_External_Rela);
11119             }
11120         }
11121     }
11122
11123   done_something = htab->reliplt->rawsize != htab->reliplt->size;
11124   if (!done_something)
11125     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11126       {
11127         asection *got;
11128
11129         if (!is_ppc64_elf (ibfd))
11130           continue;
11131
11132         got = ppc64_elf_tdata (ibfd)->got;
11133         if (got != NULL)
11134           {
11135             done_something = got->rawsize != got->size;
11136             if (done_something)
11137               break;
11138           }
11139       }
11140
11141   if (done_something)
11142     (*htab->layout_sections_again) ();
11143
11144   /* Set up for second pass over toc sections to recalculate elf_gp
11145      on input sections.  */
11146   htab->toc_bfd = NULL;
11147   htab->toc_first_sec = NULL;
11148   htab->second_toc_pass = TRUE;
11149   return done_something;
11150 }
11151
11152 /* Called after second pass of multitoc partitioning.  */
11153
11154 void
11155 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11156 {
11157   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11158
11159   /* After the second pass, toc_curr tracks the TOC offset used
11160      for code sections below in ppc64_elf_next_input_section.  */
11161   htab->toc_curr = TOC_BASE_OFF;
11162 }
11163
11164 /* No toc references were found in ISEC.  If the code in ISEC makes no
11165    calls, then there's no need to use toc adjusting stubs when branching
11166    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11167    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11168    needed, and 2 if a cyclical call-graph was found but no other reason
11169    for a stub was detected.  If called from the top level, a return of
11170    2 means the same as a return of 0.  */
11171
11172 static int
11173 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11174 {
11175   int ret;
11176
11177   /* Mark this section as checked.  */
11178   isec->call_check_done = 1;
11179
11180   /* We know none of our code bearing sections will need toc stubs.  */
11181   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11182     return 0;
11183
11184   if (isec->size == 0)
11185     return 0;
11186
11187   if (isec->output_section == NULL)
11188     return 0;
11189
11190   ret = 0;
11191   if (isec->reloc_count != 0)
11192     {
11193       Elf_Internal_Rela *relstart, *rel;
11194       Elf_Internal_Sym *local_syms;
11195       struct ppc_link_hash_table *htab;
11196
11197       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11198                                             info->keep_memory);
11199       if (relstart == NULL)
11200         return -1;
11201
11202       /* Look for branches to outside of this section.  */
11203       local_syms = NULL;
11204       htab = ppc_hash_table (info);
11205       if (htab == NULL)
11206         return -1;
11207
11208       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11209         {
11210           enum elf_ppc64_reloc_type r_type;
11211           unsigned long r_symndx;
11212           struct elf_link_hash_entry *h;
11213           struct ppc_link_hash_entry *eh;
11214           Elf_Internal_Sym *sym;
11215           asection *sym_sec;
11216           struct _opd_sec_data *opd;
11217           bfd_vma sym_value;
11218           bfd_vma dest;
11219
11220           r_type = ELF64_R_TYPE (rel->r_info);
11221           if (r_type != R_PPC64_REL24
11222               && r_type != R_PPC64_REL14
11223               && r_type != R_PPC64_REL14_BRTAKEN
11224               && r_type != R_PPC64_REL14_BRNTAKEN)
11225             continue;
11226
11227           r_symndx = ELF64_R_SYM (rel->r_info);
11228           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11229                           isec->owner))
11230             {
11231               ret = -1;
11232               break;
11233             }
11234
11235           /* Calls to dynamic lib functions go through a plt call stub
11236              that uses r2.  */
11237           eh = (struct ppc_link_hash_entry *) h;
11238           if (eh != NULL
11239               && (eh->elf.plt.plist != NULL
11240                   || (eh->oh != NULL
11241                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11242             {
11243               ret = 1;
11244               break;
11245             }
11246
11247           if (sym_sec == NULL)
11248             /* Ignore other undefined symbols.  */
11249             continue;
11250
11251           /* Assume branches to other sections not included in the
11252              link need stubs too, to cover -R and absolute syms.  */
11253           if (sym_sec->output_section == NULL)
11254             {
11255               ret = 1;
11256               break;
11257             }
11258
11259           if (h == NULL)
11260             sym_value = sym->st_value;
11261           else
11262             {
11263               if (h->root.type != bfd_link_hash_defined
11264                   && h->root.type != bfd_link_hash_defweak)
11265                 abort ();
11266               sym_value = h->root.u.def.value;
11267             }
11268           sym_value += rel->r_addend;
11269
11270           /* If this branch reloc uses an opd sym, find the code section.  */
11271           opd = get_opd_info (sym_sec);
11272           if (opd != NULL)
11273             {
11274               if (h == NULL && opd->adjust != NULL)
11275                 {
11276                   long adjust;
11277
11278                   adjust = opd->adjust[sym->st_value / 8];
11279                   if (adjust == -1)
11280                     /* Assume deleted functions won't ever be called.  */
11281                     continue;
11282                   sym_value += adjust;
11283                 }
11284
11285               dest = opd_entry_value (sym_sec, sym_value,
11286                                       &sym_sec, NULL, FALSE);
11287               if (dest == (bfd_vma) -1)
11288                 continue;
11289             }
11290           else
11291             dest = (sym_value
11292                     + sym_sec->output_offset
11293                     + sym_sec->output_section->vma);
11294
11295           /* Ignore branch to self.  */
11296           if (sym_sec == isec)
11297             continue;
11298
11299           /* If the called function uses the toc, we need a stub.  */
11300           if (sym_sec->has_toc_reloc
11301               || sym_sec->makes_toc_func_call)
11302             {
11303               ret = 1;
11304               break;
11305             }
11306
11307           /* Assume any branch that needs a long branch stub might in fact
11308              need a plt_branch stub.  A plt_branch stub uses r2.  */
11309           else if (dest - (isec->output_offset
11310                            + isec->output_section->vma
11311                            + rel->r_offset) + (1 << 25) >= (2 << 25))
11312             {
11313               ret = 1;
11314               break;
11315             }
11316
11317           /* If calling back to a section in the process of being
11318              tested, we can't say for sure that no toc adjusting stubs
11319              are needed, so don't return zero.  */
11320           else if (sym_sec->call_check_in_progress)
11321             ret = 2;
11322
11323           /* Branches to another section that itself doesn't have any TOC
11324              references are OK.  Recursively call ourselves to check.  */
11325           else if (!sym_sec->call_check_done)
11326             {
11327               int recur;
11328
11329               /* Mark current section as indeterminate, so that other
11330                  sections that call back to current won't be marked as
11331                  known.  */
11332               isec->call_check_in_progress = 1;
11333               recur = toc_adjusting_stub_needed (info, sym_sec);
11334               isec->call_check_in_progress = 0;
11335
11336               if (recur != 0)
11337                 {
11338                   ret = recur;
11339                   if (recur != 2)
11340                     break;
11341                 }
11342             }
11343         }
11344
11345       if (local_syms != NULL
11346           && (elf_symtab_hdr (isec->owner).contents
11347               != (unsigned char *) local_syms))
11348         free (local_syms);
11349       if (elf_section_data (isec)->relocs != relstart)
11350         free (relstart);
11351     }
11352
11353   if ((ret & 1) == 0
11354       && isec->map_head.s != NULL
11355       && (strcmp (isec->output_section->name, ".init") == 0
11356           || strcmp (isec->output_section->name, ".fini") == 0))
11357     {
11358       if (isec->map_head.s->has_toc_reloc
11359           || isec->map_head.s->makes_toc_func_call)
11360         ret = 1;
11361       else if (!isec->map_head.s->call_check_done)
11362         {
11363           int recur;
11364           isec->call_check_in_progress = 1;
11365           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11366           isec->call_check_in_progress = 0;
11367           if (recur != 0)
11368             ret = recur;
11369         }
11370     }
11371
11372   if (ret == 1)
11373     isec->makes_toc_func_call = 1;
11374
11375   return ret;
11376 }
11377
11378 /* The linker repeatedly calls this function for each input section,
11379    in the order that input sections are linked into output sections.
11380    Build lists of input sections to determine groupings between which
11381    we may insert linker stubs.  */
11382
11383 bfd_boolean
11384 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11385 {
11386   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11387
11388   if (htab == NULL)
11389     return FALSE;
11390
11391   if ((isec->output_section->flags & SEC_CODE) != 0
11392       && isec->output_section->index <= htab->top_index)
11393     {
11394       asection **list = htab->input_list + isec->output_section->index;
11395       /* Steal the link_sec pointer for our list.  */
11396 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11397       /* This happens to make the list in reverse order,
11398          which is what we want.  */
11399       PREV_SEC (isec) = *list;
11400       *list = isec;
11401     }
11402
11403   if (htab->multi_toc_needed)
11404     {
11405       /* If a code section has a function that uses the TOC then we need
11406          to use the right TOC (obviously).  Also, make sure that .opd gets
11407          the correct TOC value for R_PPC64_TOC relocs that don't have or
11408          can't find their function symbol (shouldn't ever happen now).
11409          Also specially treat .fixup for the linux kernel.  .fixup
11410          contains branches, but only back to the function that hit an
11411          exception.  */
11412       if (isec->has_toc_reloc
11413           || (isec->flags & SEC_CODE) == 0
11414           || strcmp (isec->name, ".fixup") == 0)
11415         {
11416           if (elf_gp (isec->owner) != 0)
11417             htab->toc_curr = elf_gp (isec->owner);
11418         }
11419       else
11420         {
11421           if (!isec->call_check_done
11422               && toc_adjusting_stub_needed (info, isec) < 0)
11423             return FALSE;
11424           /* If we make a local call from this section, ie. a branch
11425              without a following nop, then we have no place to put a
11426              toc restoring insn.  We must use the same toc group as
11427              the callee.
11428              Testing makes_toc_func_call actually tests for *any*
11429              calls to functions that need a good toc pointer.  A more
11430              precise test would be better, as this one will set
11431              incorrect values for pasted .init/.fini fragments.
11432              (Fixed later in check_pasted_section.)  */
11433           if (isec->makes_toc_func_call
11434               && elf_gp (isec->owner) != 0)
11435             htab->toc_curr = elf_gp (isec->owner);
11436         }
11437     }
11438
11439   /* Functions that don't use the TOC can belong in any TOC group.
11440      Use the last TOC base.  */
11441   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11442   return TRUE;
11443 }
11444
11445 /* Check that all .init and .fini sections use the same toc, if they
11446    have toc relocs.  */
11447
11448 static bfd_boolean
11449 check_pasted_section (struct bfd_link_info *info, const char *name)
11450 {
11451   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11452
11453   if (o != NULL)
11454     {
11455       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11456       bfd_vma toc_off = 0;
11457       asection *i;
11458
11459       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11460         if (i->has_toc_reloc)
11461           {
11462             if (toc_off == 0)
11463               toc_off = htab->stub_group[i->id].toc_off;
11464             else if (toc_off != htab->stub_group[i->id].toc_off)
11465               return FALSE;
11466           }
11467
11468       if (toc_off == 0)
11469         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11470           if (i->makes_toc_func_call)
11471             {
11472               toc_off = htab->stub_group[i->id].toc_off;
11473               break;
11474             }
11475
11476       /* Make sure the whole pasted function uses the same toc offset.  */
11477       if (toc_off != 0)
11478         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11479           htab->stub_group[i->id].toc_off = toc_off;
11480     }
11481   return TRUE;
11482 }
11483
11484 bfd_boolean
11485 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11486 {
11487   return (check_pasted_section (info, ".init")
11488           & check_pasted_section (info, ".fini"));
11489 }
11490
11491 /* See whether we can group stub sections together.  Grouping stub
11492    sections may result in fewer stubs.  More importantly, we need to
11493    put all .init* and .fini* stubs at the beginning of the .init or
11494    .fini output sections respectively, because glibc splits the
11495    _init and _fini functions into multiple parts.  Putting a stub in
11496    the middle of a function is not a good idea.  */
11497
11498 static void
11499 group_sections (struct ppc_link_hash_table *htab,
11500                 bfd_size_type stub_group_size,
11501                 bfd_boolean stubs_always_before_branch)
11502 {
11503   asection **list;
11504   bfd_size_type stub14_group_size;
11505   bfd_boolean suppress_size_errors;
11506
11507   suppress_size_errors = FALSE;
11508   stub14_group_size = stub_group_size;
11509   if (stub_group_size == 1)
11510     {
11511       /* Default values.  */
11512       if (stubs_always_before_branch)
11513         {
11514           stub_group_size = 0x1e00000;
11515           stub14_group_size = 0x7800;
11516         }
11517       else
11518         {
11519           stub_group_size = 0x1c00000;
11520           stub14_group_size = 0x7000;
11521         }
11522       suppress_size_errors = TRUE;
11523     }
11524
11525   list = htab->input_list + htab->top_index;
11526   do
11527     {
11528       asection *tail = *list;
11529       while (tail != NULL)
11530         {
11531           asection *curr;
11532           asection *prev;
11533           bfd_size_type total;
11534           bfd_boolean big_sec;
11535           bfd_vma curr_toc;
11536
11537           curr = tail;
11538           total = tail->size;
11539           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11540                              && ppc64_elf_section_data (tail)->has_14bit_branch
11541                              ? stub14_group_size : stub_group_size);
11542           if (big_sec && !suppress_size_errors)
11543             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11544                                      tail->owner, tail);
11545           curr_toc = htab->stub_group[tail->id].toc_off;
11546
11547           while ((prev = PREV_SEC (curr)) != NULL
11548                  && ((total += curr->output_offset - prev->output_offset)
11549                      < (ppc64_elf_section_data (prev) != NULL
11550                         && ppc64_elf_section_data (prev)->has_14bit_branch
11551                         ? stub14_group_size : stub_group_size))
11552                  && htab->stub_group[prev->id].toc_off == curr_toc)
11553             curr = prev;
11554
11555           /* OK, the size from the start of CURR to the end is less
11556              than stub_group_size and thus can be handled by one stub
11557              section.  (or the tail section is itself larger than
11558              stub_group_size, in which case we may be toast.)  We
11559              should really be keeping track of the total size of stubs
11560              added here, as stubs contribute to the final output
11561              section size.  That's a little tricky, and this way will
11562              only break if stubs added make the total size more than
11563              2^25, ie. for the default stub_group_size, if stubs total
11564              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11565           do
11566             {
11567               prev = PREV_SEC (tail);
11568               /* Set up this stub group.  */
11569               htab->stub_group[tail->id].link_sec = curr;
11570             }
11571           while (tail != curr && (tail = prev) != NULL);
11572
11573           /* But wait, there's more!  Input sections up to stub_group_size
11574              bytes before the stub section can be handled by it too.
11575              Don't do this if we have a really large section after the
11576              stubs, as adding more stubs increases the chance that
11577              branches may not reach into the stub section.  */
11578           if (!stubs_always_before_branch && !big_sec)
11579             {
11580               total = 0;
11581               while (prev != NULL
11582                      && ((total += tail->output_offset - prev->output_offset)
11583                          < (ppc64_elf_section_data (prev) != NULL
11584                             && ppc64_elf_section_data (prev)->has_14bit_branch
11585                             ? stub14_group_size : stub_group_size))
11586                      && htab->stub_group[prev->id].toc_off == curr_toc)
11587                 {
11588                   tail = prev;
11589                   prev = PREV_SEC (tail);
11590                   htab->stub_group[tail->id].link_sec = curr;
11591                 }
11592             }
11593           tail = prev;
11594         }
11595     }
11596   while (list-- != htab->input_list);
11597   free (htab->input_list);
11598 #undef PREV_SEC
11599 }
11600
11601 static const unsigned char glink_eh_frame_cie[] =
11602 {
11603   0, 0, 0, 16,                          /* length.  */
11604   0, 0, 0, 0,                           /* id.  */
11605   1,                                    /* CIE version.  */
11606   'z', 'R', 0,                          /* Augmentation string.  */
11607   4,                                    /* Code alignment.  */
11608   0x78,                                 /* Data alignment.  */
11609   65,                                   /* RA reg.  */
11610   1,                                    /* Augmentation size.  */
11611   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11612   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11613 };
11614
11615 /* Stripping output sections is normally done before dynamic section
11616    symbols have been allocated.  This function is called later, and
11617    handles cases like htab->brlt which is mapped to its own output
11618    section.  */
11619
11620 static void
11621 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11622 {
11623   if (isec->size == 0
11624       && isec->output_section->size == 0
11625       && !(isec->output_section->flags & SEC_KEEP)
11626       && !bfd_section_removed_from_list (info->output_bfd,
11627                                          isec->output_section)
11628       && elf_section_data (isec->output_section)->dynindx == 0)
11629     {
11630       isec->output_section->flags |= SEC_EXCLUDE;
11631       bfd_section_list_remove (info->output_bfd, isec->output_section);
11632       info->output_bfd->section_count--;
11633     }
11634 }
11635
11636 /* Determine and set the size of the stub section for a final link.
11637
11638    The basic idea here is to examine all the relocations looking for
11639    PC-relative calls to a target that is unreachable with a "bl"
11640    instruction.  */
11641
11642 bfd_boolean
11643 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11644                       bfd_boolean plt_static_chain, int plt_thread_safe,
11645                       int plt_stub_align)
11646 {
11647   bfd_size_type stub_group_size;
11648   bfd_boolean stubs_always_before_branch;
11649   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11650
11651   if (htab == NULL)
11652     return FALSE;
11653
11654   htab->plt_static_chain = plt_static_chain;
11655   htab->plt_stub_align = plt_stub_align;
11656   if (plt_thread_safe == -1 && !info->executable)
11657     plt_thread_safe = 1;
11658   if (plt_thread_safe == -1)
11659     {
11660       static const char *const thread_starter[] =
11661         {
11662           "pthread_create",
11663           /* libstdc++ */
11664           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11665           /* librt */
11666           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11667           "mq_notify", "create_timer",
11668           /* libanl */
11669           "getaddrinfo_a",
11670           /* libgomp */
11671           "GOMP_parallel_start",
11672           "GOMP_parallel_loop_static_start",
11673           "GOMP_parallel_loop_dynamic_start",
11674           "GOMP_parallel_loop_guided_start",
11675           "GOMP_parallel_loop_runtime_start",
11676           "GOMP_parallel_sections_start",
11677         };
11678       unsigned i;
11679
11680       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11681         {
11682           struct elf_link_hash_entry *h;
11683           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11684                                     FALSE, FALSE, TRUE);
11685           plt_thread_safe = h != NULL && h->ref_regular;
11686           if (plt_thread_safe)
11687             break;
11688         }
11689     }
11690   htab->plt_thread_safe = plt_thread_safe;
11691   stubs_always_before_branch = group_size < 0;
11692   if (group_size < 0)
11693     stub_group_size = -group_size;
11694   else
11695     stub_group_size = group_size;
11696
11697   group_sections (htab, stub_group_size, stubs_always_before_branch);
11698
11699   while (1)
11700     {
11701       bfd *input_bfd;
11702       unsigned int bfd_indx;
11703       asection *stub_sec;
11704
11705       htab->stub_iteration += 1;
11706
11707       for (input_bfd = info->input_bfds, bfd_indx = 0;
11708            input_bfd != NULL;
11709            input_bfd = input_bfd->link_next, bfd_indx++)
11710         {
11711           Elf_Internal_Shdr *symtab_hdr;
11712           asection *section;
11713           Elf_Internal_Sym *local_syms = NULL;
11714
11715           if (!is_ppc64_elf (input_bfd))
11716             continue;
11717
11718           /* We'll need the symbol table in a second.  */
11719           symtab_hdr = &elf_symtab_hdr (input_bfd);
11720           if (symtab_hdr->sh_info == 0)
11721             continue;
11722
11723           /* Walk over each section attached to the input bfd.  */
11724           for (section = input_bfd->sections;
11725                section != NULL;
11726                section = section->next)
11727             {
11728               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11729
11730               /* If there aren't any relocs, then there's nothing more
11731                  to do.  */
11732               if ((section->flags & SEC_RELOC) == 0
11733                   || (section->flags & SEC_ALLOC) == 0
11734                   || (section->flags & SEC_LOAD) == 0
11735                   || (section->flags & SEC_CODE) == 0
11736                   || section->reloc_count == 0)
11737                 continue;
11738
11739               /* If this section is a link-once section that will be
11740                  discarded, then don't create any stubs.  */
11741               if (section->output_section == NULL
11742                   || section->output_section->owner != info->output_bfd)
11743                 continue;
11744
11745               /* Get the relocs.  */
11746               internal_relocs
11747                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11748                                              info->keep_memory);
11749               if (internal_relocs == NULL)
11750                 goto error_ret_free_local;
11751
11752               /* Now examine each relocation.  */
11753               irela = internal_relocs;
11754               irelaend = irela + section->reloc_count;
11755               for (; irela < irelaend; irela++)
11756                 {
11757                   enum elf_ppc64_reloc_type r_type;
11758                   unsigned int r_indx;
11759                   enum ppc_stub_type stub_type;
11760                   struct ppc_stub_hash_entry *stub_entry;
11761                   asection *sym_sec, *code_sec;
11762                   bfd_vma sym_value, code_value;
11763                   bfd_vma destination;
11764                   bfd_boolean ok_dest;
11765                   struct ppc_link_hash_entry *hash;
11766                   struct ppc_link_hash_entry *fdh;
11767                   struct elf_link_hash_entry *h;
11768                   Elf_Internal_Sym *sym;
11769                   char *stub_name;
11770                   const asection *id_sec;
11771                   struct _opd_sec_data *opd;
11772                   struct plt_entry *plt_ent;
11773
11774                   r_type = ELF64_R_TYPE (irela->r_info);
11775                   r_indx = ELF64_R_SYM (irela->r_info);
11776
11777                   if (r_type >= R_PPC64_max)
11778                     {
11779                       bfd_set_error (bfd_error_bad_value);
11780                       goto error_ret_free_internal;
11781                     }
11782
11783                   /* Only look for stubs on branch instructions.  */
11784                   if (r_type != R_PPC64_REL24
11785                       && r_type != R_PPC64_REL14
11786                       && r_type != R_PPC64_REL14_BRTAKEN
11787                       && r_type != R_PPC64_REL14_BRNTAKEN)
11788                     continue;
11789
11790                   /* Now determine the call target, its name, value,
11791                      section.  */
11792                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11793                                   r_indx, input_bfd))
11794                     goto error_ret_free_internal;
11795                   hash = (struct ppc_link_hash_entry *) h;
11796
11797                   ok_dest = FALSE;
11798                   fdh = NULL;
11799                   sym_value = 0;
11800                   if (hash == NULL)
11801                     {
11802                       sym_value = sym->st_value;
11803                       ok_dest = TRUE;
11804                     }
11805                   else if (hash->elf.root.type == bfd_link_hash_defined
11806                            || hash->elf.root.type == bfd_link_hash_defweak)
11807                     {
11808                       sym_value = hash->elf.root.u.def.value;
11809                       if (sym_sec->output_section != NULL)
11810                         ok_dest = TRUE;
11811                     }
11812                   else if (hash->elf.root.type == bfd_link_hash_undefweak
11813                            || hash->elf.root.type == bfd_link_hash_undefined)
11814                     {
11815                       /* Recognise an old ABI func code entry sym, and
11816                          use the func descriptor sym instead if it is
11817                          defined.  */
11818                       if (hash->elf.root.root.string[0] == '.'
11819                           && (fdh = lookup_fdh (hash, htab)) != NULL)
11820                         {
11821                           if (fdh->elf.root.type == bfd_link_hash_defined
11822                               || fdh->elf.root.type == bfd_link_hash_defweak)
11823                             {
11824                               sym_sec = fdh->elf.root.u.def.section;
11825                               sym_value = fdh->elf.root.u.def.value;
11826                               if (sym_sec->output_section != NULL)
11827                                 ok_dest = TRUE;
11828                             }
11829                           else
11830                             fdh = NULL;
11831                         }
11832                     }
11833                   else
11834                     {
11835                       bfd_set_error (bfd_error_bad_value);
11836                       goto error_ret_free_internal;
11837                     }
11838
11839                   destination = 0;
11840                   if (ok_dest)
11841                     {
11842                       sym_value += irela->r_addend;
11843                       destination = (sym_value
11844                                      + sym_sec->output_offset
11845                                      + sym_sec->output_section->vma);
11846                     }
11847
11848                   code_sec = sym_sec;
11849                   code_value = sym_value;
11850                   opd = get_opd_info (sym_sec);
11851                   if (opd != NULL)
11852                     {
11853                       bfd_vma dest;
11854
11855                       if (hash == NULL && opd->adjust != NULL)
11856                         {
11857                           long adjust = opd->adjust[sym_value / 8];
11858                           if (adjust == -1)
11859                             continue;
11860                           code_value += adjust;
11861                           sym_value += adjust;
11862                         }
11863                       dest = opd_entry_value (sym_sec, sym_value,
11864                                               &code_sec, &code_value, FALSE);
11865                       if (dest != (bfd_vma) -1)
11866                         {
11867                           destination = dest;
11868                           if (fdh != NULL)
11869                             {
11870                               /* Fixup old ABI sym to point at code
11871                                  entry.  */
11872                               hash->elf.root.type = bfd_link_hash_defweak;
11873                               hash->elf.root.u.def.section = code_sec;
11874                               hash->elf.root.u.def.value = code_value;
11875                             }
11876                         }
11877                     }
11878
11879                   /* Determine what (if any) linker stub is needed.  */
11880                   plt_ent = NULL;
11881                   stub_type = ppc_type_of_stub (section, irela, &hash,
11882                                                 &plt_ent, destination);
11883
11884                   if (stub_type != ppc_stub_plt_call)
11885                     {
11886                       /* Check whether we need a TOC adjusting stub.
11887                          Since the linker pastes together pieces from
11888                          different object files when creating the
11889                          _init and _fini functions, it may be that a
11890                          call to what looks like a local sym is in
11891                          fact a call needing a TOC adjustment.  */
11892                       if (code_sec != NULL
11893                           && code_sec->output_section != NULL
11894                           && (htab->stub_group[code_sec->id].toc_off
11895                               != htab->stub_group[section->id].toc_off)
11896                           && (code_sec->has_toc_reloc
11897                               || code_sec->makes_toc_func_call))
11898                         stub_type = ppc_stub_long_branch_r2off;
11899                     }
11900
11901                   if (stub_type == ppc_stub_none)
11902                     continue;
11903
11904                   /* __tls_get_addr calls might be eliminated.  */
11905                   if (stub_type != ppc_stub_plt_call
11906                       && hash != NULL
11907                       && (hash == htab->tls_get_addr
11908                           || hash == htab->tls_get_addr_fd)
11909                       && section->has_tls_reloc
11910                       && irela != internal_relocs)
11911                     {
11912                       /* Get tls info.  */
11913                       unsigned char *tls_mask;
11914
11915                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11916                                          irela - 1, input_bfd))
11917                         goto error_ret_free_internal;
11918                       if (*tls_mask != 0)
11919                         continue;
11920                     }
11921
11922                   if (stub_type == ppc_stub_plt_call
11923                       && irela + 1 < irelaend
11924                       && irela[1].r_offset == irela->r_offset + 4
11925                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
11926                     {
11927                       if (!tocsave_find (htab, INSERT,
11928                                          &local_syms, irela + 1, input_bfd))
11929                         goto error_ret_free_internal;
11930                     }
11931                   else if (stub_type == ppc_stub_plt_call)
11932                     stub_type = ppc_stub_plt_call_r2save;
11933
11934                   /* Support for grouping stub sections.  */
11935                   id_sec = htab->stub_group[section->id].link_sec;
11936
11937                   /* Get the name of this stub.  */
11938                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11939                   if (!stub_name)
11940                     goto error_ret_free_internal;
11941
11942                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11943                                                      stub_name, FALSE, FALSE);
11944                   if (stub_entry != NULL)
11945                     {
11946                       /* The proper stub has already been created.  */
11947                       free (stub_name);
11948                       if (stub_type == ppc_stub_plt_call_r2save)
11949                         stub_entry->stub_type = stub_type;
11950                       continue;
11951                     }
11952
11953                   stub_entry = ppc_add_stub (stub_name, section, info);
11954                   if (stub_entry == NULL)
11955                     {
11956                       free (stub_name);
11957                     error_ret_free_internal:
11958                       if (elf_section_data (section)->relocs == NULL)
11959                         free (internal_relocs);
11960                     error_ret_free_local:
11961                       if (local_syms != NULL
11962                           && (symtab_hdr->contents
11963                               != (unsigned char *) local_syms))
11964                         free (local_syms);
11965                       return FALSE;
11966                     }
11967
11968                   stub_entry->stub_type = stub_type;
11969                   if (stub_type != ppc_stub_plt_call
11970                       && stub_type != ppc_stub_plt_call_r2save)
11971                     {
11972                       stub_entry->target_value = code_value;
11973                       stub_entry->target_section = code_sec;
11974                     }
11975                   else
11976                     {
11977                       stub_entry->target_value = sym_value;
11978                       stub_entry->target_section = sym_sec;
11979                     }
11980                   stub_entry->h = hash;
11981                   stub_entry->plt_ent = plt_ent;
11982
11983                   if (stub_entry->h != NULL)
11984                     htab->stub_globals += 1;
11985                 }
11986
11987               /* We're done with the internal relocs, free them.  */
11988               if (elf_section_data (section)->relocs != internal_relocs)
11989                 free (internal_relocs);
11990             }
11991
11992           if (local_syms != NULL
11993               && symtab_hdr->contents != (unsigned char *) local_syms)
11994             {
11995               if (!info->keep_memory)
11996                 free (local_syms);
11997               else
11998                 symtab_hdr->contents = (unsigned char *) local_syms;
11999             }
12000         }
12001
12002       /* We may have added some stubs.  Find out the new size of the
12003          stub sections.  */
12004       for (stub_sec = htab->stub_bfd->sections;
12005            stub_sec != NULL;
12006            stub_sec = stub_sec->next)
12007         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12008           {
12009             stub_sec->rawsize = stub_sec->size;
12010             stub_sec->size = 0;
12011             stub_sec->reloc_count = 0;
12012             stub_sec->flags &= ~SEC_RELOC;
12013           }
12014
12015       htab->brlt->size = 0;
12016       htab->brlt->reloc_count = 0;
12017       htab->brlt->flags &= ~SEC_RELOC;
12018       if (htab->relbrlt != NULL)
12019         htab->relbrlt->size = 0;
12020
12021       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12022
12023       if (info->emitrelocations
12024           && htab->glink != NULL && htab->glink->size != 0)
12025         {
12026           htab->glink->reloc_count = 1;
12027           htab->glink->flags |= SEC_RELOC;
12028         }
12029
12030       if (htab->glink_eh_frame != NULL
12031           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12032           && htab->glink_eh_frame->output_section->size != 0)
12033         {
12034           size_t size = 0, align;
12035
12036           for (stub_sec = htab->stub_bfd->sections;
12037                stub_sec != NULL;
12038                stub_sec = stub_sec->next)
12039             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12040               size += 20;
12041           if (htab->glink != NULL && htab->glink->size != 0)
12042             size += 24;
12043           if (size != 0)
12044             size += sizeof (glink_eh_frame_cie);
12045           align = 1;
12046           align <<= htab->glink_eh_frame->output_section->alignment_power;
12047           align -= 1;
12048           size = (size + align) & ~align;
12049           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12050           htab->glink_eh_frame->size = size;
12051         }
12052
12053       if (htab->plt_stub_align != 0)
12054         for (stub_sec = htab->stub_bfd->sections;
12055              stub_sec != NULL;
12056              stub_sec = stub_sec->next)
12057           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12058             stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12059                               & (-1 << htab->plt_stub_align));
12060
12061       for (stub_sec = htab->stub_bfd->sections;
12062            stub_sec != NULL;
12063            stub_sec = stub_sec->next)
12064         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12065             && stub_sec->rawsize != stub_sec->size)
12066           break;
12067
12068       /* Exit from this loop when no stubs have been added, and no stubs
12069          have changed size.  */
12070       if (stub_sec == NULL
12071           && (htab->glink_eh_frame == NULL
12072               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12073         break;
12074
12075       /* Ask the linker to do its stuff.  */
12076       (*htab->layout_sections_again) ();
12077     }
12078
12079   maybe_strip_output (info, htab->brlt);
12080   if (htab->glink_eh_frame != NULL)
12081     maybe_strip_output (info, htab->glink_eh_frame);
12082
12083   return TRUE;
12084 }
12085
12086 /* Called after we have determined section placement.  If sections
12087    move, we'll be called again.  Provide a value for TOCstart.  */
12088
12089 bfd_vma
12090 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12091 {
12092   asection *s;
12093   bfd_vma TOCstart;
12094
12095   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12096      order.  The TOC starts where the first of these sections starts.  */
12097   s = bfd_get_section_by_name (obfd, ".got");
12098   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12099     s = bfd_get_section_by_name (obfd, ".toc");
12100   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12101     s = bfd_get_section_by_name (obfd, ".tocbss");
12102   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12103     s = bfd_get_section_by_name (obfd, ".plt");
12104   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12105     {
12106       /* This may happen for
12107          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12108          .toc directive
12109          o  bad linker script
12110          o --gc-sections and empty TOC sections
12111
12112          FIXME: Warn user?  */
12113
12114       /* Look for a likely section.  We probably won't even be
12115          using TOCstart.  */
12116       for (s = obfd->sections; s != NULL; s = s->next)
12117         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12118                          | SEC_EXCLUDE))
12119             == (SEC_ALLOC | SEC_SMALL_DATA))
12120           break;
12121       if (s == NULL)
12122         for (s = obfd->sections; s != NULL; s = s->next)
12123           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12124               == (SEC_ALLOC | SEC_SMALL_DATA))
12125             break;
12126       if (s == NULL)
12127         for (s = obfd->sections; s != NULL; s = s->next)
12128           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12129               == SEC_ALLOC)
12130             break;
12131       if (s == NULL)
12132         for (s = obfd->sections; s != NULL; s = s->next)
12133           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12134             break;
12135     }
12136
12137   TOCstart = 0;
12138   if (s != NULL)
12139     TOCstart = s->output_section->vma + s->output_offset;
12140
12141   _bfd_set_gp_value (obfd, TOCstart);
12142
12143   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12144     {
12145       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12146
12147       if (htab != NULL
12148           && htab->elf.hgot != NULL)
12149         {
12150           htab->elf.hgot->type = STT_OBJECT;
12151           htab->elf.hgot->root.type = bfd_link_hash_defined;
12152           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12153           htab->elf.hgot->root.u.def.section = s;
12154         }
12155     }
12156   return TOCstart;
12157 }
12158
12159 /* Build all the stubs associated with the current output file.
12160    The stubs are kept in a hash table attached to the main linker
12161    hash table.  This function is called via gldelf64ppc_finish.  */
12162
12163 bfd_boolean
12164 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12165                        struct bfd_link_info *info,
12166                        char **stats)
12167 {
12168   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12169   asection *stub_sec;
12170   bfd_byte *p;
12171   int stub_sec_count = 0;
12172
12173   if (htab == NULL)
12174     return FALSE;
12175
12176   htab->emit_stub_syms = emit_stub_syms;
12177
12178   /* Allocate memory to hold the linker stubs.  */
12179   for (stub_sec = htab->stub_bfd->sections;
12180        stub_sec != NULL;
12181        stub_sec = stub_sec->next)
12182     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12183         && stub_sec->size != 0)
12184       {
12185         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12186         if (stub_sec->contents == NULL)
12187           return FALSE;
12188         /* We want to check that built size is the same as calculated
12189            size.  rawsize is a convenient location to use.  */
12190         stub_sec->rawsize = stub_sec->size;
12191         stub_sec->size = 0;
12192       }
12193
12194   if (htab->glink != NULL && htab->glink->size != 0)
12195     {
12196       unsigned int indx;
12197       bfd_vma plt0;
12198
12199       /* Build the .glink plt call stub.  */
12200       if (htab->emit_stub_syms)
12201         {
12202           struct elf_link_hash_entry *h;
12203           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12204                                     TRUE, FALSE, FALSE);
12205           if (h == NULL)
12206             return FALSE;
12207           if (h->root.type == bfd_link_hash_new)
12208             {
12209               h->root.type = bfd_link_hash_defined;
12210               h->root.u.def.section = htab->glink;
12211               h->root.u.def.value = 8;
12212               h->ref_regular = 1;
12213               h->def_regular = 1;
12214               h->ref_regular_nonweak = 1;
12215               h->forced_local = 1;
12216               h->non_elf = 0;
12217             }
12218         }
12219       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
12220       if (info->emitrelocations)
12221         {
12222           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12223           if (r == NULL)
12224             return FALSE;
12225           r->r_offset = (htab->glink->output_offset
12226                          + htab->glink->output_section->vma);
12227           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12228           r->r_addend = plt0;
12229         }
12230       p = htab->glink->contents;
12231       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12232       bfd_put_64 (htab->glink->owner, plt0, p);
12233       p += 8;
12234       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12235       p += 4;
12236       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12237       p += 4;
12238       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12239       p += 4;
12240       bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12241       p += 4;
12242       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12243       p += 4;
12244       bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12245       p += 4;
12246       bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12247       p += 4;
12248       bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12249       p += 4;
12250       bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12251       p += 4;
12252       bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12253       p += 4;
12254       bfd_put_32 (htab->glink->owner, BCTR, p);
12255       p += 4;
12256       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12257         {
12258           bfd_put_32 (htab->glink->owner, NOP, p);
12259           p += 4;
12260         }
12261
12262       /* Build the .glink lazy link call stubs.  */
12263       indx = 0;
12264       while (p < htab->glink->contents + htab->glink->size)
12265         {
12266           if (indx < 0x8000)
12267             {
12268               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12269               p += 4;
12270             }
12271           else
12272             {
12273               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12274               p += 4;
12275               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
12276               p += 4;
12277             }
12278           bfd_put_32 (htab->glink->owner,
12279                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12280           indx++;
12281           p += 4;
12282         }
12283       htab->glink->rawsize = p - htab->glink->contents;
12284     }
12285
12286   if (htab->brlt->size != 0)
12287     {
12288       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12289                                          htab->brlt->size);
12290       if (htab->brlt->contents == NULL)
12291         return FALSE;
12292     }
12293   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12294     {
12295       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12296                                             htab->relbrlt->size);
12297       if (htab->relbrlt->contents == NULL)
12298         return FALSE;
12299     }
12300
12301   if (htab->glink_eh_frame != NULL
12302       && htab->glink_eh_frame->size != 0)
12303     {
12304       bfd_vma val;
12305       bfd_byte *last_fde;
12306       size_t last_fde_len, size, align, pad;
12307
12308       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12309       if (p == NULL)
12310         return FALSE;
12311       htab->glink_eh_frame->contents = p;
12312       last_fde = p;
12313
12314       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12315
12316       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12317       /* CIE length (rewrite in case little-endian).  */
12318       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12319       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12320       p += sizeof (glink_eh_frame_cie);
12321
12322       for (stub_sec = htab->stub_bfd->sections;
12323            stub_sec != NULL;
12324            stub_sec = stub_sec->next)
12325         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12326           {
12327             last_fde = p;
12328             last_fde_len = 16;
12329             /* FDE length.  */
12330             bfd_put_32 (htab->elf.dynobj, 16, p);
12331             p += 4;
12332             /* CIE pointer.  */
12333             val = p - htab->glink_eh_frame->contents;
12334             bfd_put_32 (htab->elf.dynobj, val, p);
12335             p += 4;
12336             /* Offset to stub section.  */
12337             val = (stub_sec->output_section->vma
12338                    + stub_sec->output_offset);
12339             val -= (htab->glink_eh_frame->output_section->vma
12340                     + htab->glink_eh_frame->output_offset);
12341             val -= p - htab->glink_eh_frame->contents;
12342             if (val + 0x80000000 > 0xffffffff)
12343               {
12344                 info->callbacks->einfo
12345                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12346                    stub_sec->name);
12347                 return FALSE;
12348               }
12349             bfd_put_32 (htab->elf.dynobj, val, p);
12350             p += 4;
12351             /* stub section size.  */
12352             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12353             p += 4;
12354             /* Augmentation.  */
12355             p += 1;
12356             /* Pad.  */
12357             p += 3;
12358           }
12359       if (htab->glink != NULL && htab->glink->size != 0)
12360         {
12361           last_fde = p;
12362           last_fde_len = 20;
12363           /* FDE length.  */
12364           bfd_put_32 (htab->elf.dynobj, 20, p);
12365           p += 4;
12366           /* CIE pointer.  */
12367           val = p - htab->glink_eh_frame->contents;
12368           bfd_put_32 (htab->elf.dynobj, val, p);
12369           p += 4;
12370           /* Offset to .glink.  */
12371           val = (htab->glink->output_section->vma
12372                  + htab->glink->output_offset
12373                  + 8);
12374           val -= (htab->glink_eh_frame->output_section->vma
12375                   + htab->glink_eh_frame->output_offset);
12376           val -= p - htab->glink_eh_frame->contents;
12377           if (val + 0x80000000 > 0xffffffff)
12378             {
12379               info->callbacks->einfo
12380                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12381                  htab->glink->name);
12382               return FALSE;
12383             }
12384           bfd_put_32 (htab->elf.dynobj, val, p);
12385           p += 4;
12386           /* .glink size.  */
12387           bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
12388           p += 4;
12389           /* Augmentation.  */
12390           p += 1;
12391
12392           *p++ = DW_CFA_advance_loc + 1;
12393           *p++ = DW_CFA_register;
12394           *p++ = 65;
12395           *p++ = 12;
12396           *p++ = DW_CFA_advance_loc + 4;
12397           *p++ = DW_CFA_restore_extended;
12398           *p++ = 65;
12399         }
12400       /* Subsume any padding into the last FDE if user .eh_frame
12401          sections are aligned more than glink_eh_frame.  Otherwise any
12402          zero padding will be seen as a terminator.  */
12403       size = p - htab->glink_eh_frame->contents;
12404       align = 1;
12405       align <<= htab->glink_eh_frame->output_section->alignment_power;
12406       align -= 1;
12407       pad = ((size + align) & ~align) - size;
12408       htab->glink_eh_frame->size = size + pad;
12409       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12410     }
12411
12412   /* Build the stubs as directed by the stub hash table.  */
12413   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12414
12415   if (htab->relbrlt != NULL)
12416     htab->relbrlt->reloc_count = 0;
12417
12418   if (htab->plt_stub_align != 0)
12419     for (stub_sec = htab->stub_bfd->sections;
12420          stub_sec != NULL;
12421          stub_sec = stub_sec->next)
12422       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12423         stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12424                           & (-1 << htab->plt_stub_align));
12425
12426   for (stub_sec = htab->stub_bfd->sections;
12427        stub_sec != NULL;
12428        stub_sec = stub_sec->next)
12429     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12430       {
12431         stub_sec_count += 1;
12432         if (stub_sec->rawsize != stub_sec->size)
12433           break;
12434       }
12435
12436   if (stub_sec != NULL
12437       || htab->glink->rawsize != htab->glink->size
12438       || (htab->glink_eh_frame != NULL
12439           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12440     {
12441       htab->stub_error = TRUE;
12442       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12443     }
12444
12445   if (htab->stub_error)
12446     return FALSE;
12447
12448   if (stats != NULL)
12449     {
12450       *stats = bfd_malloc (500);
12451       if (*stats == NULL)
12452         return FALSE;
12453
12454       sprintf (*stats, _("linker stubs in %u group%s\n"
12455                          "  branch       %lu\n"
12456                          "  toc adjust   %lu\n"
12457                          "  long branch  %lu\n"
12458                          "  long toc adj %lu\n"
12459                          "  plt call     %lu\n"
12460                          "  plt call toc %lu"),
12461                stub_sec_count,
12462                stub_sec_count == 1 ? "" : "s",
12463                htab->stub_count[ppc_stub_long_branch - 1],
12464                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12465                htab->stub_count[ppc_stub_plt_branch - 1],
12466                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12467                htab->stub_count[ppc_stub_plt_call - 1],
12468                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12469     }
12470   return TRUE;
12471 }
12472
12473 /* This function undoes the changes made by add_symbol_adjust.  */
12474
12475 static bfd_boolean
12476 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12477 {
12478   struct ppc_link_hash_entry *eh;
12479
12480   if (h->root.type == bfd_link_hash_indirect)
12481     return TRUE;
12482
12483   eh = (struct ppc_link_hash_entry *) h;
12484   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12485     return TRUE;
12486
12487   eh->elf.root.type = bfd_link_hash_undefined;
12488   return TRUE;
12489 }
12490
12491 void
12492 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12493 {
12494   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12495
12496   if (htab != NULL)
12497     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12498 }
12499
12500 /* What to do when ld finds relocations against symbols defined in
12501    discarded sections.  */
12502
12503 static unsigned int
12504 ppc64_elf_action_discarded (asection *sec)
12505 {
12506   if (strcmp (".opd", sec->name) == 0)
12507     return 0;
12508
12509   if (strcmp (".toc", sec->name) == 0)
12510     return 0;
12511
12512   if (strcmp (".toc1", sec->name) == 0)
12513     return 0;
12514
12515   return _bfd_elf_default_action_discarded (sec);
12516 }
12517
12518 /* The RELOCATE_SECTION function is called by the ELF backend linker
12519    to handle the relocations for a section.
12520
12521    The relocs are always passed as Rela structures; if the section
12522    actually uses Rel structures, the r_addend field will always be
12523    zero.
12524
12525    This function is responsible for adjust the section contents as
12526    necessary, and (if using Rela relocs and generating a
12527    relocatable output file) adjusting the reloc addend as
12528    necessary.
12529
12530    This function does not have to worry about setting the reloc
12531    address or the reloc symbol index.
12532
12533    LOCAL_SYMS is a pointer to the swapped in local symbols.
12534
12535    LOCAL_SECTIONS is an array giving the section in the input file
12536    corresponding to the st_shndx field of each local symbol.
12537
12538    The global hash table entry for the global symbols can be found
12539    via elf_sym_hashes (input_bfd).
12540
12541    When generating relocatable output, this function must handle
12542    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12543    going to be the section symbol corresponding to the output
12544    section, which means that the addend must be adjusted
12545    accordingly.  */
12546
12547 static bfd_boolean
12548 ppc64_elf_relocate_section (bfd *output_bfd,
12549                             struct bfd_link_info *info,
12550                             bfd *input_bfd,
12551                             asection *input_section,
12552                             bfd_byte *contents,
12553                             Elf_Internal_Rela *relocs,
12554                             Elf_Internal_Sym *local_syms,
12555                             asection **local_sections)
12556 {
12557   struct ppc_link_hash_table *htab;
12558   Elf_Internal_Shdr *symtab_hdr;
12559   struct elf_link_hash_entry **sym_hashes;
12560   Elf_Internal_Rela *rel;
12561   Elf_Internal_Rela *relend;
12562   Elf_Internal_Rela outrel;
12563   bfd_byte *loc;
12564   struct got_entry **local_got_ents;
12565   bfd_vma TOCstart;
12566   bfd_boolean ret = TRUE;
12567   bfd_boolean is_opd;
12568   /* Assume 'at' branch hints.  */
12569   bfd_boolean is_isa_v2 = TRUE;
12570   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12571
12572   /* Initialize howto table if needed.  */
12573   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12574     ppc_howto_init ();
12575
12576   htab = ppc_hash_table (info);
12577   if (htab == NULL)
12578     return FALSE;
12579
12580   /* Don't relocate stub sections.  */
12581   if (input_section->owner == htab->stub_bfd)
12582     return TRUE;
12583
12584   BFD_ASSERT (is_ppc64_elf (input_bfd));
12585
12586   local_got_ents = elf_local_got_ents (input_bfd);
12587   TOCstart = elf_gp (output_bfd);
12588   symtab_hdr = &elf_symtab_hdr (input_bfd);
12589   sym_hashes = elf_sym_hashes (input_bfd);
12590   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12591
12592   rel = relocs;
12593   relend = relocs + input_section->reloc_count;
12594   for (; rel < relend; rel++)
12595     {
12596       enum elf_ppc64_reloc_type r_type;
12597       bfd_vma addend;
12598       bfd_reloc_status_type r;
12599       Elf_Internal_Sym *sym;
12600       asection *sec;
12601       struct elf_link_hash_entry *h_elf;
12602       struct ppc_link_hash_entry *h;
12603       struct ppc_link_hash_entry *fdh;
12604       const char *sym_name;
12605       unsigned long r_symndx, toc_symndx;
12606       bfd_vma toc_addend;
12607       unsigned char tls_mask, tls_gd, tls_type;
12608       unsigned char sym_type;
12609       bfd_vma relocation;
12610       bfd_boolean unresolved_reloc;
12611       bfd_boolean warned;
12612       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12613       unsigned int insn;
12614       unsigned int mask;
12615       struct ppc_stub_hash_entry *stub_entry;
12616       bfd_vma max_br_offset;
12617       bfd_vma from;
12618       const Elf_Internal_Rela orig_rel = *rel;
12619
12620       r_type = ELF64_R_TYPE (rel->r_info);
12621       r_symndx = ELF64_R_SYM (rel->r_info);
12622
12623       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12624          symbol of the previous ADDR64 reloc.  The symbol gives us the
12625          proper TOC base to use.  */
12626       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12627           && rel != relocs
12628           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12629           && is_opd)
12630         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12631
12632       sym = NULL;
12633       sec = NULL;
12634       h_elf = NULL;
12635       sym_name = NULL;
12636       unresolved_reloc = FALSE;
12637       warned = FALSE;
12638
12639       if (r_symndx < symtab_hdr->sh_info)
12640         {
12641           /* It's a local symbol.  */
12642           struct _opd_sec_data *opd;
12643
12644           sym = local_syms + r_symndx;
12645           sec = local_sections[r_symndx];
12646           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12647           sym_type = ELF64_ST_TYPE (sym->st_info);
12648           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12649           opd = get_opd_info (sec);
12650           if (opd != NULL && opd->adjust != NULL)
12651             {
12652               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12653               if (adjust == -1)
12654                 relocation = 0;
12655               else
12656                 {
12657                   /* If this is a relocation against the opd section sym
12658                      and we have edited .opd, adjust the reloc addend so
12659                      that ld -r and ld --emit-relocs output is correct.
12660                      If it is a reloc against some other .opd symbol,
12661                      then the symbol value will be adjusted later.  */
12662                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12663                     rel->r_addend += adjust;
12664                   else
12665                     relocation += adjust;
12666                 }
12667             }
12668         }
12669       else
12670         {
12671           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12672                                    r_symndx, symtab_hdr, sym_hashes,
12673                                    h_elf, sec, relocation,
12674                                    unresolved_reloc, warned);
12675           sym_name = h_elf->root.root.string;
12676           sym_type = h_elf->type;
12677           if (sec != NULL
12678               && sec->owner == output_bfd
12679               && strcmp (sec->name, ".opd") == 0)
12680             {
12681               /* This is a symbol defined in a linker script.  All
12682                  such are defined in output sections, even those
12683                  defined by simple assignment from a symbol defined in
12684                  an input section.  Transfer the symbol to an
12685                  appropriate input .opd section, so that a branch to
12686                  this symbol will be mapped to the location specified
12687                  by the opd entry.  */
12688               struct bfd_link_order *lo;
12689               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12690                 if (lo->type == bfd_indirect_link_order)
12691                   {
12692                     asection *isec = lo->u.indirect.section;
12693                     if (h_elf->root.u.def.value >= isec->output_offset
12694                         && h_elf->root.u.def.value < (isec->output_offset
12695                                                       + isec->size))
12696                       {
12697                         h_elf->root.u.def.value -= isec->output_offset;
12698                         h_elf->root.u.def.section = isec;
12699                         sec = isec;
12700                         break;
12701                       }
12702                   }
12703             }
12704         }
12705       h = (struct ppc_link_hash_entry *) h_elf;
12706
12707       if (sec != NULL && discarded_section (sec))
12708         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12709                                          rel, 1, relend,
12710                                          ppc64_elf_howto_table[r_type], 0,
12711                                          contents);
12712
12713       if (info->relocatable)
12714         continue;
12715
12716       if (h != NULL && &h->elf == htab->elf.hgot)
12717         {
12718           relocation = (TOCstart
12719                         + htab->stub_group[input_section->id].toc_off);
12720           sec = bfd_abs_section_ptr;
12721           unresolved_reloc = FALSE;
12722         }
12723
12724       /* TLS optimizations.  Replace instruction sequences and relocs
12725          based on information we collected in tls_optimize.  We edit
12726          RELOCS so that --emit-relocs will output something sensible
12727          for the final instruction stream.  */
12728       tls_mask = 0;
12729       tls_gd = 0;
12730       toc_symndx = 0;
12731       if (h != NULL)
12732         tls_mask = h->tls_mask;
12733       else if (local_got_ents != NULL)
12734         {
12735           struct plt_entry **local_plt = (struct plt_entry **)
12736             (local_got_ents + symtab_hdr->sh_info);
12737           unsigned char *lgot_masks = (unsigned char *)
12738             (local_plt + symtab_hdr->sh_info);
12739           tls_mask = lgot_masks[r_symndx];
12740         }
12741       if (tls_mask == 0
12742           && (r_type == R_PPC64_TLS
12743               || r_type == R_PPC64_TLSGD
12744               || r_type == R_PPC64_TLSLD))
12745         {
12746           /* Check for toc tls entries.  */
12747           unsigned char *toc_tls;
12748
12749           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12750                              &local_syms, rel, input_bfd))
12751             return FALSE;
12752
12753           if (toc_tls)
12754             tls_mask = *toc_tls;
12755         }
12756
12757       /* Check that tls relocs are used with tls syms, and non-tls
12758          relocs are used with non-tls syms.  */
12759       if (r_symndx != STN_UNDEF
12760           && r_type != R_PPC64_NONE
12761           && (h == NULL
12762               || h->elf.root.type == bfd_link_hash_defined
12763               || h->elf.root.type == bfd_link_hash_defweak)
12764           && (IS_PPC64_TLS_RELOC (r_type)
12765               != (sym_type == STT_TLS
12766                   || (sym_type == STT_SECTION
12767                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12768         {
12769           if (tls_mask != 0
12770               && (r_type == R_PPC64_TLS
12771                   || r_type == R_PPC64_TLSGD
12772                   || r_type == R_PPC64_TLSLD))
12773             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
12774             ;
12775           else
12776             info->callbacks->einfo
12777               (!IS_PPC64_TLS_RELOC (r_type)
12778                ? _("%P: %H: %s used with TLS symbol `%T'\n")
12779                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
12780                input_bfd, input_section, rel->r_offset,
12781                ppc64_elf_howto_table[r_type]->name,
12782                sym_name);
12783         }
12784
12785       /* Ensure reloc mapping code below stays sane.  */
12786       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12787           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12788           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
12789           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12790           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12791           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12792           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
12793           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12794           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12795           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12796         abort ();
12797
12798       switch (r_type)
12799         {
12800         default:
12801           break;
12802
12803         case R_PPC64_LO_DS_OPT:
12804           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12805           if ((insn & (0x3f << 26)) != 58u << 26)
12806             abort ();
12807           insn += (14u << 26) - (58u << 26);
12808           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12809           r_type = R_PPC64_TOC16_LO;
12810           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12811           break;
12812
12813         case R_PPC64_TOC16:
12814         case R_PPC64_TOC16_LO:
12815         case R_PPC64_TOC16_DS:
12816         case R_PPC64_TOC16_LO_DS:
12817           {
12818             /* Check for toc tls entries.  */
12819             unsigned char *toc_tls;
12820             int retval;
12821
12822             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12823                                    &local_syms, rel, input_bfd);
12824             if (retval == 0)
12825               return FALSE;
12826
12827             if (toc_tls)
12828               {
12829                 tls_mask = *toc_tls;
12830                 if (r_type == R_PPC64_TOC16_DS
12831                     || r_type == R_PPC64_TOC16_LO_DS)
12832                   {
12833                     if (tls_mask != 0
12834                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12835                       goto toctprel;
12836                   }
12837                 else
12838                   {
12839                     /* If we found a GD reloc pair, then we might be
12840                        doing a GD->IE transition.  */
12841                     if (retval == 2)
12842                       {
12843                         tls_gd = TLS_TPRELGD;
12844                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12845                           goto tls_ldgd_opt;
12846                       }
12847                     else if (retval == 3)
12848                       {
12849                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12850                           goto tls_ldgd_opt;
12851                       }
12852                   }
12853               }
12854           }
12855           break;
12856
12857         case R_PPC64_GOT_TPREL16_HI:
12858         case R_PPC64_GOT_TPREL16_HA:
12859           if (tls_mask != 0
12860               && (tls_mask & TLS_TPREL) == 0)
12861             {
12862               rel->r_offset -= d_offset;
12863               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12864               r_type = R_PPC64_NONE;
12865               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12866             }
12867           break;
12868
12869         case R_PPC64_GOT_TPREL16_DS:
12870         case R_PPC64_GOT_TPREL16_LO_DS:
12871           if (tls_mask != 0
12872               && (tls_mask & TLS_TPREL) == 0)
12873             {
12874             toctprel:
12875               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12876               insn &= 31 << 21;
12877               insn |= 0x3c0d0000;       /* addis 0,13,0 */
12878               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12879               r_type = R_PPC64_TPREL16_HA;
12880               if (toc_symndx != 0)
12881                 {
12882                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12883                   rel->r_addend = toc_addend;
12884                   /* We changed the symbol.  Start over in order to
12885                      get h, sym, sec etc. right.  */
12886                   rel--;
12887                   continue;
12888                 }
12889               else
12890                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12891             }
12892           break;
12893
12894         case R_PPC64_TLS:
12895           if (tls_mask != 0
12896               && (tls_mask & TLS_TPREL) == 0)
12897             {
12898               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12899               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12900               if (insn == 0)
12901                 abort ();
12902               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12903               /* Was PPC64_TLS which sits on insn boundary, now
12904                  PPC64_TPREL16_LO which is at low-order half-word.  */
12905               rel->r_offset += d_offset;
12906               r_type = R_PPC64_TPREL16_LO;
12907               if (toc_symndx != 0)
12908                 {
12909                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12910                   rel->r_addend = toc_addend;
12911                   /* We changed the symbol.  Start over in order to
12912                      get h, sym, sec etc. right.  */
12913                   rel--;
12914                   continue;
12915                 }
12916               else
12917                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12918             }
12919           break;
12920
12921         case R_PPC64_GOT_TLSGD16_HI:
12922         case R_PPC64_GOT_TLSGD16_HA:
12923           tls_gd = TLS_TPRELGD;
12924           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12925             goto tls_gdld_hi;
12926           break;
12927
12928         case R_PPC64_GOT_TLSLD16_HI:
12929         case R_PPC64_GOT_TLSLD16_HA:
12930           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12931             {
12932             tls_gdld_hi:
12933               if ((tls_mask & tls_gd) != 0)
12934                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12935                           + R_PPC64_GOT_TPREL16_DS);
12936               else
12937                 {
12938                   rel->r_offset -= d_offset;
12939                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12940                   r_type = R_PPC64_NONE;
12941                 }
12942               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12943             }
12944           break;
12945
12946         case R_PPC64_GOT_TLSGD16:
12947         case R_PPC64_GOT_TLSGD16_LO:
12948           tls_gd = TLS_TPRELGD;
12949           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12950             goto tls_ldgd_opt;
12951           break;
12952
12953         case R_PPC64_GOT_TLSLD16:
12954         case R_PPC64_GOT_TLSLD16_LO:
12955           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12956             {
12957               unsigned int insn1, insn2, insn3;
12958               bfd_vma offset;
12959
12960             tls_ldgd_opt:
12961               offset = (bfd_vma) -1;
12962               /* If not using the newer R_PPC64_TLSGD/LD to mark
12963                  __tls_get_addr calls, we must trust that the call
12964                  stays with its arg setup insns, ie. that the next
12965                  reloc is the __tls_get_addr call associated with
12966                  the current reloc.  Edit both insns.  */
12967               if (input_section->has_tls_get_addr_call
12968                   && rel + 1 < relend
12969                   && branch_reloc_hash_match (input_bfd, rel + 1,
12970                                               htab->tls_get_addr,
12971                                               htab->tls_get_addr_fd))
12972                 offset = rel[1].r_offset;
12973               if ((tls_mask & tls_gd) != 0)
12974                 {
12975                   /* IE */
12976                   insn1 = bfd_get_32 (output_bfd,
12977                                       contents + rel->r_offset - d_offset);
12978                   insn1 &= (1 << 26) - (1 << 2);
12979                   insn1 |= 58 << 26;    /* ld */
12980                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12981                   if (offset != (bfd_vma) -1)
12982                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12983                   if ((tls_mask & TLS_EXPLICIT) == 0)
12984                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12985                               + R_PPC64_GOT_TPREL16_DS);
12986                   else
12987                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12988                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12989                 }
12990               else
12991                 {
12992                   /* LE */
12993                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
12994                   insn2 = 0x38630000;   /* addi 3,3,0 */
12995                   if (tls_gd == 0)
12996                     {
12997                       /* Was an LD reloc.  */
12998                       if (toc_symndx)
12999                         sec = local_sections[toc_symndx];
13000                       for (r_symndx = 0;
13001                            r_symndx < symtab_hdr->sh_info;
13002                            r_symndx++)
13003                         if (local_sections[r_symndx] == sec)
13004                           break;
13005                       if (r_symndx >= symtab_hdr->sh_info)
13006                         r_symndx = STN_UNDEF;
13007                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13008                       if (r_symndx != STN_UNDEF)
13009                         rel->r_addend -= (local_syms[r_symndx].st_value
13010                                           + sec->output_offset
13011                                           + sec->output_section->vma);
13012                     }
13013                   else if (toc_symndx != 0)
13014                     {
13015                       r_symndx = toc_symndx;
13016                       rel->r_addend = toc_addend;
13017                     }
13018                   r_type = R_PPC64_TPREL16_HA;
13019                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13020                   if (offset != (bfd_vma) -1)
13021                     {
13022                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13023                                                     R_PPC64_TPREL16_LO);
13024                       rel[1].r_offset = offset + d_offset;
13025                       rel[1].r_addend = rel->r_addend;
13026                     }
13027                 }
13028               bfd_put_32 (output_bfd, insn1,
13029                           contents + rel->r_offset - d_offset);
13030               if (offset != (bfd_vma) -1)
13031                 {
13032                   insn3 = bfd_get_32 (output_bfd,
13033                                       contents + offset + 4);
13034                   if (insn3 == NOP
13035                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13036                     {
13037                       rel[1].r_offset += 4;
13038                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13039                       insn2 = NOP;
13040                     }
13041                   bfd_put_32 (output_bfd, insn2, contents + offset);
13042                 }
13043               if ((tls_mask & tls_gd) == 0
13044                   && (tls_gd == 0 || toc_symndx != 0))
13045                 {
13046                   /* We changed the symbol.  Start over in order
13047                      to get h, sym, sec etc. right.  */
13048                   rel--;
13049                   continue;
13050                 }
13051             }
13052           break;
13053
13054         case R_PPC64_TLSGD:
13055           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13056             {
13057               unsigned int insn2, insn3;
13058               bfd_vma offset = rel->r_offset;
13059
13060               if ((tls_mask & TLS_TPRELGD) != 0)
13061                 {
13062                   /* IE */
13063                   r_type = R_PPC64_NONE;
13064                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13065                 }
13066               else
13067                 {
13068                   /* LE */
13069                   if (toc_symndx != 0)
13070                     {
13071                       r_symndx = toc_symndx;
13072                       rel->r_addend = toc_addend;
13073                     }
13074                   r_type = R_PPC64_TPREL16_LO;
13075                   rel->r_offset = offset + d_offset;
13076                   insn2 = 0x38630000;   /* addi 3,3,0 */
13077                 }
13078               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13079               /* Zap the reloc on the _tls_get_addr call too.  */
13080               BFD_ASSERT (offset == rel[1].r_offset);
13081               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13082               insn3 = bfd_get_32 (output_bfd,
13083                                   contents + offset + 4);
13084               if (insn3 == NOP
13085                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13086                 {
13087                   rel->r_offset += 4;
13088                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13089                   insn2 = NOP;
13090                 }
13091               bfd_put_32 (output_bfd, insn2, contents + offset);
13092               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13093                 {
13094                   rel--;
13095                   continue;
13096                 }
13097             }
13098           break;
13099
13100         case R_PPC64_TLSLD:
13101           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13102             {
13103               unsigned int insn2, insn3;
13104               bfd_vma offset = rel->r_offset;
13105
13106               if (toc_symndx)
13107                 sec = local_sections[toc_symndx];
13108               for (r_symndx = 0;
13109                    r_symndx < symtab_hdr->sh_info;
13110                    r_symndx++)
13111                 if (local_sections[r_symndx] == sec)
13112                   break;
13113               if (r_symndx >= symtab_hdr->sh_info)
13114                 r_symndx = STN_UNDEF;
13115               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13116               if (r_symndx != STN_UNDEF)
13117                 rel->r_addend -= (local_syms[r_symndx].st_value
13118                                   + sec->output_offset
13119                                   + sec->output_section->vma);
13120
13121               r_type = R_PPC64_TPREL16_LO;
13122               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13123               rel->r_offset = offset + d_offset;
13124               /* Zap the reloc on the _tls_get_addr call too.  */
13125               BFD_ASSERT (offset == rel[1].r_offset);
13126               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13127               insn2 = 0x38630000;       /* addi 3,3,0 */
13128               insn3 = bfd_get_32 (output_bfd,
13129                                   contents + offset + 4);
13130               if (insn3 == NOP
13131                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13132                 {
13133                   rel->r_offset += 4;
13134                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13135                   insn2 = NOP;
13136                 }
13137               bfd_put_32 (output_bfd, insn2, contents + offset);
13138               rel--;
13139               continue;
13140             }
13141           break;
13142
13143         case R_PPC64_DTPMOD64:
13144           if (rel + 1 < relend
13145               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13146               && rel[1].r_offset == rel->r_offset + 8)
13147             {
13148               if ((tls_mask & TLS_GD) == 0)
13149                 {
13150                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13151                   if ((tls_mask & TLS_TPRELGD) != 0)
13152                     r_type = R_PPC64_TPREL64;
13153                   else
13154                     {
13155                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13156                       r_type = R_PPC64_NONE;
13157                     }
13158                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13159                 }
13160             }
13161           else
13162             {
13163               if ((tls_mask & TLS_LD) == 0)
13164                 {
13165                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13166                   r_type = R_PPC64_NONE;
13167                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13168                 }
13169             }
13170           break;
13171
13172         case R_PPC64_TPREL64:
13173           if ((tls_mask & TLS_TPREL) == 0)
13174             {
13175               r_type = R_PPC64_NONE;
13176               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13177             }
13178           break;
13179         }
13180
13181       /* Handle other relocations that tweak non-addend part of insn.  */
13182       insn = 0;
13183       max_br_offset = 1 << 25;
13184       addend = rel->r_addend;
13185       reloc_dest = DEST_NORMAL;
13186       switch (r_type)
13187         {
13188         default:
13189           break;
13190
13191         case R_PPC64_TOCSAVE:
13192           if (relocation + addend == (rel->r_offset
13193                                       + input_section->output_offset
13194                                       + input_section->output_section->vma)
13195               && tocsave_find (htab, NO_INSERT,
13196                                &local_syms, rel, input_bfd))
13197             {
13198               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13199               if (insn == NOP
13200                   || insn == CROR_151515 || insn == CROR_313131)
13201                 bfd_put_32 (input_bfd, STD_R2_40R1,
13202                             contents + rel->r_offset);
13203             }
13204           break;
13205
13206           /* Branch taken prediction relocations.  */
13207         case R_PPC64_ADDR14_BRTAKEN:
13208         case R_PPC64_REL14_BRTAKEN:
13209           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13210           /* Fall thru.  */
13211
13212           /* Branch not taken prediction relocations.  */
13213         case R_PPC64_ADDR14_BRNTAKEN:
13214         case R_PPC64_REL14_BRNTAKEN:
13215           insn |= bfd_get_32 (output_bfd,
13216                               contents + rel->r_offset) & ~(0x01 << 21);
13217           /* Fall thru.  */
13218
13219         case R_PPC64_REL14:
13220           max_br_offset = 1 << 15;
13221           /* Fall thru.  */
13222
13223         case R_PPC64_REL24:
13224           /* Calls to functions with a different TOC, such as calls to
13225              shared objects, need to alter the TOC pointer.  This is
13226              done using a linkage stub.  A REL24 branching to these
13227              linkage stubs needs to be followed by a nop, as the nop
13228              will be replaced with an instruction to restore the TOC
13229              base pointer.  */
13230           fdh = h;
13231           if (h != NULL
13232               && h->oh != NULL
13233               && h->oh->is_func_descriptor)
13234             fdh = ppc_follow_link (h->oh);
13235           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13236                                            htab);
13237           if (stub_entry != NULL
13238               && (stub_entry->stub_type == ppc_stub_plt_call
13239                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13240                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13241                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13242             {
13243               bfd_boolean can_plt_call = FALSE;
13244
13245               /* All of these stubs will modify r2, so there must be a
13246                  branch and link followed by a nop.  The nop is
13247                  replaced by an insn to restore r2.  */
13248               if (rel->r_offset + 8 <= input_section->size)
13249                 {
13250                   unsigned long br;
13251
13252                   br = bfd_get_32 (input_bfd,
13253                                    contents + rel->r_offset);
13254                   if ((br & 1) != 0)
13255                     {
13256                       unsigned long nop;
13257
13258                       nop = bfd_get_32 (input_bfd,
13259                                         contents + rel->r_offset + 4);
13260                       if (nop == NOP
13261                           || nop == CROR_151515 || nop == CROR_313131)
13262                         {
13263                           if (h != NULL
13264                               && (h == htab->tls_get_addr_fd
13265                                   || h == htab->tls_get_addr)
13266                               && !htab->no_tls_get_addr_opt)
13267                             {
13268                               /* Special stub used, leave nop alone.  */
13269                             }
13270                           else
13271                             bfd_put_32 (input_bfd, LD_R2_40R1,
13272                                         contents + rel->r_offset + 4);
13273                           can_plt_call = TRUE;
13274                         }
13275                     }
13276                 }
13277
13278               if (!can_plt_call && h != NULL)
13279                 {
13280                   const char *name = h->elf.root.root.string;
13281
13282                   if (*name == '.')
13283                     ++name;
13284
13285                   if (strncmp (name, "__libc_start_main", 17) == 0
13286                       && (name[17] == 0 || name[17] == '@'))
13287                     {
13288                       /* Allow crt1 branch to go via a toc adjusting
13289                          stub.  Other calls that never return could do
13290                          the same, if we could detect such.  */
13291                       can_plt_call = TRUE;
13292                     }
13293                 }
13294
13295               if (!can_plt_call)
13296                 {
13297                   /* g++ as of 20130507 emits self-calls without a
13298                      following nop.  This is arguably wrong since we
13299                      have conflicting information.  On the one hand a
13300                      global symbol and on the other a local call
13301                      sequence, but don't error for this special case.
13302                      It isn't possible to cheaply verify we have
13303                      exactly such a call.  Allow all calls to the same
13304                      section.  */
13305                   asection *code_sec = sec;
13306
13307                   if (get_opd_info (sec) != NULL)
13308                     {
13309                       bfd_vma off = (relocation + addend
13310                                      - sec->output_section->vma
13311                                      - sec->output_offset);
13312
13313                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13314                     }
13315                   if (code_sec == input_section)
13316                     can_plt_call = TRUE;
13317                 }
13318
13319               if (!can_plt_call)
13320                 {
13321                   info->callbacks->einfo
13322                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13323                        "recompile with -fPIC"),
13324                      input_bfd, input_section, rel->r_offset, sym_name);
13325
13326                   bfd_set_error (bfd_error_bad_value);
13327                   ret = FALSE;
13328                 }
13329
13330               if (can_plt_call
13331                   && (stub_entry->stub_type == ppc_stub_plt_call
13332                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13333                 unresolved_reloc = FALSE;
13334             }
13335
13336           if ((stub_entry == NULL
13337                || stub_entry->stub_type == ppc_stub_long_branch
13338                || stub_entry->stub_type == ppc_stub_plt_branch)
13339               && get_opd_info (sec) != NULL)
13340             {
13341               /* The branch destination is the value of the opd entry. */
13342               bfd_vma off = (relocation + addend
13343                              - sec->output_section->vma
13344                              - sec->output_offset);
13345               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13346               if (dest != (bfd_vma) -1)
13347                 {
13348                   relocation = dest;
13349                   addend = 0;
13350                   reloc_dest = DEST_OPD;
13351                 }
13352             }
13353
13354           /* If the branch is out of reach we ought to have a long
13355              branch stub.  */
13356           from = (rel->r_offset
13357                   + input_section->output_offset
13358                   + input_section->output_section->vma);
13359
13360           if (stub_entry != NULL
13361               && (stub_entry->stub_type == ppc_stub_long_branch
13362                   || stub_entry->stub_type == ppc_stub_plt_branch)
13363               && (r_type == R_PPC64_ADDR14_BRTAKEN
13364                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13365                   || (relocation + addend - from + max_br_offset
13366                       < 2 * max_br_offset)))
13367             /* Don't use the stub if this branch is in range.  */
13368             stub_entry = NULL;
13369
13370           if (stub_entry != NULL)
13371             {
13372               /* Munge up the value and addend so that we call the stub
13373                  rather than the procedure directly.  */
13374               relocation = (stub_entry->stub_offset
13375                             + stub_entry->stub_sec->output_offset
13376                             + stub_entry->stub_sec->output_section->vma);
13377               addend = 0;
13378               reloc_dest = DEST_STUB;
13379
13380               if ((stub_entry->stub_type == ppc_stub_plt_call
13381                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13382                   && (ALWAYS_EMIT_R2SAVE
13383                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13384                   && rel + 1 < relend
13385                   && rel[1].r_offset == rel->r_offset + 4
13386                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13387                 relocation += 4;
13388             }
13389
13390           if (insn != 0)
13391             {
13392               if (is_isa_v2)
13393                 {
13394                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13395                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13396                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13397                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13398                     insn |= 0x02 << 21;
13399                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13400                     insn |= 0x08 << 21;
13401                   else
13402                     break;
13403                 }
13404               else
13405                 {
13406                   /* Invert 'y' bit if not the default.  */
13407                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13408                     insn ^= 0x01 << 21;
13409                 }
13410
13411               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13412             }
13413
13414           /* NOP out calls to undefined weak functions.
13415              We can thus call a weak function without first
13416              checking whether the function is defined.  */
13417           else if (h != NULL
13418                    && h->elf.root.type == bfd_link_hash_undefweak
13419                    && h->elf.dynindx == -1
13420                    && r_type == R_PPC64_REL24
13421                    && relocation == 0
13422                    && addend == 0)
13423             {
13424               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13425               continue;
13426             }
13427           break;
13428         }
13429
13430       /* Set `addend'.  */
13431       tls_type = 0;
13432       switch (r_type)
13433         {
13434         default:
13435           info->callbacks->einfo
13436             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13437              input_bfd, (int) r_type, sym_name);
13438
13439           bfd_set_error (bfd_error_bad_value);
13440           ret = FALSE;
13441           continue;
13442
13443         case R_PPC64_NONE:
13444         case R_PPC64_TLS:
13445         case R_PPC64_TLSGD:
13446         case R_PPC64_TLSLD:
13447         case R_PPC64_TOCSAVE:
13448         case R_PPC64_GNU_VTINHERIT:
13449         case R_PPC64_GNU_VTENTRY:
13450           continue;
13451
13452           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13453              address in the GOT as relocation value instead of the
13454              symbol's value itself.  Also, create a GOT entry for the
13455              symbol and put the symbol value there.  */
13456         case R_PPC64_GOT_TLSGD16:
13457         case R_PPC64_GOT_TLSGD16_LO:
13458         case R_PPC64_GOT_TLSGD16_HI:
13459         case R_PPC64_GOT_TLSGD16_HA:
13460           tls_type = TLS_TLS | TLS_GD;
13461           goto dogot;
13462
13463         case R_PPC64_GOT_TLSLD16:
13464         case R_PPC64_GOT_TLSLD16_LO:
13465         case R_PPC64_GOT_TLSLD16_HI:
13466         case R_PPC64_GOT_TLSLD16_HA:
13467           tls_type = TLS_TLS | TLS_LD;
13468           goto dogot;
13469
13470         case R_PPC64_GOT_TPREL16_DS:
13471         case R_PPC64_GOT_TPREL16_LO_DS:
13472         case R_PPC64_GOT_TPREL16_HI:
13473         case R_PPC64_GOT_TPREL16_HA:
13474           tls_type = TLS_TLS | TLS_TPREL;
13475           goto dogot;
13476
13477         case R_PPC64_GOT_DTPREL16_DS:
13478         case R_PPC64_GOT_DTPREL16_LO_DS:
13479         case R_PPC64_GOT_DTPREL16_HI:
13480         case R_PPC64_GOT_DTPREL16_HA:
13481           tls_type = TLS_TLS | TLS_DTPREL;
13482           goto dogot;
13483
13484         case R_PPC64_GOT16:
13485         case R_PPC64_GOT16_LO:
13486         case R_PPC64_GOT16_HI:
13487         case R_PPC64_GOT16_HA:
13488         case R_PPC64_GOT16_DS:
13489         case R_PPC64_GOT16_LO_DS:
13490         dogot:
13491           {
13492             /* Relocation is to the entry for this symbol in the global
13493                offset table.  */
13494             asection *got;
13495             bfd_vma *offp;
13496             bfd_vma off;
13497             unsigned long indx = 0;
13498             struct got_entry *ent;
13499
13500             if (tls_type == (TLS_TLS | TLS_LD)
13501                 && (h == NULL
13502                     || !h->elf.def_dynamic))
13503               ent = ppc64_tlsld_got (input_bfd);
13504             else
13505               {
13506
13507                 if (h != NULL)
13508                   {
13509                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13510                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13511                                                           &h->elf)
13512                         || (info->shared
13513                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
13514                       /* This is actually a static link, or it is a
13515                          -Bsymbolic link and the symbol is defined
13516                          locally, or the symbol was forced to be local
13517                          because of a version file.  */
13518                       ;
13519                     else
13520                       {
13521                         BFD_ASSERT (h->elf.dynindx != -1);
13522                         indx = h->elf.dynindx;
13523                         unresolved_reloc = FALSE;
13524                       }
13525                     ent = h->elf.got.glist;
13526                   }
13527                 else
13528                   {
13529                     if (local_got_ents == NULL)
13530                       abort ();
13531                     ent = local_got_ents[r_symndx];
13532                   }
13533
13534                 for (; ent != NULL; ent = ent->next)
13535                   if (ent->addend == orig_rel.r_addend
13536                       && ent->owner == input_bfd
13537                       && ent->tls_type == tls_type)
13538                     break;
13539               }
13540
13541             if (ent == NULL)
13542               abort ();
13543             if (ent->is_indirect)
13544               ent = ent->got.ent;
13545             offp = &ent->got.offset;
13546             got = ppc64_elf_tdata (ent->owner)->got;
13547             if (got == NULL)
13548               abort ();
13549
13550             /* The offset must always be a multiple of 8.  We use the
13551                least significant bit to record whether we have already
13552                processed this entry.  */
13553             off = *offp;
13554             if ((off & 1) != 0)
13555               off &= ~1;
13556             else
13557               {
13558                 /* Generate relocs for the dynamic linker, except in
13559                    the case of TLSLD where we'll use one entry per
13560                    module.  */
13561                 asection *relgot;
13562                 bfd_boolean ifunc;
13563
13564                 *offp = off | 1;
13565                 relgot = NULL;
13566                 ifunc = (h != NULL
13567                          ? h->elf.type == STT_GNU_IFUNC
13568                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13569                 if (ifunc)
13570                   relgot = htab->reliplt;
13571                 else if ((info->shared || indx != 0)
13572                          && (h == NULL
13573                              || (tls_type == (TLS_TLS | TLS_LD)
13574                                  && !h->elf.def_dynamic)
13575                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13576                              || h->elf.root.type != bfd_link_hash_undefweak))
13577                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13578                 if (relgot != NULL)
13579                   {
13580                     outrel.r_offset = (got->output_section->vma
13581                                        + got->output_offset
13582                                        + off);
13583                     outrel.r_addend = addend;
13584                     if (tls_type & (TLS_LD | TLS_GD))
13585                       {
13586                         outrel.r_addend = 0;
13587                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13588                         if (tls_type == (TLS_TLS | TLS_GD))
13589                           {
13590                             loc = relgot->contents;
13591                             loc += (relgot->reloc_count++
13592                                     * sizeof (Elf64_External_Rela));
13593                             bfd_elf64_swap_reloca_out (output_bfd,
13594                                                        &outrel, loc);
13595                             outrel.r_offset += 8;
13596                             outrel.r_addend = addend;
13597                             outrel.r_info
13598                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13599                           }
13600                       }
13601                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13602                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13603                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13604                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13605                     else if (indx != 0)
13606                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13607                     else
13608                       {
13609                         if (ifunc)
13610                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13611                         else
13612                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13613
13614                         /* Write the .got section contents for the sake
13615                            of prelink.  */
13616                         loc = got->contents + off;
13617                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13618                                     loc);
13619                       }
13620
13621                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13622                       {
13623                         outrel.r_addend += relocation;
13624                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13625                           outrel.r_addend -= htab->elf.tls_sec->vma;
13626                       }
13627                     loc = relgot->contents;
13628                     loc += (relgot->reloc_count++
13629                             * sizeof (Elf64_External_Rela));
13630                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13631                   }
13632
13633                 /* Init the .got section contents here if we're not
13634                    emitting a reloc.  */
13635                 else
13636                   {
13637                     relocation += addend;
13638                     if (tls_type == (TLS_TLS | TLS_LD))
13639                       relocation = 1;
13640                     else if (tls_type != 0)
13641                       {
13642                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13643                         if (tls_type == (TLS_TLS | TLS_TPREL))
13644                           relocation += DTP_OFFSET - TP_OFFSET;
13645
13646                         if (tls_type == (TLS_TLS | TLS_GD))
13647                           {
13648                             bfd_put_64 (output_bfd, relocation,
13649                                         got->contents + off + 8);
13650                             relocation = 1;
13651                           }
13652                       }
13653
13654                     bfd_put_64 (output_bfd, relocation,
13655                                 got->contents + off);
13656                   }
13657               }
13658
13659             if (off >= (bfd_vma) -2)
13660               abort ();
13661
13662             relocation = got->output_section->vma + got->output_offset + off;
13663             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
13664           }
13665           break;
13666
13667         case R_PPC64_PLT16_HA:
13668         case R_PPC64_PLT16_HI:
13669         case R_PPC64_PLT16_LO:
13670         case R_PPC64_PLT32:
13671         case R_PPC64_PLT64:
13672           /* Relocation is to the entry for this symbol in the
13673              procedure linkage table.  */
13674
13675           /* Resolve a PLT reloc against a local symbol directly,
13676              without using the procedure linkage table.  */
13677           if (h == NULL)
13678             break;
13679
13680           /* It's possible that we didn't make a PLT entry for this
13681              symbol.  This happens when statically linking PIC code,
13682              or when using -Bsymbolic.  Go find a match if there is a
13683              PLT entry.  */
13684           if (htab->plt != NULL)
13685             {
13686               struct plt_entry *ent;
13687               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
13688                 if (ent->addend == orig_rel.r_addend
13689                     && ent->plt.offset != (bfd_vma) -1)
13690                   {
13691                     relocation = (htab->plt->output_section->vma
13692                                   + htab->plt->output_offset
13693                                   + ent->plt.offset);
13694                     unresolved_reloc = FALSE;
13695                   }
13696             }
13697           break;
13698
13699         case R_PPC64_TOC:
13700           /* Relocation value is TOC base.  */
13701           relocation = TOCstart;
13702           if (r_symndx == STN_UNDEF)
13703             relocation += htab->stub_group[input_section->id].toc_off;
13704           else if (unresolved_reloc)
13705             ;
13706           else if (sec != NULL && sec->id <= htab->top_id)
13707             relocation += htab->stub_group[sec->id].toc_off;
13708           else
13709             unresolved_reloc = TRUE;
13710           goto dodyn;
13711
13712           /* TOC16 relocs.  We want the offset relative to the TOC base,
13713              which is the address of the start of the TOC plus 0x8000.
13714              The TOC consists of sections .got, .toc, .tocbss, and .plt,
13715              in this order.  */
13716         case R_PPC64_TOC16:
13717         case R_PPC64_TOC16_LO:
13718         case R_PPC64_TOC16_HI:
13719         case R_PPC64_TOC16_DS:
13720         case R_PPC64_TOC16_LO_DS:
13721         case R_PPC64_TOC16_HA:
13722           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13723           break;
13724
13725           /* Relocate against the beginning of the section.  */
13726         case R_PPC64_SECTOFF:
13727         case R_PPC64_SECTOFF_LO:
13728         case R_PPC64_SECTOFF_HI:
13729         case R_PPC64_SECTOFF_DS:
13730         case R_PPC64_SECTOFF_LO_DS:
13731         case R_PPC64_SECTOFF_HA:
13732           if (sec != NULL)
13733             addend -= sec->output_section->vma;
13734           break;
13735
13736         case R_PPC64_REL16:
13737         case R_PPC64_REL16_LO:
13738         case R_PPC64_REL16_HI:
13739         case R_PPC64_REL16_HA:
13740           break;
13741
13742         case R_PPC64_REL14:
13743         case R_PPC64_REL14_BRNTAKEN:
13744         case R_PPC64_REL14_BRTAKEN:
13745         case R_PPC64_REL24:
13746           break;
13747
13748         case R_PPC64_TPREL16:
13749         case R_PPC64_TPREL16_LO:
13750         case R_PPC64_TPREL16_HI:
13751         case R_PPC64_TPREL16_HA:
13752         case R_PPC64_TPREL16_DS:
13753         case R_PPC64_TPREL16_LO_DS:
13754         case R_PPC64_TPREL16_HIGH:
13755         case R_PPC64_TPREL16_HIGHA:
13756         case R_PPC64_TPREL16_HIGHER:
13757         case R_PPC64_TPREL16_HIGHERA:
13758         case R_PPC64_TPREL16_HIGHEST:
13759         case R_PPC64_TPREL16_HIGHESTA:
13760           if (h != NULL
13761               && h->elf.root.type == bfd_link_hash_undefweak
13762               && h->elf.dynindx == -1)
13763             {
13764               /* Make this relocation against an undefined weak symbol
13765                  resolve to zero.  This is really just a tweak, since
13766                  code using weak externs ought to check that they are
13767                  defined before using them.  */
13768               bfd_byte *p = contents + rel->r_offset - d_offset;
13769
13770               insn = bfd_get_32 (output_bfd, p);
13771               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13772               if (insn != 0)
13773                 bfd_put_32 (output_bfd, insn, p);
13774               break;
13775             }
13776           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13777           if (info->shared)
13778             /* The TPREL16 relocs shouldn't really be used in shared
13779                libs as they will result in DT_TEXTREL being set, but
13780                support them anyway.  */
13781             goto dodyn;
13782           break;
13783
13784         case R_PPC64_DTPREL16:
13785         case R_PPC64_DTPREL16_LO:
13786         case R_PPC64_DTPREL16_HI:
13787         case R_PPC64_DTPREL16_HA:
13788         case R_PPC64_DTPREL16_DS:
13789         case R_PPC64_DTPREL16_LO_DS:
13790         case R_PPC64_DTPREL16_HIGH:
13791         case R_PPC64_DTPREL16_HIGHA:
13792         case R_PPC64_DTPREL16_HIGHER:
13793         case R_PPC64_DTPREL16_HIGHERA:
13794         case R_PPC64_DTPREL16_HIGHEST:
13795         case R_PPC64_DTPREL16_HIGHESTA:
13796           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13797           break;
13798
13799         case R_PPC64_DTPMOD64:
13800           relocation = 1;
13801           addend = 0;
13802           goto dodyn;
13803
13804         case R_PPC64_TPREL64:
13805           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13806           goto dodyn;
13807
13808         case R_PPC64_DTPREL64:
13809           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13810           /* Fall thru */
13811
13812           /* Relocations that may need to be propagated if this is a
13813              dynamic object.  */
13814         case R_PPC64_REL30:
13815         case R_PPC64_REL32:
13816         case R_PPC64_REL64:
13817         case R_PPC64_ADDR14:
13818         case R_PPC64_ADDR14_BRNTAKEN:
13819         case R_PPC64_ADDR14_BRTAKEN:
13820         case R_PPC64_ADDR16:
13821         case R_PPC64_ADDR16_DS:
13822         case R_PPC64_ADDR16_HA:
13823         case R_PPC64_ADDR16_HI:
13824         case R_PPC64_ADDR16_HIGH:
13825         case R_PPC64_ADDR16_HIGHA:
13826         case R_PPC64_ADDR16_HIGHER:
13827         case R_PPC64_ADDR16_HIGHERA:
13828         case R_PPC64_ADDR16_HIGHEST:
13829         case R_PPC64_ADDR16_HIGHESTA:
13830         case R_PPC64_ADDR16_LO:
13831         case R_PPC64_ADDR16_LO_DS:
13832         case R_PPC64_ADDR24:
13833         case R_PPC64_ADDR32:
13834         case R_PPC64_ADDR64:
13835         case R_PPC64_UADDR16:
13836         case R_PPC64_UADDR32:
13837         case R_PPC64_UADDR64:
13838         dodyn:
13839           if ((input_section->flags & SEC_ALLOC) == 0)
13840             break;
13841
13842           if (NO_OPD_RELOCS && is_opd)
13843             break;
13844
13845           if ((info->shared
13846                && (h == NULL
13847                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13848                    || h->elf.root.type != bfd_link_hash_undefweak)
13849                && (must_be_dyn_reloc (info, r_type)
13850                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13851               || (ELIMINATE_COPY_RELOCS
13852                   && !info->shared
13853                   && h != NULL
13854                   && h->elf.dynindx != -1
13855                   && !h->elf.non_got_ref
13856                   && !h->elf.def_regular)
13857               || (!info->shared
13858                   && (h != NULL
13859                       ? h->elf.type == STT_GNU_IFUNC
13860                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13861             {
13862               bfd_boolean skip, relocate;
13863               asection *sreloc;
13864               bfd_vma out_off;
13865
13866               /* When generating a dynamic object, these relocations
13867                  are copied into the output file to be resolved at run
13868                  time.  */
13869
13870               skip = FALSE;
13871               relocate = FALSE;
13872
13873               out_off = _bfd_elf_section_offset (output_bfd, info,
13874                                                  input_section, rel->r_offset);
13875               if (out_off == (bfd_vma) -1)
13876                 skip = TRUE;
13877               else if (out_off == (bfd_vma) -2)
13878                 skip = TRUE, relocate = TRUE;
13879               out_off += (input_section->output_section->vma
13880                           + input_section->output_offset);
13881               outrel.r_offset = out_off;
13882               outrel.r_addend = rel->r_addend;
13883
13884               /* Optimize unaligned reloc use.  */
13885               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13886                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13887                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13888               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13889                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13890                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13891               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13892                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13893                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13894
13895               if (skip)
13896                 memset (&outrel, 0, sizeof outrel);
13897               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13898                        && !is_opd
13899                        && r_type != R_PPC64_TOC)
13900                 {
13901                   BFD_ASSERT (h->elf.dynindx != -1);
13902                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13903                 }
13904               else
13905                 {
13906                   /* This symbol is local, or marked to become local,
13907                      or this is an opd section reloc which must point
13908                      at a local function.  */
13909                   outrel.r_addend += relocation;
13910                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13911                     {
13912                       if (is_opd && h != NULL)
13913                         {
13914                           /* Lie about opd entries.  This case occurs
13915                              when building shared libraries and we
13916                              reference a function in another shared
13917                              lib.  The same thing happens for a weak
13918                              definition in an application that's
13919                              overridden by a strong definition in a
13920                              shared lib.  (I believe this is a generic
13921                              bug in binutils handling of weak syms.)
13922                              In these cases we won't use the opd
13923                              entry in this lib.  */
13924                           unresolved_reloc = FALSE;
13925                         }
13926                       if (!is_opd
13927                           && r_type == R_PPC64_ADDR64
13928                           && (h != NULL
13929                               ? h->elf.type == STT_GNU_IFUNC
13930                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13931                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13932                       else
13933                         {
13934                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13935
13936                           /* We need to relocate .opd contents for ld.so.
13937                              Prelink also wants simple and consistent rules
13938                              for relocs.  This make all RELATIVE relocs have
13939                              *r_offset equal to r_addend.  */
13940                           relocate = TRUE;
13941                         }
13942                     }
13943                   else
13944                     {
13945                       long indx = 0;
13946
13947                       if (h != NULL
13948                           ? h->elf.type == STT_GNU_IFUNC
13949                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13950                         {
13951                           info->callbacks->einfo
13952                             (_("%P: %H: %s for indirect "
13953                                "function `%T' unsupported\n"),
13954                              input_bfd, input_section, rel->r_offset,
13955                              ppc64_elf_howto_table[r_type]->name,
13956                              sym_name);
13957                           ret = FALSE;
13958                         }
13959                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13960                         ;
13961                       else if (sec == NULL || sec->owner == NULL)
13962                         {
13963                           bfd_set_error (bfd_error_bad_value);
13964                           return FALSE;
13965                         }
13966                       else
13967                         {
13968                           asection *osec;
13969
13970                           osec = sec->output_section;
13971                           indx = elf_section_data (osec)->dynindx;
13972
13973                           if (indx == 0)
13974                             {
13975                               if ((osec->flags & SEC_READONLY) == 0
13976                                   && htab->elf.data_index_section != NULL)
13977                                 osec = htab->elf.data_index_section;
13978                               else
13979                                 osec = htab->elf.text_index_section;
13980                               indx = elf_section_data (osec)->dynindx;
13981                             }
13982                           BFD_ASSERT (indx != 0);
13983
13984                           /* We are turning this relocation into one
13985                              against a section symbol, so subtract out
13986                              the output section's address but not the
13987                              offset of the input section in the output
13988                              section.  */
13989                           outrel.r_addend -= osec->vma;
13990                         }
13991
13992                       outrel.r_info = ELF64_R_INFO (indx, r_type);
13993                     }
13994                 }
13995
13996               sreloc = elf_section_data (input_section)->sreloc;
13997               if (h != NULL
13998                   ? h->elf.type == STT_GNU_IFUNC
13999                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14000                 sreloc = htab->reliplt;
14001               if (sreloc == NULL)
14002                 abort ();
14003
14004               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14005                   >= sreloc->size)
14006                 abort ();
14007               loc = sreloc->contents;
14008               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14009               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14010
14011               /* If this reloc is against an external symbol, it will
14012                  be computed at runtime, so there's no need to do
14013                  anything now.  However, for the sake of prelink ensure
14014                  that the section contents are a known value.  */
14015               if (! relocate)
14016                 {
14017                   unresolved_reloc = FALSE;
14018                   /* The value chosen here is quite arbitrary as ld.so
14019                      ignores section contents except for the special
14020                      case of .opd where the contents might be accessed
14021                      before relocation.  Choose zero, as that won't
14022                      cause reloc overflow.  */
14023                   relocation = 0;
14024                   addend = 0;
14025                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14026                      to improve backward compatibility with older
14027                      versions of ld.  */
14028                   if (r_type == R_PPC64_ADDR64)
14029                     addend = outrel.r_addend;
14030                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14031                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14032                     addend = (input_section->output_section->vma
14033                               + input_section->output_offset
14034                               + rel->r_offset);
14035                 }
14036             }
14037           break;
14038
14039         case R_PPC64_COPY:
14040         case R_PPC64_GLOB_DAT:
14041         case R_PPC64_JMP_SLOT:
14042         case R_PPC64_JMP_IREL:
14043         case R_PPC64_RELATIVE:
14044           /* We shouldn't ever see these dynamic relocs in relocatable
14045              files.  */
14046           /* Fall through.  */
14047
14048         case R_PPC64_PLTGOT16:
14049         case R_PPC64_PLTGOT16_DS:
14050         case R_PPC64_PLTGOT16_HA:
14051         case R_PPC64_PLTGOT16_HI:
14052         case R_PPC64_PLTGOT16_LO:
14053         case R_PPC64_PLTGOT16_LO_DS:
14054         case R_PPC64_PLTREL32:
14055         case R_PPC64_PLTREL64:
14056           /* These ones haven't been implemented yet.  */
14057
14058           info->callbacks->einfo
14059             (_("%P: %B: %s is not supported for `%T'\n"),
14060              input_bfd,
14061              ppc64_elf_howto_table[r_type]->name, sym_name);
14062
14063           bfd_set_error (bfd_error_invalid_operation);
14064           ret = FALSE;
14065           continue;
14066         }
14067
14068       /* Multi-instruction sequences that access the TOC can be
14069          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14070          to             nop;           addi rb,r2,x;  */
14071       switch (r_type)
14072         {
14073         default:
14074           break;
14075
14076         case R_PPC64_GOT_TLSLD16_HI:
14077         case R_PPC64_GOT_TLSGD16_HI:
14078         case R_PPC64_GOT_TPREL16_HI:
14079         case R_PPC64_GOT_DTPREL16_HI:
14080         case R_PPC64_GOT16_HI:
14081         case R_PPC64_TOC16_HI:
14082           /* These relocs would only be useful if building up an
14083              offset to later add to r2, perhaps in an indexed
14084              addressing mode instruction.  Don't try to optimize.
14085              Unfortunately, the possibility of someone building up an
14086              offset like this or even with the HA relocs, means that
14087              we need to check the high insn when optimizing the low
14088              insn.  */
14089           break;
14090
14091         case R_PPC64_GOT_TLSLD16_HA:
14092         case R_PPC64_GOT_TLSGD16_HA:
14093         case R_PPC64_GOT_TPREL16_HA:
14094         case R_PPC64_GOT_DTPREL16_HA:
14095         case R_PPC64_GOT16_HA:
14096         case R_PPC64_TOC16_HA:
14097           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14098               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14099             {
14100               bfd_byte *p = contents + (rel->r_offset & ~3);
14101               bfd_put_32 (input_bfd, NOP, p);
14102             }
14103           break;
14104
14105         case R_PPC64_GOT_TLSLD16_LO:
14106         case R_PPC64_GOT_TLSGD16_LO:
14107         case R_PPC64_GOT_TPREL16_LO_DS:
14108         case R_PPC64_GOT_DTPREL16_LO_DS:
14109         case R_PPC64_GOT16_LO:
14110         case R_PPC64_GOT16_LO_DS:
14111         case R_PPC64_TOC16_LO:
14112         case R_PPC64_TOC16_LO_DS:
14113           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14114               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14115             {
14116               bfd_byte *p = contents + (rel->r_offset & ~3);
14117               insn = bfd_get_32 (input_bfd, p);
14118               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14119                 {
14120                   /* Transform addic to addi when we change reg.  */
14121                   insn &= ~((0x3f << 26) | (0x1f << 16));
14122                   insn |= (14u << 26) | (2 << 16);
14123                 }
14124               else
14125                 {
14126                   insn &= ~(0x1f << 16);
14127                   insn |= 2 << 16;
14128                 }
14129               bfd_put_32 (input_bfd, insn, p);
14130             }
14131           break;
14132         }
14133
14134       /* Do any further special processing.  */
14135       switch (r_type)
14136         {
14137         default:
14138           break;
14139
14140         case R_PPC64_REL16_HA:
14141         case R_PPC64_ADDR16_HA:
14142         case R_PPC64_ADDR16_HIGHA:
14143         case R_PPC64_ADDR16_HIGHERA:
14144         case R_PPC64_ADDR16_HIGHESTA:
14145         case R_PPC64_TOC16_HA:
14146         case R_PPC64_SECTOFF_HA:
14147         case R_PPC64_TPREL16_HA:
14148         case R_PPC64_TPREL16_HIGHA:
14149         case R_PPC64_TPREL16_HIGHERA:
14150         case R_PPC64_TPREL16_HIGHESTA:
14151         case R_PPC64_DTPREL16_HA:
14152         case R_PPC64_DTPREL16_HIGHA:
14153         case R_PPC64_DTPREL16_HIGHERA:
14154         case R_PPC64_DTPREL16_HIGHESTA:
14155           /* It's just possible that this symbol is a weak symbol
14156              that's not actually defined anywhere. In that case,
14157              'sec' would be NULL, and we should leave the symbol
14158              alone (it will be set to zero elsewhere in the link).  */
14159           if (sec == NULL)
14160             break;
14161           /* Fall thru */
14162
14163         case R_PPC64_GOT16_HA:
14164         case R_PPC64_PLTGOT16_HA:
14165         case R_PPC64_PLT16_HA:
14166         case R_PPC64_GOT_TLSGD16_HA:
14167         case R_PPC64_GOT_TLSLD16_HA:
14168         case R_PPC64_GOT_TPREL16_HA:
14169         case R_PPC64_GOT_DTPREL16_HA:
14170           /* Add 0x10000 if sign bit in 0:15 is set.
14171              Bits 0:15 are not used.  */
14172           addend += 0x8000;
14173           break;
14174
14175         case R_PPC64_ADDR16_DS:
14176         case R_PPC64_ADDR16_LO_DS:
14177         case R_PPC64_GOT16_DS:
14178         case R_PPC64_GOT16_LO_DS:
14179         case R_PPC64_PLT16_LO_DS:
14180         case R_PPC64_SECTOFF_DS:
14181         case R_PPC64_SECTOFF_LO_DS:
14182         case R_PPC64_TOC16_DS:
14183         case R_PPC64_TOC16_LO_DS:
14184         case R_PPC64_PLTGOT16_DS:
14185         case R_PPC64_PLTGOT16_LO_DS:
14186         case R_PPC64_GOT_TPREL16_DS:
14187         case R_PPC64_GOT_TPREL16_LO_DS:
14188         case R_PPC64_GOT_DTPREL16_DS:
14189         case R_PPC64_GOT_DTPREL16_LO_DS:
14190         case R_PPC64_TPREL16_DS:
14191         case R_PPC64_TPREL16_LO_DS:
14192         case R_PPC64_DTPREL16_DS:
14193         case R_PPC64_DTPREL16_LO_DS:
14194           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14195           mask = 3;
14196           /* If this reloc is against an lq insn, then the value must be
14197              a multiple of 16.  This is somewhat of a hack, but the
14198              "correct" way to do this by defining _DQ forms of all the
14199              _DS relocs bloats all reloc switches in this file.  It
14200              doesn't seem to make much sense to use any of these relocs
14201              in data, so testing the insn should be safe.  */
14202           if ((insn & (0x3f << 26)) == (56u << 26))
14203             mask = 15;
14204           if (((relocation + addend) & mask) != 0)
14205             {
14206               info->callbacks->einfo
14207                 (_("%P: %H: error: %s not a multiple of %u\n"),
14208                  input_bfd, input_section, rel->r_offset,
14209                  ppc64_elf_howto_table[r_type]->name,
14210                  mask + 1);
14211               bfd_set_error (bfd_error_bad_value);
14212               ret = FALSE;
14213               continue;
14214             }
14215           break;
14216         }
14217
14218       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14219          because such sections are not SEC_ALLOC and thus ld.so will
14220          not process them.  */
14221       if (unresolved_reloc
14222           && !((input_section->flags & SEC_DEBUGGING) != 0
14223                && h->elf.def_dynamic)
14224           && _bfd_elf_section_offset (output_bfd, info, input_section,
14225                                       rel->r_offset) != (bfd_vma) -1)
14226         {
14227           info->callbacks->einfo
14228             (_("%P: %H: unresolvable %s against `%T'\n"),
14229              input_bfd, input_section, rel->r_offset,
14230              ppc64_elf_howto_table[(int) r_type]->name,
14231              h->elf.root.root.string);
14232           ret = FALSE;
14233         }
14234
14235       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14236                                     input_bfd,
14237                                     input_section,
14238                                     contents,
14239                                     rel->r_offset,
14240                                     relocation,
14241                                     addend);
14242
14243       if (r != bfd_reloc_ok)
14244         {
14245           char *more_info = NULL;
14246           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14247
14248           if (reloc_dest != DEST_NORMAL)
14249             {
14250               more_info = bfd_malloc (strlen (reloc_name) + 8);
14251               if (more_info != NULL)
14252                 {
14253                   strcpy (more_info, reloc_name);
14254                   strcat (more_info, (reloc_dest == DEST_OPD
14255                                       ? " (OPD)" : " (stub)"));
14256                   reloc_name = more_info;
14257                 }
14258             }
14259
14260           if (r == bfd_reloc_overflow)
14261             {
14262               if (warned)
14263                 continue;
14264               if (h != NULL
14265                   && h->elf.root.type == bfd_link_hash_undefweak
14266                   && ppc64_elf_howto_table[r_type]->pc_relative)
14267                 {
14268                   /* Assume this is a call protected by other code that
14269                      detects the symbol is undefined.  If this is the case,
14270                      we can safely ignore the overflow.  If not, the
14271                      program is hosed anyway, and a little warning isn't
14272                      going to help.  */
14273
14274                   continue;
14275                 }
14276
14277               if (!((*info->callbacks->reloc_overflow)
14278                     (info, &h->elf.root, sym_name,
14279                      reloc_name, orig_rel.r_addend,
14280                      input_bfd, input_section, rel->r_offset)))
14281                 return FALSE;
14282             }
14283           else
14284             {
14285               info->callbacks->einfo
14286                 (_("%P: %H: %s against `%T': error %d\n"),
14287                  input_bfd, input_section, rel->r_offset,
14288                  reloc_name, sym_name, (int) r);
14289               ret = FALSE;
14290             }
14291           if (more_info != NULL)
14292             free (more_info);
14293         }
14294     }
14295
14296   /* If we're emitting relocations, then shortly after this function
14297      returns, reloc offsets and addends for this section will be
14298      adjusted.  Worse, reloc symbol indices will be for the output
14299      file rather than the input.  Save a copy of the relocs for
14300      opd_entry_value.  */
14301   if (is_opd && (info->emitrelocations || info->relocatable))
14302     {
14303       bfd_size_type amt;
14304       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14305       rel = bfd_alloc (input_bfd, amt);
14306       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14307       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14308       if (rel == NULL)
14309         return FALSE;
14310       memcpy (rel, relocs, amt);
14311     }
14312   return ret;
14313 }
14314
14315 /* Adjust the value of any local symbols in opd sections.  */
14316
14317 static int
14318 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14319                               const char *name ATTRIBUTE_UNUSED,
14320                               Elf_Internal_Sym *elfsym,
14321                               asection *input_sec,
14322                               struct elf_link_hash_entry *h)
14323 {
14324   struct _opd_sec_data *opd;
14325   long adjust;
14326   bfd_vma value;
14327
14328   if (h != NULL)
14329     return 1;
14330
14331   opd = get_opd_info (input_sec);
14332   if (opd == NULL || opd->adjust == NULL)
14333     return 1;
14334
14335   value = elfsym->st_value - input_sec->output_offset;
14336   if (!info->relocatable)
14337     value -= input_sec->output_section->vma;
14338
14339   adjust = opd->adjust[value / 8];
14340   if (adjust == -1)
14341     return 2;
14342
14343   elfsym->st_value += adjust;
14344   return 1;
14345 }
14346
14347 /* Finish up dynamic symbol handling.  We set the contents of various
14348    dynamic sections here.  */
14349
14350 static bfd_boolean
14351 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14352                                  struct bfd_link_info *info,
14353                                  struct elf_link_hash_entry *h,
14354                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14355 {
14356   struct ppc_link_hash_table *htab;
14357   struct plt_entry *ent;
14358   Elf_Internal_Rela rela;
14359   bfd_byte *loc;
14360
14361   htab = ppc_hash_table (info);
14362   if (htab == NULL)
14363     return FALSE;
14364
14365   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14366     if (ent->plt.offset != (bfd_vma) -1)
14367       {
14368         /* This symbol has an entry in the procedure linkage
14369            table.  Set it up.  */
14370         if (!htab->elf.dynamic_sections_created
14371             || h->dynindx == -1)
14372           {
14373             BFD_ASSERT (h->type == STT_GNU_IFUNC
14374                         && h->def_regular
14375                         && (h->root.type == bfd_link_hash_defined
14376                             || h->root.type == bfd_link_hash_defweak));
14377             rela.r_offset = (htab->iplt->output_section->vma
14378                              + htab->iplt->output_offset
14379                              + ent->plt.offset);
14380             if (htab->opd_abi)
14381               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14382             else
14383               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14384             rela.r_addend = (h->root.u.def.value
14385                              + h->root.u.def.section->output_offset
14386                              + h->root.u.def.section->output_section->vma
14387                              + ent->addend);
14388             loc = (htab->reliplt->contents
14389                    + (htab->reliplt->reloc_count++
14390                       * sizeof (Elf64_External_Rela)));
14391           }
14392         else
14393           {
14394             rela.r_offset = (htab->plt->output_section->vma
14395                              + htab->plt->output_offset
14396                              + ent->plt.offset);
14397             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14398             rela.r_addend = ent->addend;
14399             loc = (htab->relplt->contents
14400                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
14401                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
14402           }
14403         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14404       }
14405
14406   if (h->needs_copy)
14407     {
14408       /* This symbol needs a copy reloc.  Set it up.  */
14409
14410       if (h->dynindx == -1
14411           || (h->root.type != bfd_link_hash_defined
14412               && h->root.type != bfd_link_hash_defweak)
14413           || htab->relbss == NULL)
14414         abort ();
14415
14416       rela.r_offset = (h->root.u.def.value
14417                        + h->root.u.def.section->output_section->vma
14418                        + h->root.u.def.section->output_offset);
14419       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14420       rela.r_addend = 0;
14421       loc = htab->relbss->contents;
14422       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14423       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14424     }
14425
14426   return TRUE;
14427 }
14428
14429 /* Used to decide how to sort relocs in an optimal manner for the
14430    dynamic linker, before writing them out.  */
14431
14432 static enum elf_reloc_type_class
14433 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14434                             const asection *rel_sec,
14435                             const Elf_Internal_Rela *rela)
14436 {
14437   enum elf_ppc64_reloc_type r_type;
14438   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14439
14440   if (rel_sec == htab->reliplt)
14441     return reloc_class_ifunc;
14442
14443   r_type = ELF64_R_TYPE (rela->r_info);
14444   switch (r_type)
14445     {
14446     case R_PPC64_RELATIVE:
14447       return reloc_class_relative;
14448     case R_PPC64_JMP_SLOT:
14449       return reloc_class_plt;
14450     case R_PPC64_COPY:
14451       return reloc_class_copy;
14452     default:
14453       return reloc_class_normal;
14454     }
14455 }
14456
14457 /* Finish up the dynamic sections.  */
14458
14459 static bfd_boolean
14460 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14461                                    struct bfd_link_info *info)
14462 {
14463   struct ppc_link_hash_table *htab;
14464   bfd *dynobj;
14465   asection *sdyn;
14466
14467   htab = ppc_hash_table (info);
14468   if (htab == NULL)
14469     return FALSE;
14470
14471   dynobj = htab->elf.dynobj;
14472   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14473
14474   if (htab->elf.dynamic_sections_created)
14475     {
14476       Elf64_External_Dyn *dyncon, *dynconend;
14477
14478       if (sdyn == NULL || htab->got == NULL)
14479         abort ();
14480
14481       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14482       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14483       for (; dyncon < dynconend; dyncon++)
14484         {
14485           Elf_Internal_Dyn dyn;
14486           asection *s;
14487
14488           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14489
14490           switch (dyn.d_tag)
14491             {
14492             default:
14493               continue;
14494
14495             case DT_PPC64_GLINK:
14496               s = htab->glink;
14497               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14498               /* We stupidly defined DT_PPC64_GLINK to be the start
14499                  of glink rather than the first entry point, which is
14500                  what ld.so needs, and now have a bigger stub to
14501                  support automatic multiple TOCs.  */
14502               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
14503               break;
14504
14505             case DT_PPC64_OPD:
14506               s = bfd_get_section_by_name (output_bfd, ".opd");
14507               if (s == NULL)
14508                 continue;
14509               dyn.d_un.d_ptr = s->vma;
14510               break;
14511
14512             case DT_PPC64_OPDSZ:
14513               s = bfd_get_section_by_name (output_bfd, ".opd");
14514               if (s == NULL)
14515                 continue;
14516               dyn.d_un.d_val = s->size;
14517               break;
14518
14519             case DT_PLTGOT:
14520               s = htab->plt;
14521               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14522               break;
14523
14524             case DT_JMPREL:
14525               s = htab->relplt;
14526               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14527               break;
14528
14529             case DT_PLTRELSZ:
14530               dyn.d_un.d_val = htab->relplt->size;
14531               break;
14532
14533             case DT_RELASZ:
14534               /* Don't count procedure linkage table relocs in the
14535                  overall reloc count.  */
14536               s = htab->relplt;
14537               if (s == NULL)
14538                 continue;
14539               dyn.d_un.d_val -= s->size;
14540               break;
14541
14542             case DT_RELA:
14543               /* We may not be using the standard ELF linker script.
14544                  If .rela.plt is the first .rela section, we adjust
14545                  DT_RELA to not include it.  */
14546               s = htab->relplt;
14547               if (s == NULL)
14548                 continue;
14549               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14550                 continue;
14551               dyn.d_un.d_ptr += s->size;
14552               break;
14553             }
14554
14555           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14556         }
14557     }
14558
14559   if (htab->got != NULL && htab->got->size != 0)
14560     {
14561       /* Fill in the first entry in the global offset table.
14562          We use it to hold the link-time TOCbase.  */
14563       bfd_put_64 (output_bfd,
14564                   elf_gp (output_bfd) + TOC_BASE_OFF,
14565                   htab->got->contents);
14566
14567       /* Set .got entry size.  */
14568       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
14569     }
14570
14571   if (htab->plt != NULL && htab->plt->size != 0)
14572     {
14573       /* Set .plt entry size.  */
14574       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
14575         = PLT_ENTRY_SIZE;
14576     }
14577
14578   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14579      brlt ourselves if emitrelocations.  */
14580   if (htab->brlt != NULL
14581       && htab->brlt->reloc_count != 0
14582       && !_bfd_elf_link_output_relocs (output_bfd,
14583                                        htab->brlt,
14584                                        elf_section_data (htab->brlt)->rela.hdr,
14585                                        elf_section_data (htab->brlt)->relocs,
14586                                        NULL))
14587     return FALSE;
14588
14589   if (htab->glink != NULL
14590       && htab->glink->reloc_count != 0
14591       && !_bfd_elf_link_output_relocs (output_bfd,
14592                                        htab->glink,
14593                                        elf_section_data (htab->glink)->rela.hdr,
14594                                        elf_section_data (htab->glink)->relocs,
14595                                        NULL))
14596     return FALSE;
14597
14598
14599   if (htab->glink_eh_frame != NULL
14600       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14601       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14602                                            htab->glink_eh_frame,
14603                                            htab->glink_eh_frame->contents))
14604     return FALSE;
14605
14606   /* We need to handle writing out multiple GOT sections ourselves,
14607      since we didn't add them to DYNOBJ.  We know dynobj is the first
14608      bfd.  */
14609   while ((dynobj = dynobj->link_next) != NULL)
14610     {
14611       asection *s;
14612
14613       if (!is_ppc64_elf (dynobj))
14614         continue;
14615
14616       s = ppc64_elf_tdata (dynobj)->got;
14617       if (s != NULL
14618           && s->size != 0
14619           && s->output_section != bfd_abs_section_ptr
14620           && !bfd_set_section_contents (output_bfd, s->output_section,
14621                                         s->contents, s->output_offset,
14622                                         s->size))
14623         return FALSE;
14624       s = ppc64_elf_tdata (dynobj)->relgot;
14625       if (s != NULL
14626           && s->size != 0
14627           && s->output_section != bfd_abs_section_ptr
14628           && !bfd_set_section_contents (output_bfd, s->output_section,
14629                                         s->contents, s->output_offset,
14630                                         s->size))
14631         return FALSE;
14632     }
14633
14634   return TRUE;
14635 }
14636
14637 #include "elf64-target.h"
14638
14639 /* FreeBSD support */
14640
14641 #undef  TARGET_LITTLE_SYM
14642 #undef  TARGET_LITTLE_NAME
14643
14644 #undef  TARGET_BIG_SYM
14645 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
14646 #undef  TARGET_BIG_NAME
14647 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
14648
14649 #undef  ELF_OSABI
14650 #define ELF_OSABI       ELFOSABI_FREEBSD
14651
14652 #undef  elf64_bed
14653 #define elf64_bed       elf64_powerpc_fbsd_bed
14654
14655 #include "elf64-target.h"
14656