bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   3    Free Software Foundation, Inc.
   4    Written by Linus Nordberg, Swox AB <[email protected]>,
   5    based on elf32-ppc.c by Ian Lance Taylor.
   6    Largely rewritten by Alan Modra <[email protected]>
   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 2 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 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "bfd.h"
  29 #include "sysdep.h"
  30 #include "bfdlink.h"
  31 #include "libbfd.h"
  32 #include "elf-bfd.h"
  33 #include "elf/ppc64.h"
  34 #include "elf64-ppc.h"
  35
  36 static bfd_reloc_status_type ppc64_elf_ha_reloc
  37   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  38 static bfd_reloc_status_type ppc64_elf_branch_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_toc_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_vma opd_entry_value
  55   (asection *, bfd_vma, asection **, bfd_vma *);
  56
  57 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  58 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  59 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  60 #define TARGET_BIG_NAME         "elf64-powerpc"
  61 #define ELF_ARCH                bfd_arch_powerpc
  62 #define ELF_MACHINE_CODE        EM_PPC64
  63 #define ELF_MAXPAGESIZE         0x10000
  64 #define ELF_COMMONPAGESIZE      0x1000
  65 #define elf_info_to_howto       ppc64_elf_info_to_howto
  66
  67 #define elf_backend_want_got_sym 0
  68 #define elf_backend_want_plt_sym 0
  69 #define elf_backend_plt_alignment 3
  70 #define elf_backend_plt_not_loaded 1
  71 #define elf_backend_got_header_size 8
  72 #define elf_backend_can_gc_sections 1
  73 #define elf_backend_can_refcount 1
  74 #define elf_backend_rela_normal 1
  75
  76 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  77 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  78 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  79 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  80 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  81 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  82 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  83
  84 #define elf_backend_object_p                  ppc64_elf_object_p
  85 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  86 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  87 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  88 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  89 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  90 #define elf_backend_check_directives          ppc64_elf_check_directives
  91 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
  92 #define elf_backend_check_relocs              ppc64_elf_check_relocs
  93 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
  94 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
  95 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
  96 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
  97 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
  98 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
  99 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 100 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 101 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 102 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 103 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 104 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 105 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 106 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 107 #define elf_backend_special_sections          ppc64_elf_special_sections
 108
 109 /* The name of the dynamic interpreter.  This is put in the .interp
 110    section.  */
 111 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 112
 113 /* The size in bytes of an entry in the procedure linkage table.  */
 114 #define PLT_ENTRY_SIZE 24
 115
 116 /* The initial size of the plt reserved for the dynamic linker.  */
 117 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 118
 119 /* TOC base pointers offset from start of TOC.  */
 120 #define TOC_BASE_OFF    0x8000
 121
 122 /* Offset of tp and dtp pointers from start of TLS block.  */
 123 #define TP_OFFSET       0x7000
 124 #define DTP_OFFSET      0x8000
 125
 126 /* .plt call stub instructions.  The normal stub is like this, but
 127    sometimes the .plt entry crosses a 64k boundary and we need to
 128    insert an addis to adjust r12.  */
 129 #define PLT_CALL_STUB_SIZE (7*4)
 130 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 131 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 132 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 133 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 134 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 135                                         /* ld    %r11,xxx+16@l(%r12) */
 136 #define BCTR            0x4e800420      /* bctr                      */
 137
 138
 139 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 140 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 141 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 142
 143 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 144
 145 /* glink call stub instructions.  We enter with the index in R0.  */
 146 #define GLINK_CALL_STUB_SIZE (16*4)
 147                                         /* 0:                           */
 148                                         /*  .quad plt0-1f               */
 149                                         /* __glink:                     */
 150 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 151 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 152                                         /* 1:                           */
 153 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 154 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 155 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 156 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 157                                         /*  ld %11,0(%12)               */
 158                                         /*  ld %2,8(%12)                */
 159                                         /*  mtctr %11                   */
 160                                         /*  ld %11,16(%12)              */
 161                                         /*  bctr                        */
 162
 163 /* Pad with this.  */
 164 #define NOP             0x60000000
 165
 166 /* Some other nops.  */
 167 #define CROR_151515     0x4def7b82
 168 #define CROR_313131     0x4ffffb82
 169
 170 /* .glink entries for the first 32k functions are two instructions.  */
 171 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 172 #define B_DOT           0x48000000      /* b     .              */
 173
 174 /* After that, we need two instructions to load the index, followed by
 175    a branch.  */
 176 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 177 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 178
 179 /* Instructions used by the save and restore reg functions.  */
 180 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 181 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 182 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 183 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 184 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 185 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 186 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 187 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 188 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 189 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 190 #define BLR             0x4e800020      /* blr                  */
 191
 192 /* Since .opd is an array of descriptors and each entry will end up
 193    with identical R_PPC64_RELATIVE relocs, there is really no need to
 194    propagate .opd relocs;  The dynamic linker should be taught to
 195    relocate .opd without reloc entries.  */
 196 #ifndef NO_OPD_RELOCS
 197 #define NO_OPD_RELOCS 0
 198 #endif
 199 \f
 200 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 201
 202 /* Relocation HOWTO's.  */
 203 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 204
 205 static reloc_howto_type ppc64_elf_howto_raw[] = {
 206   /* This reloc does nothing.  */
 207   HOWTO (R_PPC64_NONE,          /* type */
 208          0,                     /* rightshift */
 209          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 210          32,                    /* bitsize */
 211          FALSE,                 /* pc_relative */
 212          0,                     /* bitpos */
 213          complain_overflow_dont, /* complain_on_overflow */
 214          bfd_elf_generic_reloc, /* special_function */
 215          "R_PPC64_NONE",        /* name */
 216          FALSE,                 /* partial_inplace */
 217          0,                     /* src_mask */
 218          0,                     /* dst_mask */
 219          FALSE),                /* pcrel_offset */
 220
 221   /* A standard 32 bit relocation.  */
 222   HOWTO (R_PPC64_ADDR32,        /* type */
 223          0,                     /* rightshift */
 224          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 225          32,                    /* bitsize */
 226          FALSE,                 /* pc_relative */
 227          0,                     /* bitpos */
 228          complain_overflow_bitfield, /* complain_on_overflow */
 229          bfd_elf_generic_reloc, /* special_function */
 230          "R_PPC64_ADDR32",      /* name */
 231          FALSE,                 /* partial_inplace */
 232          0,                     /* src_mask */
 233          0xffffffff,            /* dst_mask */
 234          FALSE),                /* pcrel_offset */
 235
 236   /* An absolute 26 bit branch; the lower two bits must be zero.
 237      FIXME: we don't check that, we just clear them.  */
 238   HOWTO (R_PPC64_ADDR24,        /* type */
 239          0,                     /* rightshift */
 240          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 241          26,                    /* bitsize */
 242          FALSE,                 /* pc_relative */
 243          0,                     /* bitpos */
 244          complain_overflow_bitfield, /* complain_on_overflow */
 245          bfd_elf_generic_reloc, /* special_function */
 246          "R_PPC64_ADDR24",      /* name */
 247          FALSE,                 /* partial_inplace */
 248          0,                     /* src_mask */
 249          0x03fffffc,            /* dst_mask */
 250          FALSE),                /* pcrel_offset */
 251
 252   /* A standard 16 bit relocation.  */
 253   HOWTO (R_PPC64_ADDR16,        /* type */
 254          0,                     /* rightshift */
 255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 256          16,                    /* bitsize */
 257          FALSE,                 /* pc_relative */
 258          0,                     /* bitpos */
 259          complain_overflow_bitfield, /* complain_on_overflow */
 260          bfd_elf_generic_reloc, /* special_function */
 261          "R_PPC64_ADDR16",      /* name */
 262          FALSE,                 /* partial_inplace */
 263          0,                     /* src_mask */
 264          0xffff,                /* dst_mask */
 265          FALSE),                /* pcrel_offset */
 266
 267   /* A 16 bit relocation without overflow.  */
 268   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 269          0,                     /* rightshift */
 270          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          16,                    /* bitsize */
 272          FALSE,                 /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_dont,/* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* special_function */
 276          "R_PPC64_ADDR16_LO",   /* name */
 277          FALSE,                 /* partial_inplace */
 278          0,                     /* src_mask */
 279          0xffff,                /* dst_mask */
 280          FALSE),                /* pcrel_offset */
 281
 282   /* Bits 16-31 of an address.  */
 283   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 284          16,                    /* rightshift */
 285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 286          16,                    /* bitsize */
 287          FALSE,                 /* pc_relative */
 288          0,                     /* bitpos */
 289          complain_overflow_dont, /* complain_on_overflow */
 290          bfd_elf_generic_reloc, /* special_function */
 291          "R_PPC64_ADDR16_HI",   /* name */
 292          FALSE,                 /* partial_inplace */
 293          0,                     /* src_mask */
 294          0xffff,                /* dst_mask */
 295          FALSE),                /* pcrel_offset */
 296
 297   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 298      bits, treated as a signed number, is negative.  */
 299   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 300          16,                    /* rightshift */
 301          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 302          16,                    /* bitsize */
 303          FALSE,                 /* pc_relative */
 304          0,                     /* bitpos */
 305          complain_overflow_dont, /* complain_on_overflow */
 306          ppc64_elf_ha_reloc,    /* special_function */
 307          "R_PPC64_ADDR16_HA",   /* name */
 308          FALSE,                 /* partial_inplace */
 309          0,                     /* src_mask */
 310          0xffff,                /* dst_mask */
 311          FALSE),                /* pcrel_offset */
 312
 313   /* An absolute 16 bit branch; the lower two bits must be zero.
 314      FIXME: we don't check that, we just clear them.  */
 315   HOWTO (R_PPC64_ADDR14,        /* type */
 316          0,                     /* rightshift */
 317          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          ppc64_elf_branch_reloc, /* special_function */
 323          "R_PPC64_ADDR14",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0x0000fffc,            /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* An absolute 16 bit branch, for which bit 10 should be set to
 330      indicate that the branch is expected to be taken.  The lower two
 331      bits must be zero.  */
 332   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 333          0,                     /* rightshift */
 334          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 335          16,                    /* bitsize */
 336          FALSE,                 /* pc_relative */
 337          0,                     /* bitpos */
 338          complain_overflow_bitfield, /* complain_on_overflow */
 339          ppc64_elf_brtaken_reloc, /* special_function */
 340          "R_PPC64_ADDR14_BRTAKEN",/* name */
 341          FALSE,                 /* partial_inplace */
 342          0,                     /* src_mask */
 343          0x0000fffc,            /* dst_mask */
 344          FALSE),                /* pcrel_offset */
 345
 346   /* An absolute 16 bit branch, for which bit 10 should be set to
 347      indicate that the branch is not expected to be taken.  The lower
 348      two bits must be zero.  */
 349   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 350          0,                     /* rightshift */
 351          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 352          16,                    /* bitsize */
 353          FALSE,                 /* pc_relative */
 354          0,                     /* bitpos */
 355          complain_overflow_bitfield, /* complain_on_overflow */
 356          ppc64_elf_brtaken_reloc, /* special_function */
 357          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 358          FALSE,                 /* partial_inplace */
 359          0,                     /* src_mask */
 360          0x0000fffc,            /* dst_mask */
 361          FALSE),                /* pcrel_offset */
 362
 363   /* A relative 26 bit branch; the lower two bits must be zero.  */
 364   HOWTO (R_PPC64_REL24,         /* type */
 365          0,                     /* rightshift */
 366          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 367          26,                    /* bitsize */
 368          TRUE,                  /* pc_relative */
 369          0,                     /* bitpos */
 370          complain_overflow_signed, /* complain_on_overflow */
 371          ppc64_elf_branch_reloc, /* special_function */
 372          "R_PPC64_REL24",       /* name */
 373          FALSE,                 /* partial_inplace */
 374          0,                     /* src_mask */
 375          0x03fffffc,            /* dst_mask */
 376          TRUE),                 /* pcrel_offset */
 377
 378   /* A relative 16 bit branch; the lower two bits must be zero.  */
 379   HOWTO (R_PPC64_REL14,         /* type */
 380          0,                     /* rightshift */
 381          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 382          16,                    /* bitsize */
 383          TRUE,                  /* pc_relative */
 384          0,                     /* bitpos */
 385          complain_overflow_signed, /* complain_on_overflow */
 386          ppc64_elf_branch_reloc, /* special_function */
 387          "R_PPC64_REL14",       /* name */
 388          FALSE,                 /* partial_inplace */
 389          0,                     /* src_mask */
 390          0x0000fffc,            /* dst_mask */
 391          TRUE),                 /* pcrel_offset */
 392
 393   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 394      the branch is expected to be taken.  The lower two bits must be
 395      zero.  */
 396   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 397          0,                     /* rightshift */
 398          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 399          16,                    /* bitsize */
 400          TRUE,                  /* pc_relative */
 401          0,                     /* bitpos */
 402          complain_overflow_signed, /* complain_on_overflow */
 403          ppc64_elf_brtaken_reloc, /* special_function */
 404          "R_PPC64_REL14_BRTAKEN", /* name */
 405          FALSE,                 /* partial_inplace */
 406          0,                     /* src_mask */
 407          0x0000fffc,            /* dst_mask */
 408          TRUE),                 /* pcrel_offset */
 409
 410   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 411      the branch is not expected to be taken.  The lower two bits must
 412      be zero.  */
 413   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 414          0,                     /* rightshift */
 415          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 416          16,                    /* bitsize */
 417          TRUE,                  /* pc_relative */
 418          0,                     /* bitpos */
 419          complain_overflow_signed, /* complain_on_overflow */
 420          ppc64_elf_brtaken_reloc, /* special_function */
 421          "R_PPC64_REL14_BRNTAKEN",/* name */
 422          FALSE,                 /* partial_inplace */
 423          0,                     /* src_mask */
 424          0x0000fffc,            /* dst_mask */
 425          TRUE),                 /* pcrel_offset */
 426
 427   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 428      symbol.  */
 429   HOWTO (R_PPC64_GOT16,         /* type */
 430          0,                     /* rightshift */
 431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 432          16,                    /* bitsize */
 433          FALSE,                 /* pc_relative */
 434          0,                     /* bitpos */
 435          complain_overflow_signed, /* complain_on_overflow */
 436          ppc64_elf_unhandled_reloc, /* special_function */
 437          "R_PPC64_GOT16",       /* name */
 438          FALSE,                 /* partial_inplace */
 439          0,                     /* src_mask */
 440          0xffff,                /* dst_mask */
 441          FALSE),                /* pcrel_offset */
 442
 443   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 444      the symbol.  */
 445   HOWTO (R_PPC64_GOT16_LO,      /* type */
 446          0,                     /* rightshift */
 447          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 448          16,                    /* bitsize */
 449          FALSE,                 /* pc_relative */
 450          0,                     /* bitpos */
 451          complain_overflow_dont, /* complain_on_overflow */
 452          ppc64_elf_unhandled_reloc, /* special_function */
 453          "R_PPC64_GOT16_LO",    /* name */
 454          FALSE,                 /* partial_inplace */
 455          0,                     /* src_mask */
 456          0xffff,                /* dst_mask */
 457          FALSE),                /* pcrel_offset */
 458
 459   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 460      the symbol.  */
 461   HOWTO (R_PPC64_GOT16_HI,      /* type */
 462          16,                    /* rightshift */
 463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 464          16,                    /* bitsize */
 465          FALSE,                 /* pc_relative */
 466          0,                     /* bitpos */
 467          complain_overflow_dont,/* complain_on_overflow */
 468          ppc64_elf_unhandled_reloc, /* special_function */
 469          "R_PPC64_GOT16_HI",    /* name */
 470          FALSE,                 /* partial_inplace */
 471          0,                     /* src_mask */
 472          0xffff,                /* dst_mask */
 473          FALSE),                /* pcrel_offset */
 474
 475   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 476      the symbol.  */
 477   HOWTO (R_PPC64_GOT16_HA,      /* type */
 478          16,                    /* rightshift */
 479          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 480          16,                    /* bitsize */
 481          FALSE,                 /* pc_relative */
 482          0,                     /* bitpos */
 483          complain_overflow_dont,/* complain_on_overflow */
 484          ppc64_elf_unhandled_reloc, /* special_function */
 485          "R_PPC64_GOT16_HA",    /* name */
 486          FALSE,                 /* partial_inplace */
 487          0,                     /* src_mask */
 488          0xffff,                /* dst_mask */
 489          FALSE),                /* pcrel_offset */
 490
 491   /* This is used only by the dynamic linker.  The symbol should exist
 492      both in the object being run and in some shared library.  The
 493      dynamic linker copies the data addressed by the symbol from the
 494      shared library into the object, because the object being
 495      run has to have the data at some particular address.  */
 496   HOWTO (R_PPC64_COPY,          /* type */
 497          0,                     /* rightshift */
 498          0,                     /* this one is variable size */
 499          0,                     /* bitsize */
 500          FALSE,                 /* pc_relative */
 501          0,                     /* bitpos */
 502          complain_overflow_dont, /* complain_on_overflow */
 503          ppc64_elf_unhandled_reloc, /* special_function */
 504          "R_PPC64_COPY",        /* name */
 505          FALSE,                 /* partial_inplace */
 506          0,                     /* src_mask */
 507          0,                     /* dst_mask */
 508          FALSE),                /* pcrel_offset */
 509
 510   /* Like R_PPC64_ADDR64, but used when setting global offset table
 511      entries.  */
 512   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 513          0,                     /* rightshift */
 514          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 515          64,                    /* bitsize */
 516          FALSE,                 /* pc_relative */
 517          0,                     /* bitpos */
 518          complain_overflow_dont, /* complain_on_overflow */
 519          ppc64_elf_unhandled_reloc,  /* special_function */
 520          "R_PPC64_GLOB_DAT",    /* name */
 521          FALSE,                 /* partial_inplace */
 522          0,                     /* src_mask */
 523          ONES (64),             /* dst_mask */
 524          FALSE),                /* pcrel_offset */
 525
 526   /* Created by the link editor.  Marks a procedure linkage table
 527      entry for a symbol.  */
 528   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 529          0,                     /* rightshift */
 530          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          0,                     /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_dont, /* complain_on_overflow */
 535          ppc64_elf_unhandled_reloc, /* special_function */
 536          "R_PPC64_JMP_SLOT",    /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0,                     /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* Used only by the dynamic linker.  When the object is run, this
 543      doubleword64 is set to the load address of the object, plus the
 544      addend.  */
 545   HOWTO (R_PPC64_RELATIVE,      /* type */
 546          0,                     /* rightshift */
 547          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 548          64,                    /* bitsize */
 549          FALSE,                 /* pc_relative */
 550          0,                     /* bitpos */
 551          complain_overflow_dont, /* complain_on_overflow */
 552          bfd_elf_generic_reloc, /* special_function */
 553          "R_PPC64_RELATIVE",    /* name */
 554          FALSE,                 /* partial_inplace */
 555          0,                     /* src_mask */
 556          ONES (64),             /* dst_mask */
 557          FALSE),                /* pcrel_offset */
 558
 559   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 560   HOWTO (R_PPC64_UADDR32,       /* type */
 561          0,                     /* rightshift */
 562          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 563          32,                    /* bitsize */
 564          FALSE,                 /* pc_relative */
 565          0,                     /* bitpos */
 566          complain_overflow_bitfield, /* complain_on_overflow */
 567          bfd_elf_generic_reloc, /* special_function */
 568          "R_PPC64_UADDR32",     /* name */
 569          FALSE,                 /* partial_inplace */
 570          0,                     /* src_mask */
 571          0xffffffff,            /* dst_mask */
 572          FALSE),                /* pcrel_offset */
 573
 574   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 575   HOWTO (R_PPC64_UADDR16,       /* type */
 576          0,                     /* rightshift */
 577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 578          16,                    /* bitsize */
 579          FALSE,                 /* pc_relative */
 580          0,                     /* bitpos */
 581          complain_overflow_bitfield, /* complain_on_overflow */
 582          bfd_elf_generic_reloc, /* special_function */
 583          "R_PPC64_UADDR16",     /* name */
 584          FALSE,                 /* partial_inplace */
 585          0,                     /* src_mask */
 586          0xffff,                /* dst_mask */
 587          FALSE),                /* pcrel_offset */
 588
 589   /* 32-bit PC relative.  */
 590   HOWTO (R_PPC64_REL32,         /* type */
 591          0,                     /* rightshift */
 592          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          32,                    /* bitsize */
 594          TRUE,                  /* pc_relative */
 595          0,                     /* bitpos */
 596          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 597          complain_overflow_signed, /* complain_on_overflow */
 598          bfd_elf_generic_reloc, /* special_function */
 599          "R_PPC64_REL32",       /* name */
 600          FALSE,                 /* partial_inplace */
 601          0,                     /* src_mask */
 602          0xffffffff,            /* dst_mask */
 603          TRUE),                 /* pcrel_offset */
 604
 605   /* 32-bit relocation to the symbol's procedure linkage table.  */
 606   HOWTO (R_PPC64_PLT32,         /* type */
 607          0,                     /* rightshift */
 608          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 609          32,                    /* bitsize */
 610          FALSE,                 /* pc_relative */
 611          0,                     /* bitpos */
 612          complain_overflow_bitfield, /* complain_on_overflow */
 613          ppc64_elf_unhandled_reloc, /* special_function */
 614          "R_PPC64_PLT32",       /* name */
 615          FALSE,                 /* partial_inplace */
 616          0,                     /* src_mask */
 617          0xffffffff,            /* dst_mask */
 618          FALSE),                /* pcrel_offset */
 619
 620   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 621      FIXME: R_PPC64_PLTREL32 not supported.  */
 622   HOWTO (R_PPC64_PLTREL32,      /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          TRUE,                  /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_signed, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_PLTREL32",    /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          TRUE),                 /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 637      the symbol.  */
 638   HOWTO (R_PPC64_PLT16_LO,      /* type */
 639          0,                     /* rightshift */
 640          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 641          16,                    /* bitsize */
 642          FALSE,                 /* pc_relative */
 643          0,                     /* bitpos */
 644          complain_overflow_dont, /* complain_on_overflow */
 645          ppc64_elf_unhandled_reloc, /* special_function */
 646          "R_PPC64_PLT16_LO",    /* name */
 647          FALSE,                 /* partial_inplace */
 648          0,                     /* src_mask */
 649          0xffff,                /* dst_mask */
 650          FALSE),                /* pcrel_offset */
 651
 652   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 653      the symbol.  */
 654   HOWTO (R_PPC64_PLT16_HI,      /* type */
 655          16,                    /* rightshift */
 656          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 657          16,                    /* bitsize */
 658          FALSE,                 /* pc_relative */
 659          0,                     /* bitpos */
 660          complain_overflow_dont, /* complain_on_overflow */
 661          ppc64_elf_unhandled_reloc, /* special_function */
 662          "R_PPC64_PLT16_HI",    /* name */
 663          FALSE,                 /* partial_inplace */
 664          0,                     /* src_mask */
 665          0xffff,                /* dst_mask */
 666          FALSE),                /* pcrel_offset */
 667
 668   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 669      the symbol.  */
 670   HOWTO (R_PPC64_PLT16_HA,      /* type */
 671          16,                    /* rightshift */
 672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 673          16,                    /* bitsize */
 674          FALSE,                 /* pc_relative */
 675          0,                     /* bitpos */
 676          complain_overflow_dont, /* complain_on_overflow */
 677          ppc64_elf_unhandled_reloc, /* special_function */
 678          "R_PPC64_PLT16_HA",    /* name */
 679          FALSE,                 /* partial_inplace */
 680          0,                     /* src_mask */
 681          0xffff,                /* dst_mask */
 682          FALSE),                /* pcrel_offset */
 683
 684   /* 16-bit section relative relocation.  */
 685   HOWTO (R_PPC64_SECTOFF,       /* type */
 686          0,                     /* rightshift */
 687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 688          16,                    /* bitsize */
 689          FALSE,                 /* pc_relative */
 690          0,                     /* bitpos */
 691          complain_overflow_bitfield, /* complain_on_overflow */
 692          ppc64_elf_sectoff_reloc, /* special_function */
 693          "R_PPC64_SECTOFF",     /* name */
 694          FALSE,                 /* partial_inplace */
 695          0,                     /* src_mask */
 696          0xffff,                /* dst_mask */
 697          FALSE),                /* pcrel_offset */
 698
 699   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 700   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 701          0,                     /* rightshift */
 702          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 703          16,                    /* bitsize */
 704          FALSE,                 /* pc_relative */
 705          0,                     /* bitpos */
 706          complain_overflow_dont, /* complain_on_overflow */
 707          ppc64_elf_sectoff_reloc, /* special_function */
 708          "R_PPC64_SECTOFF_LO",  /* name */
 709          FALSE,                 /* partial_inplace */
 710          0,                     /* src_mask */
 711          0xffff,                /* dst_mask */
 712          FALSE),                /* pcrel_offset */
 713
 714   /* 16-bit upper half section relative relocation.  */
 715   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_dont, /* complain_on_overflow */
 722          ppc64_elf_sectoff_reloc, /* special_function */
 723          "R_PPC64_SECTOFF_HI",  /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* 16-bit upper half adjusted section relative relocation.  */
 730   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 731          16,                    /* rightshift */
 732          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 733          16,                    /* bitsize */
 734          FALSE,                 /* pc_relative */
 735          0,                     /* bitpos */
 736          complain_overflow_dont, /* complain_on_overflow */
 737          ppc64_elf_sectoff_ha_reloc, /* special_function */
 738          "R_PPC64_SECTOFF_HA",  /* name */
 739          FALSE,                 /* partial_inplace */
 740          0,                     /* src_mask */
 741          0xffff,                /* dst_mask */
 742          FALSE),                /* pcrel_offset */
 743
 744   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 745   HOWTO (R_PPC64_REL30,         /* type */
 746          2,                     /* rightshift */
 747          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 748          30,                    /* bitsize */
 749          TRUE,                  /* pc_relative */
 750          0,                     /* bitpos */
 751          complain_overflow_dont, /* complain_on_overflow */
 752          bfd_elf_generic_reloc, /* special_function */
 753          "R_PPC64_REL30",       /* name */
 754          FALSE,                 /* partial_inplace */
 755          0,                     /* src_mask */
 756          0xfffffffc,            /* dst_mask */
 757          TRUE),                 /* pcrel_offset */
 758
 759   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 760
 761   /* A standard 64-bit relocation.  */
 762   HOWTO (R_PPC64_ADDR64,        /* type */
 763          0,                     /* rightshift */
 764          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 765          64,                    /* bitsize */
 766          FALSE,                 /* pc_relative */
 767          0,                     /* bitpos */
 768          complain_overflow_dont, /* complain_on_overflow */
 769          bfd_elf_generic_reloc, /* special_function */
 770          "R_PPC64_ADDR64",      /* name */
 771          FALSE,                 /* partial_inplace */
 772          0,                     /* src_mask */
 773          ONES (64),             /* dst_mask */
 774          FALSE),                /* pcrel_offset */
 775
 776   /* The bits 32-47 of an address.  */
 777   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 778          32,                    /* rightshift */
 779          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 780          16,                    /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_dont, /* complain_on_overflow */
 784          bfd_elf_generic_reloc, /* special_function */
 785          "R_PPC64_ADDR16_HIGHER", /* name */
 786          FALSE,                 /* partial_inplace */
 787          0,                     /* src_mask */
 788          0xffff,                /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790
 791   /* The bits 32-47 of an address, plus 1 if the contents of the low
 792      16 bits, treated as a signed number, is negative.  */
 793   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 794          32,                    /* rightshift */
 795          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 796          16,                    /* bitsize */
 797          FALSE,                 /* pc_relative */
 798          0,                     /* bitpos */
 799          complain_overflow_dont, /* complain_on_overflow */
 800          ppc64_elf_ha_reloc,    /* special_function */
 801          "R_PPC64_ADDR16_HIGHERA", /* name */
 802          FALSE,                 /* partial_inplace */
 803          0,                     /* src_mask */
 804          0xffff,                /* dst_mask */
 805          FALSE),                /* pcrel_offset */
 806
 807   /* The bits 48-63 of an address.  */
 808   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 809          48,                    /* rightshift */
 810          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 811          16,                    /* bitsize */
 812          FALSE,                 /* pc_relative */
 813          0,                     /* bitpos */
 814          complain_overflow_dont, /* complain_on_overflow */
 815          bfd_elf_generic_reloc, /* special_function */
 816          "R_PPC64_ADDR16_HIGHEST", /* name */
 817          FALSE,                 /* partial_inplace */
 818          0,                     /* src_mask */
 819          0xffff,                /* dst_mask */
 820          FALSE),                /* pcrel_offset */
 821
 822   /* The bits 48-63 of an address, plus 1 if the contents of the low
 823      16 bits, treated as a signed number, is negative.  */
 824   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 825          48,                    /* rightshift */
 826          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 827          16,                    /* bitsize */
 828          FALSE,                 /* pc_relative */
 829          0,                     /* bitpos */
 830          complain_overflow_dont, /* complain_on_overflow */
 831          ppc64_elf_ha_reloc,    /* special_function */
 832          "R_PPC64_ADDR16_HIGHESTA", /* name */
 833          FALSE,                 /* partial_inplace */
 834          0,                     /* src_mask */
 835          0xffff,                /* dst_mask */
 836          FALSE),                /* pcrel_offset */
 837
 838   /* Like ADDR64, but may be unaligned.  */
 839   HOWTO (R_PPC64_UADDR64,       /* type */
 840          0,                     /* rightshift */
 841          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 842          64,                    /* bitsize */
 843          FALSE,                 /* pc_relative */
 844          0,                     /* bitpos */
 845          complain_overflow_dont, /* complain_on_overflow */
 846          bfd_elf_generic_reloc, /* special_function */
 847          "R_PPC64_UADDR64",     /* name */
 848          FALSE,                 /* partial_inplace */
 849          0,                     /* src_mask */
 850          ONES (64),             /* dst_mask */
 851          FALSE),                /* pcrel_offset */
 852
 853   /* 64-bit relative relocation.  */
 854   HOWTO (R_PPC64_REL64,         /* type */
 855          0,                     /* rightshift */
 856          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 857          64,                    /* bitsize */
 858          TRUE,                  /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          bfd_elf_generic_reloc, /* special_function */
 862          "R_PPC64_REL64",       /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          ONES (64),             /* dst_mask */
 866          TRUE),                 /* pcrel_offset */
 867
 868   /* 64-bit relocation to the symbol's procedure linkage table.  */
 869   HOWTO (R_PPC64_PLT64,         /* type */
 870          0,                     /* rightshift */
 871          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 872          64,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          ppc64_elf_unhandled_reloc, /* special_function */
 877          "R_PPC64_PLT64",       /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          ONES (64),             /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* 64-bit PC relative relocation to the symbol's procedure linkage
 884      table.  */
 885   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 886   HOWTO (R_PPC64_PLTREL64,      /* type */
 887          0,                     /* rightshift */
 888          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 889          64,                    /* bitsize */
 890          TRUE,                  /* pc_relative */
 891          0,                     /* bitpos */
 892          complain_overflow_dont, /* complain_on_overflow */
 893          ppc64_elf_unhandled_reloc, /* special_function */
 894          "R_PPC64_PLTREL64",    /* name */
 895          FALSE,                 /* partial_inplace */
 896          0,                     /* src_mask */
 897          ONES (64),             /* dst_mask */
 898          TRUE),                 /* pcrel_offset */
 899
 900   /* 16 bit TOC-relative relocation.  */
 901
 902   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 903   HOWTO (R_PPC64_TOC16,         /* type */
 904          0,                     /* rightshift */
 905          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 906          16,                    /* bitsize */
 907          FALSE,                 /* pc_relative */
 908          0,                     /* bitpos */
 909          complain_overflow_signed, /* complain_on_overflow */
 910          ppc64_elf_toc_reloc,   /* special_function */
 911          "R_PPC64_TOC16",       /* name */
 912          FALSE,                 /* partial_inplace */
 913          0,                     /* src_mask */
 914          0xffff,                /* dst_mask */
 915          FALSE),                /* pcrel_offset */
 916
 917   /* 16 bit TOC-relative relocation without overflow.  */
 918
 919   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 920   HOWTO (R_PPC64_TOC16_LO,      /* type */
 921          0,                     /* rightshift */
 922          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 923          16,                    /* bitsize */
 924          FALSE,                 /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          ppc64_elf_toc_reloc,   /* special_function */
 928          "R_PPC64_TOC16_LO",    /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          0xffff,                /* dst_mask */
 932          FALSE),                /* pcrel_offset */
 933
 934   /* 16 bit TOC-relative relocation, high 16 bits.  */
 935
 936   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 937   HOWTO (R_PPC64_TOC16_HI,      /* type */
 938          16,                    /* rightshift */
 939          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 940          16,                    /* bitsize */
 941          FALSE,                 /* pc_relative */
 942          0,                     /* bitpos */
 943          complain_overflow_dont, /* complain_on_overflow */
 944          ppc64_elf_toc_reloc,   /* special_function */
 945          "R_PPC64_TOC16_HI",    /* name */
 946          FALSE,                 /* partial_inplace */
 947          0,                     /* src_mask */
 948          0xffff,                /* dst_mask */
 949          FALSE),                /* pcrel_offset */
 950
 951   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 952      contents of the low 16 bits, treated as a signed number, is
 953      negative.  */
 954
 955   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 956   HOWTO (R_PPC64_TOC16_HA,      /* type */
 957          16,                    /* rightshift */
 958          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 959          16,                    /* bitsize */
 960          FALSE,                 /* pc_relative */
 961          0,                     /* bitpos */
 962          complain_overflow_dont, /* complain_on_overflow */
 963          ppc64_elf_toc_ha_reloc, /* special_function */
 964          "R_PPC64_TOC16_HA",    /* name */
 965          FALSE,                 /* partial_inplace */
 966          0,                     /* src_mask */
 967          0xffff,                /* dst_mask */
 968          FALSE),                /* pcrel_offset */
 969
 970   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 971
 972   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 973   HOWTO (R_PPC64_TOC,           /* type */
 974          0,                     /* rightshift */
 975          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 976          64,                    /* bitsize */
 977          FALSE,                 /* pc_relative */
 978          0,                     /* bitpos */
 979          complain_overflow_bitfield, /* complain_on_overflow */
 980          ppc64_elf_toc64_reloc, /* special_function */
 981          "R_PPC64_TOC",         /* name */
 982          FALSE,                 /* partial_inplace */
 983          0,                     /* src_mask */
 984          ONES (64),             /* dst_mask */
 985          FALSE),                /* pcrel_offset */
 986
 987   /* Like R_PPC64_GOT16, but also informs the link editor that the
 988      value to relocate may (!) refer to a PLT entry which the link
 989      editor (a) may replace with the symbol value.  If the link editor
 990      is unable to fully resolve the symbol, it may (b) create a PLT
 991      entry and store the address to the new PLT entry in the GOT.
 992      This permits lazy resolution of function symbols at run time.
 993      The link editor may also skip all of this and just (c) emit a
 994      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
 995   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
 996     HOWTO (R_PPC64_PLTGOT16,    /* type */
 997          0,                     /* rightshift */
 998          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 999          16,                    /* bitsize */
1000          FALSE,                 /* pc_relative */
1001          0,                     /* bitpos */
1002          complain_overflow_signed, /* complain_on_overflow */
1003          ppc64_elf_unhandled_reloc, /* special_function */
1004          "R_PPC64_PLTGOT16",    /* name */
1005          FALSE,                 /* partial_inplace */
1006          0,                     /* src_mask */
1007          0xffff,                /* dst_mask */
1008          FALSE),                /* pcrel_offset */
1009
1010   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1011   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1012   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1013          0,                     /* rightshift */
1014          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1015          16,                    /* bitsize */
1016          FALSE,                 /* pc_relative */
1017          0,                     /* bitpos */
1018          complain_overflow_dont, /* complain_on_overflow */
1019          ppc64_elf_unhandled_reloc, /* special_function */
1020          "R_PPC64_PLTGOT16_LO", /* name */
1021          FALSE,                 /* partial_inplace */
1022          0,                     /* src_mask */
1023          0xffff,                /* dst_mask */
1024          FALSE),                /* pcrel_offset */
1025
1026   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1027   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1028   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1029          16,                    /* rightshift */
1030          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1031          16,                    /* bitsize */
1032          FALSE,                 /* pc_relative */
1033          0,                     /* bitpos */
1034          complain_overflow_dont, /* complain_on_overflow */
1035          ppc64_elf_unhandled_reloc, /* special_function */
1036          "R_PPC64_PLTGOT16_HI", /* name */
1037          FALSE,                 /* partial_inplace */
1038          0,                     /* src_mask */
1039          0xffff,                /* dst_mask */
1040          FALSE),                /* pcrel_offset */
1041
1042   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1043      1 if the contents of the low 16 bits, treated as a signed number,
1044      is negative.  */
1045   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1046   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1047          16,                    /* rightshift */
1048          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1049          16,                    /* bitsize */
1050          FALSE,                 /* pc_relative */
1051          0,                     /* bitpos */
1052          complain_overflow_dont,/* complain_on_overflow */
1053          ppc64_elf_unhandled_reloc, /* special_function */
1054          "R_PPC64_PLTGOT16_HA", /* name */
1055          FALSE,                 /* partial_inplace */
1056          0,                     /* src_mask */
1057          0xffff,                /* dst_mask */
1058          FALSE),                /* pcrel_offset */
1059
1060   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1061   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1062          0,                     /* rightshift */
1063          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          16,                    /* bitsize */
1065          FALSE,                 /* pc_relative */
1066          0,                     /* bitpos */
1067          complain_overflow_bitfield, /* complain_on_overflow */
1068          bfd_elf_generic_reloc, /* special_function */
1069          "R_PPC64_ADDR16_DS",   /* name */
1070          FALSE,                 /* partial_inplace */
1071          0,                     /* src_mask */
1072          0xfffc,                /* dst_mask */
1073          FALSE),                /* pcrel_offset */
1074
1075   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1076   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1077          0,                     /* rightshift */
1078          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1079          16,                    /* bitsize */
1080          FALSE,                 /* pc_relative */
1081          0,                     /* bitpos */
1082          complain_overflow_dont,/* complain_on_overflow */
1083          bfd_elf_generic_reloc, /* special_function */
1084          "R_PPC64_ADDR16_LO_DS",/* name */
1085          FALSE,                 /* partial_inplace */
1086          0,                     /* src_mask */
1087          0xfffc,                /* dst_mask */
1088          FALSE),                /* pcrel_offset */
1089
1090   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1091   HOWTO (R_PPC64_GOT16_DS,      /* type */
1092          0,                     /* rightshift */
1093          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1094          16,                    /* bitsize */
1095          FALSE,                 /* pc_relative */
1096          0,                     /* bitpos */
1097          complain_overflow_signed, /* complain_on_overflow */
1098          ppc64_elf_unhandled_reloc, /* special_function */
1099          "R_PPC64_GOT16_DS",    /* name */
1100          FALSE,                 /* partial_inplace */
1101          0,                     /* src_mask */
1102          0xfffc,                /* dst_mask */
1103          FALSE),                /* pcrel_offset */
1104
1105   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1106   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1107          0,                     /* rightshift */
1108          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1109          16,                    /* bitsize */
1110          FALSE,                 /* pc_relative */
1111          0,                     /* bitpos */
1112          complain_overflow_dont, /* complain_on_overflow */
1113          ppc64_elf_unhandled_reloc, /* special_function */
1114          "R_PPC64_GOT16_LO_DS", /* name */
1115          FALSE,                 /* partial_inplace */
1116          0,                     /* src_mask */
1117          0xfffc,                /* dst_mask */
1118          FALSE),                /* pcrel_offset */
1119
1120   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1121   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1122          0,                     /* rightshift */
1123          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1124          16,                    /* bitsize */
1125          FALSE,                 /* pc_relative */
1126          0,                     /* bitpos */
1127          complain_overflow_dont, /* complain_on_overflow */
1128          ppc64_elf_unhandled_reloc, /* special_function */
1129          "R_PPC64_PLT16_LO_DS", /* name */
1130          FALSE,                 /* partial_inplace */
1131          0,                     /* src_mask */
1132          0xfffc,                /* dst_mask */
1133          FALSE),                /* pcrel_offset */
1134
1135   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1136   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1137          0,                     /* rightshift */
1138          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1139          16,                    /* bitsize */
1140          FALSE,                 /* pc_relative */
1141          0,                     /* bitpos */
1142          complain_overflow_bitfield, /* complain_on_overflow */
1143          ppc64_elf_sectoff_reloc, /* special_function */
1144          "R_PPC64_SECTOFF_DS",  /* name */
1145          FALSE,                 /* partial_inplace */
1146          0,                     /* src_mask */
1147          0xfffc,                /* dst_mask */
1148          FALSE),                /* pcrel_offset */
1149
1150   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1151   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1152          0,                     /* rightshift */
1153          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1154          16,                    /* bitsize */
1155          FALSE,                 /* pc_relative */
1156          0,                     /* bitpos */
1157          complain_overflow_dont, /* complain_on_overflow */
1158          ppc64_elf_sectoff_reloc, /* special_function */
1159          "R_PPC64_SECTOFF_LO_DS",/* name */
1160          FALSE,                 /* partial_inplace */
1161          0,                     /* src_mask */
1162          0xfffc,                /* dst_mask */
1163          FALSE),                /* pcrel_offset */
1164
1165   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1166   HOWTO (R_PPC64_TOC16_DS,      /* type */
1167          0,                     /* rightshift */
1168          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1169          16,                    /* bitsize */
1170          FALSE,                 /* pc_relative */
1171          0,                     /* bitpos */
1172          complain_overflow_signed, /* complain_on_overflow */
1173          ppc64_elf_toc_reloc,   /* special_function */
1174          "R_PPC64_TOC16_DS",    /* name */
1175          FALSE,                 /* partial_inplace */
1176          0,                     /* src_mask */
1177          0xfffc,                /* dst_mask */
1178          FALSE),                /* pcrel_offset */
1179
1180   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1181   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1182          0,                     /* rightshift */
1183          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1184          16,                    /* bitsize */
1185          FALSE,                 /* pc_relative */
1186          0,                     /* bitpos */
1187          complain_overflow_dont, /* complain_on_overflow */
1188          ppc64_elf_toc_reloc,   /* special_function */
1189          "R_PPC64_TOC16_LO_DS", /* name */
1190          FALSE,                 /* partial_inplace */
1191          0,                     /* src_mask */
1192          0xfffc,                /* dst_mask */
1193          FALSE),                /* pcrel_offset */
1194
1195   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1196   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1197     HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_unhandled_reloc, /* special_function */
1205          "R_PPC64_PLTGOT16_DS", /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1212   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1213   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1214          0,                     /* rightshift */
1215          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1216          16,                    /* bitsize */
1217          FALSE,                 /* pc_relative */
1218          0,                     /* bitpos */
1219          complain_overflow_dont, /* complain_on_overflow */
1220          ppc64_elf_unhandled_reloc, /* special_function */
1221          "R_PPC64_PLTGOT16_LO_DS",/* name */
1222          FALSE,                 /* partial_inplace */
1223          0,                     /* src_mask */
1224          0xfffc,                /* dst_mask */
1225          FALSE),                /* pcrel_offset */
1226
1227   /* Marker reloc for TLS.  */
1228   HOWTO (R_PPC64_TLS,
1229          0,                     /* rightshift */
1230          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1231          32,                    /* bitsize */
1232          FALSE,                 /* pc_relative */
1233          0,                     /* bitpos */
1234          complain_overflow_dont, /* complain_on_overflow */
1235          bfd_elf_generic_reloc, /* special_function */
1236          "R_PPC64_TLS",         /* name */
1237          FALSE,                 /* partial_inplace */
1238          0,                     /* src_mask */
1239          0,                     /* dst_mask */
1240          FALSE),                /* pcrel_offset */
1241
1242   /* Computes the load module index of the load module that contains the
1243      definition of its TLS sym.  */
1244   HOWTO (R_PPC64_DTPMOD64,
1245          0,                     /* rightshift */
1246          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1247          64,                    /* bitsize */
1248          FALSE,                 /* pc_relative */
1249          0,                     /* bitpos */
1250          complain_overflow_dont, /* complain_on_overflow */
1251          ppc64_elf_unhandled_reloc, /* special_function */
1252          "R_PPC64_DTPMOD64",    /* name */
1253          FALSE,                 /* partial_inplace */
1254          0,                     /* src_mask */
1255          ONES (64),             /* dst_mask */
1256          FALSE),                /* pcrel_offset */
1257
1258   /* Computes a dtv-relative displacement, the difference between the value
1259      of sym+add and the base address of the thread-local storage block that
1260      contains the definition of sym, minus 0x8000.  */
1261   HOWTO (R_PPC64_DTPREL64,
1262          0,                     /* rightshift */
1263          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1264          64,                    /* bitsize */
1265          FALSE,                 /* pc_relative */
1266          0,                     /* bitpos */
1267          complain_overflow_dont, /* complain_on_overflow */
1268          ppc64_elf_unhandled_reloc, /* special_function */
1269          "R_PPC64_DTPREL64",    /* name */
1270          FALSE,                 /* partial_inplace */
1271          0,                     /* src_mask */
1272          ONES (64),             /* dst_mask */
1273          FALSE),                /* pcrel_offset */
1274
1275   /* A 16 bit dtprel reloc.  */
1276   HOWTO (R_PPC64_DTPREL16,
1277          0,                     /* rightshift */
1278          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1279          16,                    /* bitsize */
1280          FALSE,                 /* pc_relative */
1281          0,                     /* bitpos */
1282          complain_overflow_signed, /* complain_on_overflow */
1283          ppc64_elf_unhandled_reloc, /* special_function */
1284          "R_PPC64_DTPREL16",    /* name */
1285          FALSE,                 /* partial_inplace */
1286          0,                     /* src_mask */
1287          0xffff,                /* dst_mask */
1288          FALSE),                /* pcrel_offset */
1289
1290   /* Like DTPREL16, but no overflow.  */
1291   HOWTO (R_PPC64_DTPREL16_LO,
1292          0,                     /* rightshift */
1293          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1294          16,                    /* bitsize */
1295          FALSE,                 /* pc_relative */
1296          0,                     /* bitpos */
1297          complain_overflow_dont, /* complain_on_overflow */
1298          ppc64_elf_unhandled_reloc, /* special_function */
1299          "R_PPC64_DTPREL16_LO", /* name */
1300          FALSE,                 /* partial_inplace */
1301          0,                     /* src_mask */
1302          0xffff,                /* dst_mask */
1303          FALSE),                /* pcrel_offset */
1304
1305   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1306   HOWTO (R_PPC64_DTPREL16_HI,
1307          16,                    /* rightshift */
1308          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1309          16,                    /* bitsize */
1310          FALSE,                 /* pc_relative */
1311          0,                     /* bitpos */
1312          complain_overflow_dont, /* complain_on_overflow */
1313          ppc64_elf_unhandled_reloc, /* special_function */
1314          "R_PPC64_DTPREL16_HI", /* name */
1315          FALSE,                 /* partial_inplace */
1316          0,                     /* src_mask */
1317          0xffff,                /* dst_mask */
1318          FALSE),                /* pcrel_offset */
1319
1320   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1321   HOWTO (R_PPC64_DTPREL16_HA,
1322          16,                    /* rightshift */
1323          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1324          16,                    /* bitsize */
1325          FALSE,                 /* pc_relative */
1326          0,                     /* bitpos */
1327          complain_overflow_dont, /* complain_on_overflow */
1328          ppc64_elf_unhandled_reloc, /* special_function */
1329          "R_PPC64_DTPREL16_HA", /* name */
1330          FALSE,                 /* partial_inplace */
1331          0,                     /* src_mask */
1332          0xffff,                /* dst_mask */
1333          FALSE),                /* pcrel_offset */
1334
1335   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1336   HOWTO (R_PPC64_DTPREL16_HIGHER,
1337          32,                    /* rightshift */
1338          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1339          16,                    /* bitsize */
1340          FALSE,                 /* pc_relative */
1341          0,                     /* bitpos */
1342          complain_overflow_dont, /* complain_on_overflow */
1343          ppc64_elf_unhandled_reloc, /* special_function */
1344          "R_PPC64_DTPREL16_HIGHER", /* name */
1345          FALSE,                 /* partial_inplace */
1346          0,                     /* src_mask */
1347          0xffff,                /* dst_mask */
1348          FALSE),                /* pcrel_offset */
1349
1350   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1351   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1352          32,                    /* rightshift */
1353          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1354          16,                    /* bitsize */
1355          FALSE,                 /* pc_relative */
1356          0,                     /* bitpos */
1357          complain_overflow_dont, /* complain_on_overflow */
1358          ppc64_elf_unhandled_reloc, /* special_function */
1359          "R_PPC64_DTPREL16_HIGHERA", /* name */
1360          FALSE,                 /* partial_inplace */
1361          0,                     /* src_mask */
1362          0xffff,                /* dst_mask */
1363          FALSE),                /* pcrel_offset */
1364
1365   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1366   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1367          48,                    /* rightshift */
1368          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1369          16,                    /* bitsize */
1370          FALSE,                 /* pc_relative */
1371          0,                     /* bitpos */
1372          complain_overflow_dont, /* complain_on_overflow */
1373          ppc64_elf_unhandled_reloc, /* special_function */
1374          "R_PPC64_DTPREL16_HIGHEST", /* name */
1375          FALSE,                 /* partial_inplace */
1376          0,                     /* src_mask */
1377          0xffff,                /* dst_mask */
1378          FALSE),                /* pcrel_offset */
1379
1380   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1381   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1382          48,                    /* rightshift */
1383          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1384          16,                    /* bitsize */
1385          FALSE,                 /* pc_relative */
1386          0,                     /* bitpos */
1387          complain_overflow_dont, /* complain_on_overflow */
1388          ppc64_elf_unhandled_reloc, /* special_function */
1389          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1390          FALSE,                 /* partial_inplace */
1391          0,                     /* src_mask */
1392          0xffff,                /* dst_mask */
1393          FALSE),                /* pcrel_offset */
1394
1395   /* Like DTPREL16, but for insns with a DS field.  */
1396   HOWTO (R_PPC64_DTPREL16_DS,
1397          0,                     /* rightshift */
1398          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1399          16,                    /* bitsize */
1400          FALSE,                 /* pc_relative */
1401          0,                     /* bitpos */
1402          complain_overflow_signed, /* complain_on_overflow */
1403          ppc64_elf_unhandled_reloc, /* special_function */
1404          "R_PPC64_DTPREL16_DS", /* name */
1405          FALSE,                 /* partial_inplace */
1406          0,                     /* src_mask */
1407          0xfffc,                /* dst_mask */
1408          FALSE),                /* pcrel_offset */
1409
1410   /* Like DTPREL16_DS, but no overflow.  */
1411   HOWTO (R_PPC64_DTPREL16_LO_DS,
1412          0,                     /* rightshift */
1413          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1414          16,                    /* bitsize */
1415          FALSE,                 /* pc_relative */
1416          0,                     /* bitpos */
1417          complain_overflow_dont, /* complain_on_overflow */
1418          ppc64_elf_unhandled_reloc, /* special_function */
1419          "R_PPC64_DTPREL16_LO_DS", /* name */
1420          FALSE,                 /* partial_inplace */
1421          0,                     /* src_mask */
1422          0xfffc,                /* dst_mask */
1423          FALSE),                /* pcrel_offset */
1424
1425   /* Computes a tp-relative displacement, the difference between the value of
1426      sym+add and the value of the thread pointer (r13).  */
1427   HOWTO (R_PPC64_TPREL64,
1428          0,                     /* rightshift */
1429          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1430          64,                    /* bitsize */
1431          FALSE,                 /* pc_relative */
1432          0,                     /* bitpos */
1433          complain_overflow_dont, /* complain_on_overflow */
1434          ppc64_elf_unhandled_reloc, /* special_function */
1435          "R_PPC64_TPREL64",     /* name */
1436          FALSE,                 /* partial_inplace */
1437          0,                     /* src_mask */
1438          ONES (64),             /* dst_mask */
1439          FALSE),                /* pcrel_offset */
1440
1441   /* A 16 bit tprel reloc.  */
1442   HOWTO (R_PPC64_TPREL16,
1443          0,                     /* rightshift */
1444          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1445          16,                    /* bitsize */
1446          FALSE,                 /* pc_relative */
1447          0,                     /* bitpos */
1448          complain_overflow_signed, /* complain_on_overflow */
1449          ppc64_elf_unhandled_reloc, /* special_function */
1450          "R_PPC64_TPREL16",     /* name */
1451          FALSE,                 /* partial_inplace */
1452          0,                     /* src_mask */
1453          0xffff,                /* dst_mask */
1454          FALSE),                /* pcrel_offset */
1455
1456   /* Like TPREL16, but no overflow.  */
1457   HOWTO (R_PPC64_TPREL16_LO,
1458          0,                     /* rightshift */
1459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1460          16,                    /* bitsize */
1461          FALSE,                 /* pc_relative */
1462          0,                     /* bitpos */
1463          complain_overflow_dont, /* complain_on_overflow */
1464          ppc64_elf_unhandled_reloc, /* special_function */
1465          "R_PPC64_TPREL16_LO",  /* name */
1466          FALSE,                 /* partial_inplace */
1467          0,                     /* src_mask */
1468          0xffff,                /* dst_mask */
1469          FALSE),                /* pcrel_offset */
1470
1471   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1472   HOWTO (R_PPC64_TPREL16_HI,
1473          16,                    /* rightshift */
1474          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1475          16,                    /* bitsize */
1476          FALSE,                 /* pc_relative */
1477          0,                     /* bitpos */
1478          complain_overflow_dont, /* complain_on_overflow */
1479          ppc64_elf_unhandled_reloc, /* special_function */
1480          "R_PPC64_TPREL16_HI",  /* name */
1481          FALSE,                 /* partial_inplace */
1482          0,                     /* src_mask */
1483          0xffff,                /* dst_mask */
1484          FALSE),                /* pcrel_offset */
1485
1486   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1487   HOWTO (R_PPC64_TPREL16_HA,
1488          16,                    /* rightshift */
1489          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1490          16,                    /* bitsize */
1491          FALSE,                 /* pc_relative */
1492          0,                     /* bitpos */
1493          complain_overflow_dont, /* complain_on_overflow */
1494          ppc64_elf_unhandled_reloc, /* special_function */
1495          "R_PPC64_TPREL16_HA",  /* name */
1496          FALSE,                 /* partial_inplace */
1497          0,                     /* src_mask */
1498          0xffff,                /* dst_mask */
1499          FALSE),                /* pcrel_offset */
1500
1501   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1502   HOWTO (R_PPC64_TPREL16_HIGHER,
1503          32,                    /* rightshift */
1504          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1505          16,                    /* bitsize */
1506          FALSE,                 /* pc_relative */
1507          0,                     /* bitpos */
1508          complain_overflow_dont, /* complain_on_overflow */
1509          ppc64_elf_unhandled_reloc, /* special_function */
1510          "R_PPC64_TPREL16_HIGHER",      /* name */
1511          FALSE,                 /* partial_inplace */
1512          0,                     /* src_mask */
1513          0xffff,                /* dst_mask */
1514          FALSE),                /* pcrel_offset */
1515
1516   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1517   HOWTO (R_PPC64_TPREL16_HIGHERA,
1518          32,                    /* rightshift */
1519          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1520          16,                    /* bitsize */
1521          FALSE,                 /* pc_relative */
1522          0,                     /* bitpos */
1523          complain_overflow_dont, /* complain_on_overflow */
1524          ppc64_elf_unhandled_reloc, /* special_function */
1525          "R_PPC64_TPREL16_HIGHERA", /* name */
1526          FALSE,                 /* partial_inplace */
1527          0,                     /* src_mask */
1528          0xffff,                /* dst_mask */
1529          FALSE),                /* pcrel_offset */
1530
1531   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1532   HOWTO (R_PPC64_TPREL16_HIGHEST,
1533          48,                    /* rightshift */
1534          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1535          16,                    /* bitsize */
1536          FALSE,                 /* pc_relative */
1537          0,                     /* bitpos */
1538          complain_overflow_dont, /* complain_on_overflow */
1539          ppc64_elf_unhandled_reloc, /* special_function */
1540          "R_PPC64_TPREL16_HIGHEST", /* name */
1541          FALSE,                 /* partial_inplace */
1542          0,                     /* src_mask */
1543          0xffff,                /* dst_mask */
1544          FALSE),                /* pcrel_offset */
1545
1546   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1547   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1548          48,                    /* rightshift */
1549          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1550          16,                    /* bitsize */
1551          FALSE,                 /* pc_relative */
1552          0,                     /* bitpos */
1553          complain_overflow_dont, /* complain_on_overflow */
1554          ppc64_elf_unhandled_reloc, /* special_function */
1555          "R_PPC64_TPREL16_HIGHESTA", /* name */
1556          FALSE,                 /* partial_inplace */
1557          0,                     /* src_mask */
1558          0xffff,                /* dst_mask */
1559          FALSE),                /* pcrel_offset */
1560
1561   /* Like TPREL16, but for insns with a DS field.  */
1562   HOWTO (R_PPC64_TPREL16_DS,
1563          0,                     /* rightshift */
1564          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1565          16,                    /* bitsize */
1566          FALSE,                 /* pc_relative */
1567          0,                     /* bitpos */
1568          complain_overflow_signed, /* complain_on_overflow */
1569          ppc64_elf_unhandled_reloc, /* special_function */
1570          "R_PPC64_TPREL16_DS",  /* name */
1571          FALSE,                 /* partial_inplace */
1572          0,                     /* src_mask */
1573          0xfffc,                /* dst_mask */
1574          FALSE),                /* pcrel_offset */
1575
1576   /* Like TPREL16_DS, but no overflow.  */
1577   HOWTO (R_PPC64_TPREL16_LO_DS,
1578          0,                     /* rightshift */
1579          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1580          16,                    /* bitsize */
1581          FALSE,                 /* pc_relative */
1582          0,                     /* bitpos */
1583          complain_overflow_dont, /* complain_on_overflow */
1584          ppc64_elf_unhandled_reloc, /* special_function */
1585          "R_PPC64_TPREL16_LO_DS", /* name */
1586          FALSE,                 /* partial_inplace */
1587          0,                     /* src_mask */
1588          0xfffc,                /* dst_mask */
1589          FALSE),                /* pcrel_offset */
1590
1591   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1592      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1593      to the first entry relative to the TOC base (r2).  */
1594   HOWTO (R_PPC64_GOT_TLSGD16,
1595          0,                     /* rightshift */
1596          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1597          16,                    /* bitsize */
1598          FALSE,                 /* pc_relative */
1599          0,                     /* bitpos */
1600          complain_overflow_signed, /* complain_on_overflow */
1601          ppc64_elf_unhandled_reloc, /* special_function */
1602          "R_PPC64_GOT_TLSGD16", /* name */
1603          FALSE,                 /* partial_inplace */
1604          0,                     /* src_mask */
1605          0xffff,                /* dst_mask */
1606          FALSE),                /* pcrel_offset */
1607
1608   /* Like GOT_TLSGD16, but no overflow.  */
1609   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1610          0,                     /* rightshift */
1611          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1612          16,                    /* bitsize */
1613          FALSE,                 /* pc_relative */
1614          0,                     /* bitpos */
1615          complain_overflow_dont, /* complain_on_overflow */
1616          ppc64_elf_unhandled_reloc, /* special_function */
1617          "R_PPC64_GOT_TLSGD16_LO", /* name */
1618          FALSE,                 /* partial_inplace */
1619          0,                     /* src_mask */
1620          0xffff,                /* dst_mask */
1621          FALSE),                /* pcrel_offset */
1622
1623   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1624   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1625          16,                    /* rightshift */
1626          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1627          16,                    /* bitsize */
1628          FALSE,                 /* pc_relative */
1629          0,                     /* bitpos */
1630          complain_overflow_dont, /* complain_on_overflow */
1631          ppc64_elf_unhandled_reloc, /* special_function */
1632          "R_PPC64_GOT_TLSGD16_HI", /* name */
1633          FALSE,                 /* partial_inplace */
1634          0,                     /* src_mask */
1635          0xffff,                /* dst_mask */
1636          FALSE),                /* pcrel_offset */
1637
1638   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1639   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1640          16,                    /* rightshift */
1641          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1642          16,                    /* bitsize */
1643          FALSE,                 /* pc_relative */
1644          0,                     /* bitpos */
1645          complain_overflow_dont, /* complain_on_overflow */
1646          ppc64_elf_unhandled_reloc, /* special_function */
1647          "R_PPC64_GOT_TLSGD16_HA", /* name */
1648          FALSE,                 /* partial_inplace */
1649          0,                     /* src_mask */
1650          0xffff,                /* dst_mask */
1651          FALSE),                /* pcrel_offset */
1652
1653   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1654      with values (sym+add)@dtpmod and zero, and computes the offset to the
1655      first entry relative to the TOC base (r2).  */
1656   HOWTO (R_PPC64_GOT_TLSLD16,
1657          0,                     /* rightshift */
1658          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1659          16,                    /* bitsize */
1660          FALSE,                 /* pc_relative */
1661          0,                     /* bitpos */
1662          complain_overflow_signed, /* complain_on_overflow */
1663          ppc64_elf_unhandled_reloc, /* special_function */
1664          "R_PPC64_GOT_TLSLD16", /* name */
1665          FALSE,                 /* partial_inplace */
1666          0,                     /* src_mask */
1667          0xffff,                /* dst_mask */
1668          FALSE),                /* pcrel_offset */
1669
1670   /* Like GOT_TLSLD16, but no overflow.  */
1671   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1672          0,                     /* rightshift */
1673          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1674          16,                    /* bitsize */
1675          FALSE,                 /* pc_relative */
1676          0,                     /* bitpos */
1677          complain_overflow_dont, /* complain_on_overflow */
1678          ppc64_elf_unhandled_reloc, /* special_function */
1679          "R_PPC64_GOT_TLSLD16_LO", /* name */
1680          FALSE,                 /* partial_inplace */
1681          0,                     /* src_mask */
1682          0xffff,                /* dst_mask */
1683          FALSE),                /* pcrel_offset */
1684
1685   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1686   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1687          16,                    /* rightshift */
1688          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1689          16,                    /* bitsize */
1690          FALSE,                 /* pc_relative */
1691          0,                     /* bitpos */
1692          complain_overflow_dont, /* complain_on_overflow */
1693          ppc64_elf_unhandled_reloc, /* special_function */
1694          "R_PPC64_GOT_TLSLD16_HI", /* name */
1695          FALSE,                 /* partial_inplace */
1696          0,                     /* src_mask */
1697          0xffff,                /* dst_mask */
1698          FALSE),                /* pcrel_offset */
1699
1700   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1701   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1702          16,                    /* rightshift */
1703          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1704          16,                    /* bitsize */
1705          FALSE,                 /* pc_relative */
1706          0,                     /* bitpos */
1707          complain_overflow_dont, /* complain_on_overflow */
1708          ppc64_elf_unhandled_reloc, /* special_function */
1709          "R_PPC64_GOT_TLSLD16_HA", /* name */
1710          FALSE,                 /* partial_inplace */
1711          0,                     /* src_mask */
1712          0xffff,                /* dst_mask */
1713          FALSE),                /* pcrel_offset */
1714
1715   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1716      the offset to the entry relative to the TOC base (r2).  */
1717   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1718          0,                     /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_signed, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_DTPREL16_DS", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xfffc,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_DTPREL16_DS, but no overflow.  */
1732   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1733          0,                     /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_dont, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xfffc,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1747   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1748          16,                    /* rightshift */
1749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1750          16,                    /* bitsize */
1751          FALSE,                 /* pc_relative */
1752          0,                     /* bitpos */
1753          complain_overflow_dont, /* complain_on_overflow */
1754          ppc64_elf_unhandled_reloc, /* special_function */
1755          "R_PPC64_GOT_DTPREL16_HI", /* name */
1756          FALSE,                 /* partial_inplace */
1757          0,                     /* src_mask */
1758          0xffff,                /* dst_mask */
1759          FALSE),                /* pcrel_offset */
1760
1761   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1762   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1763          16,                    /* rightshift */
1764          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1765          16,                    /* bitsize */
1766          FALSE,                 /* pc_relative */
1767          0,                     /* bitpos */
1768          complain_overflow_dont, /* complain_on_overflow */
1769          ppc64_elf_unhandled_reloc, /* special_function */
1770          "R_PPC64_GOT_DTPREL16_HA", /* name */
1771          FALSE,                 /* partial_inplace */
1772          0,                     /* src_mask */
1773          0xffff,                /* dst_mask */
1774          FALSE),                /* pcrel_offset */
1775
1776   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1777      offset to the entry relative to the TOC base (r2).  */
1778   HOWTO (R_PPC64_GOT_TPREL16_DS,
1779          0,                     /* rightshift */
1780          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1781          16,                    /* bitsize */
1782          FALSE,                 /* pc_relative */
1783          0,                     /* bitpos */
1784          complain_overflow_signed, /* complain_on_overflow */
1785          ppc64_elf_unhandled_reloc, /* special_function */
1786          "R_PPC64_GOT_TPREL16_DS", /* name */
1787          FALSE,                 /* partial_inplace */
1788          0,                     /* src_mask */
1789          0xfffc,                /* dst_mask */
1790          FALSE),                /* pcrel_offset */
1791
1792   /* Like GOT_TPREL16_DS, but no overflow.  */
1793   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1794          0,                     /* rightshift */
1795          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1796          16,                    /* bitsize */
1797          FALSE,                 /* pc_relative */
1798          0,                     /* bitpos */
1799          complain_overflow_dont, /* complain_on_overflow */
1800          ppc64_elf_unhandled_reloc, /* special_function */
1801          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1802          FALSE,                 /* partial_inplace */
1803          0,                     /* src_mask */
1804          0xfffc,                /* dst_mask */
1805          FALSE),                /* pcrel_offset */
1806
1807   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1808   HOWTO (R_PPC64_GOT_TPREL16_HI,
1809          16,                    /* rightshift */
1810          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1811          16,                    /* bitsize */
1812          FALSE,                 /* pc_relative */
1813          0,                     /* bitpos */
1814          complain_overflow_dont, /* complain_on_overflow */
1815          ppc64_elf_unhandled_reloc, /* special_function */
1816          "R_PPC64_GOT_TPREL16_HI", /* name */
1817          FALSE,                 /* partial_inplace */
1818          0,                     /* src_mask */
1819          0xffff,                /* dst_mask */
1820          FALSE),                /* pcrel_offset */
1821
1822   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1823   HOWTO (R_PPC64_GOT_TPREL16_HA,
1824          16,                    /* rightshift */
1825          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1826          16,                    /* bitsize */
1827          FALSE,                 /* pc_relative */
1828          0,                     /* bitpos */
1829          complain_overflow_dont, /* complain_on_overflow */
1830          ppc64_elf_unhandled_reloc, /* special_function */
1831          "R_PPC64_GOT_TPREL16_HA", /* name */
1832          FALSE,                 /* partial_inplace */
1833          0,                     /* src_mask */
1834          0xffff,                /* dst_mask */
1835          FALSE),                /* pcrel_offset */
1836
1837   /* GNU extension to record C++ vtable hierarchy.  */
1838   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1839          0,                     /* rightshift */
1840          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1841          0,                     /* bitsize */
1842          FALSE,                 /* pc_relative */
1843          0,                     /* bitpos */
1844          complain_overflow_dont, /* complain_on_overflow */
1845          NULL,                  /* special_function */
1846          "R_PPC64_GNU_VTINHERIT", /* name */
1847          FALSE,                 /* partial_inplace */
1848          0,                     /* src_mask */
1849          0,                     /* dst_mask */
1850          FALSE),                /* pcrel_offset */
1851
1852   /* GNU extension to record C++ vtable member usage.  */
1853   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1854          0,                     /* rightshift */
1855          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1856          0,                     /* bitsize */
1857          FALSE,                 /* pc_relative */
1858          0,                     /* bitpos */
1859          complain_overflow_dont, /* complain_on_overflow */
1860          NULL,                  /* special_function */
1861          "R_PPC64_GNU_VTENTRY", /* name */
1862          FALSE,                 /* partial_inplace */
1863          0,                     /* src_mask */
1864          0,                     /* dst_mask */
1865          FALSE),                /* pcrel_offset */
1866 };
1867
1868 \f
1869 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1870    be done.  */
1871
1872 static void
1873 ppc_howto_init (void)
1874 {
1875   unsigned int i, type;
1876
1877   for (i = 0;
1878        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1879        i++)
1880     {
1881       type = ppc64_elf_howto_raw[i].type;
1882       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1883                           / sizeof (ppc64_elf_howto_table[0])));
1884       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1885     }
1886 }
1887
1888 static reloc_howto_type *
1889 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1890                              bfd_reloc_code_real_type code)
1891 {
1892   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1893
1894   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1895     /* Initialize howto table if needed.  */
1896     ppc_howto_init ();
1897
1898   switch (code)
1899     {
1900     default:
1901       return NULL;
1902
1903     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
1904       break;
1905     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
1906       break;
1907     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
1908       break;
1909     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
1910       break;
1911     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
1912       break;
1913     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
1914       break;
1915     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
1916       break;
1917     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
1918       break;
1919     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
1920       break;
1921     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
1922       break;
1923     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
1924       break;
1925     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
1926       break;
1927     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
1928       break;
1929     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
1930       break;
1931     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
1932       break;
1933     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
1934       break;
1935     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
1936       break;
1937     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
1938       break;
1939     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
1940       break;
1941     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
1942       break;
1943     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
1944       break;
1945     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
1946       break;
1947     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
1948       break;
1949     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
1950       break;
1951     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
1952       break;
1953     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
1954       break;
1955     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
1956       break;
1957     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
1958       break;
1959     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
1960       break;
1961     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
1962       break;
1963     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
1964       break;
1965     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
1966       break;
1967     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
1968       break;
1969     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
1970       break;
1971     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
1972       break;
1973     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
1974       break;
1975     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
1976       break;
1977     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
1978       break;
1979     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
1980       break;
1981     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
1982       break;
1983     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
1984       break;
1985     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
1986       break;
1987     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
1988       break;
1989     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
1990       break;
1991     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
1992       break;
1993     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
1994       break;
1995     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
1996       break;
1997     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
1998       break;
1999     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2000       break;
2001     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2002       break;
2003     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2004       break;
2005     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2006       break;
2007     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2008       break;
2009     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2010       break;
2011     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2012       break;
2013     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2014       break;
2015     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2016       break;
2017     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2018       break;
2019     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2020       break;
2021     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2022       break;
2023     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2024       break;
2025     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2026       break;
2027     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2028       break;
2029     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2030       break;
2031     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2032       break;
2033     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2034       break;
2035     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2036       break;
2037     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2038       break;
2039     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2040       break;
2041     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2042       break;
2043     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2044       break;
2045     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2046       break;
2047     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2048       break;
2049     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2050       break;
2051     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2052       break;
2053     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2054       break;
2055     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2056       break;
2057     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2058       break;
2059     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2060       break;
2061     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2062       break;
2063     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2064       break;
2065     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2066       break;
2067     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2068       break;
2069     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2070       break;
2071     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2072       break;
2073     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2074       break;
2075     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2076       break;
2077     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2078       break;
2079     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2080       break;
2081     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2082       break;
2083     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2084       break;
2085     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2086       break;
2087     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2088       break;
2089     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2090       break;
2091     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2092       break;
2093     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2094       break;
2095     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2096       break;
2097     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2098       break;
2099     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2100       break;
2101     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2102       break;
2103     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2104       break;
2105     }
2106
2107   return ppc64_elf_howto_table[r];
2108 };
2109
2110 /* Set the howto pointer for a PowerPC ELF reloc.  */
2111
2112 static void
2113 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2114                          Elf_Internal_Rela *dst)
2115 {
2116   unsigned int type;
2117
2118   /* Initialize howto table if needed.  */
2119   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2120     ppc_howto_init ();
2121
2122   type = ELF64_R_TYPE (dst->r_info);
2123   if (type >= (sizeof (ppc64_elf_howto_table)
2124                / sizeof (ppc64_elf_howto_table[0])))
2125     {
2126       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2127                              abfd, (int) type);
2128       type = R_PPC64_NONE;
2129     }
2130   cache_ptr->howto = ppc64_elf_howto_table[type];
2131 }
2132
2133 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2134
2135 static bfd_reloc_status_type
2136 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2137                     void *data, asection *input_section,
2138                     bfd *output_bfd, char **error_message)
2139 {
2140   /* If this is a relocatable link (output_bfd test tells us), just
2141      call the generic function.  Any adjustment will be done at final
2142      link time.  */
2143   if (output_bfd != NULL)
2144     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2145                                   input_section, output_bfd, error_message);
2146
2147   /* Adjust the addend for sign extension of the low 16 bits.
2148      We won't actually be using the low 16 bits, so trashing them
2149      doesn't matter.  */
2150   reloc_entry->addend += 0x8000;
2151   return bfd_reloc_continue;
2152 }
2153
2154 static bfd_reloc_status_type
2155 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2156                         void *data, asection *input_section,
2157                         bfd *output_bfd, char **error_message)
2158 {
2159   if (output_bfd != NULL)
2160     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2161                                   input_section, output_bfd, error_message);
2162
2163   if (strcmp (symbol->section->name, ".opd") == 0
2164       && (symbol->section->owner->flags & DYNAMIC) == 0)
2165     {
2166       bfd_vma dest = opd_entry_value (symbol->section,
2167                                       symbol->value + reloc_entry->addend,
2168                                       NULL, NULL);
2169       if (dest != (bfd_vma) -1)
2170         reloc_entry->addend = dest - (symbol->value
2171                                       + symbol->section->output_section->vma
2172                                       + symbol->section->output_offset);
2173     }
2174   return bfd_reloc_continue;
2175 }
2176
2177 static bfd_reloc_status_type
2178 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2179                          void *data, asection *input_section,
2180                          bfd *output_bfd, char **error_message)
2181 {
2182   long insn;
2183   enum elf_ppc64_reloc_type r_type;
2184   bfd_size_type octets;
2185   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2186   bfd_boolean is_power4 = FALSE;
2187
2188   /* If this is a relocatable link (output_bfd test tells us), just
2189      call the generic function.  Any adjustment will be done at final
2190      link time.  */
2191   if (output_bfd != NULL)
2192     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2193                                   input_section, output_bfd, error_message);
2194
2195   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2196   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2197   insn &= ~(0x01 << 21);
2198   r_type = reloc_entry->howto->type;
2199   if (r_type == R_PPC64_ADDR14_BRTAKEN
2200       || r_type == R_PPC64_REL14_BRTAKEN)
2201     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2202
2203   if (is_power4)
2204     {
2205       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2206          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2207          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2208       if ((insn & (0x14 << 21)) == (0x04 << 21))
2209         insn |= 0x02 << 21;
2210       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2211         insn |= 0x08 << 21;
2212       else
2213         goto out;
2214     }
2215   else
2216     {
2217       bfd_vma target = 0;
2218       bfd_vma from;
2219
2220       if (!bfd_is_com_section (symbol->section))
2221         target = symbol->value;
2222       target += symbol->section->output_section->vma;
2223       target += symbol->section->output_offset;
2224       target += reloc_entry->addend;
2225
2226       from = (reloc_entry->address
2227               + input_section->output_offset
2228               + input_section->output_section->vma);
2229
2230       /* Invert 'y' bit if not the default.  */
2231       if ((bfd_signed_vma) (target - from) < 0)
2232         insn ^= 0x01 << 21;
2233     }
2234   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2235  out:
2236   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2237                                  input_section, output_bfd, error_message);
2238 }
2239
2240 static bfd_reloc_status_type
2241 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2242                          void *data, asection *input_section,
2243                          bfd *output_bfd, char **error_message)
2244 {
2245   /* If this is a relocatable link (output_bfd test tells us), just
2246      call the generic function.  Any adjustment will be done at final
2247      link time.  */
2248   if (output_bfd != NULL)
2249     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2250                                   input_section, output_bfd, error_message);
2251
2252   /* Subtract the symbol section base address.  */
2253   reloc_entry->addend -= symbol->section->output_section->vma;
2254   return bfd_reloc_continue;
2255 }
2256
2257 static bfd_reloc_status_type
2258 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2259                             void *data, asection *input_section,
2260                             bfd *output_bfd, char **error_message)
2261 {
2262   /* If this is a relocatable link (output_bfd test tells us), just
2263      call the generic function.  Any adjustment will be done at final
2264      link time.  */
2265   if (output_bfd != NULL)
2266     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2267                                   input_section, output_bfd, error_message);
2268
2269   /* Subtract the symbol section base address.  */
2270   reloc_entry->addend -= symbol->section->output_section->vma;
2271
2272   /* Adjust the addend for sign extension of the low 16 bits.  */
2273   reloc_entry->addend += 0x8000;
2274   return bfd_reloc_continue;
2275 }
2276
2277 static bfd_reloc_status_type
2278 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2279                      void *data, asection *input_section,
2280                      bfd *output_bfd, char **error_message)
2281 {
2282   bfd_vma TOCstart;
2283
2284   /* If this is a relocatable link (output_bfd test tells us), just
2285      call the generic function.  Any adjustment will be done at final
2286      link time.  */
2287   if (output_bfd != NULL)
2288     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2289                                   input_section, output_bfd, error_message);
2290
2291   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2292   if (TOCstart == 0)
2293     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2294
2295   /* Subtract the TOC base address.  */
2296   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2297   return bfd_reloc_continue;
2298 }
2299
2300 static bfd_reloc_status_type
2301 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2302                         void *data, asection *input_section,
2303                         bfd *output_bfd, char **error_message)
2304 {
2305   bfd_vma TOCstart;
2306
2307   /* If this is a relocatable link (output_bfd test tells us), just
2308      call the generic function.  Any adjustment will be done at final
2309      link time.  */
2310   if (output_bfd != NULL)
2311     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2312                                   input_section, output_bfd, error_message);
2313
2314   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2315   if (TOCstart == 0)
2316     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2317
2318   /* Subtract the TOC base address.  */
2319   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2320
2321   /* Adjust the addend for sign extension of the low 16 bits.  */
2322   reloc_entry->addend += 0x8000;
2323   return bfd_reloc_continue;
2324 }
2325
2326 static bfd_reloc_status_type
2327 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2328                        void *data, asection *input_section,
2329                        bfd *output_bfd, char **error_message)
2330 {
2331   bfd_vma TOCstart;
2332   bfd_size_type octets;
2333
2334   /* If this is a relocatable link (output_bfd test tells us), just
2335      call the generic function.  Any adjustment will be done at final
2336      link time.  */
2337   if (output_bfd != NULL)
2338     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2339                                   input_section, output_bfd, error_message);
2340
2341   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2342   if (TOCstart == 0)
2343     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2344
2345   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2346   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2347   return bfd_reloc_ok;
2348 }
2349
2350 static bfd_reloc_status_type
2351 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2352                            void *data, asection *input_section,
2353                            bfd *output_bfd, char **error_message)
2354 {
2355   /* If this is a relocatable link (output_bfd test tells us), just
2356      call the generic function.  Any adjustment will be done at final
2357      link time.  */
2358   if (output_bfd != NULL)
2359     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2360                                   input_section, output_bfd, error_message);
2361
2362   if (error_message != NULL)
2363     {
2364       static char buf[60];
2365       sprintf (buf, "generic linker can't handle %s",
2366                reloc_entry->howto->name);
2367       *error_message = buf;
2368     }
2369   return bfd_reloc_dangerous;
2370 }
2371
2372 struct ppc64_elf_obj_tdata
2373 {
2374   struct elf_obj_tdata elf;
2375
2376   /* Shortcuts to dynamic linker sections.  */
2377   asection *got;
2378   asection *relgot;
2379
2380   /* Used during garbage collection.  We attach global symbols defined
2381      on removed .opd entries to this section so that the sym is removed.  */
2382   asection *deleted_section;
2383
2384   /* TLS local dynamic got entry handling.  Suppose for multiple GOT
2385      sections means we potentially need one of these for each input bfd.  */
2386   union {
2387     bfd_signed_vma refcount;
2388     bfd_vma offset;
2389   } tlsld_got;
2390
2391   /* A copy of relocs before they are modified for --emit-relocs.  */
2392   Elf_Internal_Rela *opd_relocs;
2393 };
2394
2395 #define ppc64_elf_tdata(bfd) \
2396   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2397
2398 #define ppc64_tlsld_got(bfd) \
2399   (&ppc64_elf_tdata (bfd)->tlsld_got)
2400
2401 /* Override the generic function because we store some extras.  */
2402
2403 static bfd_boolean
2404 ppc64_elf_mkobject (bfd *abfd)
2405 {
2406   if (abfd->tdata.any == NULL)
2407     {
2408       bfd_size_type amt = sizeof (struct ppc64_elf_obj_tdata);
2409       abfd->tdata.any = bfd_zalloc (abfd, amt);
2410       if (abfd->tdata.any == NULL)
2411         return FALSE;
2412     }
2413   return bfd_elf_mkobject (abfd);
2414 }
2415
2416 /* Return 1 if target is one of ours.  */
2417
2418 static bfd_boolean
2419 is_ppc64_elf_target (const struct bfd_target *targ)
2420 {
2421   extern const bfd_target bfd_elf64_powerpc_vec;
2422   extern const bfd_target bfd_elf64_powerpcle_vec;
2423
2424   return targ == &bfd_elf64_powerpc_vec || targ == &bfd_elf64_powerpcle_vec;
2425 }
2426
2427 /* Fix bad default arch selected for a 64 bit input bfd when the
2428    default is 32 bit.  */
2429
2430 static bfd_boolean
2431 ppc64_elf_object_p (bfd *abfd)
2432 {
2433   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2434     {
2435       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2436
2437       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2438         {
2439           /* Relies on arch after 32 bit default being 64 bit default.  */
2440           abfd->arch_info = abfd->arch_info->next;
2441           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2442         }
2443     }
2444   return TRUE;
2445 }
2446
2447 /* Support for core dump NOTE sections.  */
2448
2449 static bfd_boolean
2450 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2451 {
2452   size_t offset, size;
2453
2454   if (note->descsz != 504)
2455     return FALSE;
2456
2457   /* pr_cursig */
2458   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2459
2460   /* pr_pid */
2461   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2462
2463   /* pr_reg */
2464   offset = 112;
2465   size = 384;
2466
2467   /* Make a ".reg/999" section.  */
2468   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2469                                           size, note->descpos + offset);
2470 }
2471
2472 static bfd_boolean
2473 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2474 {
2475   if (note->descsz != 136)
2476     return FALSE;
2477
2478   elf_tdata (abfd)->core_program
2479     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2480   elf_tdata (abfd)->core_command
2481     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2482
2483   return TRUE;
2484 }
2485
2486 /* Merge backend specific data from an object file to the output
2487    object file when linking.  */
2488
2489 static bfd_boolean
2490 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2491 {
2492   /* Check if we have the same endianess.  */
2493   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2494       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2495       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2496     {
2497       const char *msg;
2498
2499       if (bfd_big_endian (ibfd))
2500         msg = _("%B: compiled for a big endian system "
2501                 "and target is little endian");
2502       else
2503         msg = _("%B: compiled for a little endian system "
2504                 "and target is big endian");
2505
2506       (*_bfd_error_handler) (msg, ibfd);
2507
2508       bfd_set_error (bfd_error_wrong_format);
2509       return FALSE;
2510     }
2511
2512   return TRUE;
2513 }
2514
2515 /* Add extra PPC sections.  */
2516
2517 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2518 {
2519   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2520   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2521   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2522   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2523   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2524   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2525   { NULL,                     0,  0, 0,            0 }
2526 };
2527
2528 struct _ppc64_elf_section_data
2529 {
2530   struct bfd_elf_section_data elf;
2531
2532   /* An array with one entry for each opd function descriptor.  */
2533   union
2534   {
2535     /* Points to the function code section for local opd entries.  */
2536     asection **func_sec;
2537     /* After editing .opd, adjust references to opd local syms.  */
2538     long *adjust;
2539   } opd;
2540
2541   /* An array for toc sections, indexed by offset/8.
2542      Specifies the relocation symbol index used at a given toc offset.  */
2543   unsigned *t_symndx;
2544 };
2545
2546 #define ppc64_elf_section_data(sec) \
2547   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2548
2549 static bfd_boolean
2550 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2551 {
2552   if (!sec->used_by_bfd)
2553     {
2554       struct _ppc64_elf_section_data *sdata;
2555       bfd_size_type amt = sizeof (*sdata);
2556
2557       sdata = bfd_zalloc (abfd, amt);
2558       if (sdata == NULL)
2559         return FALSE;
2560       sec->used_by_bfd = sdata;
2561     }
2562
2563   return _bfd_elf_new_section_hook (abfd, sec);
2564 }
2565
2566 static void *
2567 get_opd_info (asection * sec)
2568 {
2569   if (sec != NULL
2570       && ppc64_elf_section_data (sec) != NULL
2571       && ppc64_elf_section_data (sec)->opd.adjust != NULL)
2572     return ppc64_elf_section_data (sec)->opd.adjust;
2573   return NULL;
2574 }
2575 \f
2576 /* Parameters for the qsort hook.  */
2577 static asection *synthetic_opd;
2578 static bfd_boolean synthetic_relocatable;
2579
2580 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2581
2582 static int
2583 compare_symbols (const void *ap, const void *bp)
2584 {
2585   const asymbol *a = * (const asymbol **) ap;
2586   const asymbol *b = * (const asymbol **) bp;
2587
2588   /* Section symbols first.  */
2589   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2590     return -1;
2591   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2592     return 1;
2593
2594   /* then .opd symbols.  */
2595   if (a->section == synthetic_opd && b->section != synthetic_opd)
2596     return -1;
2597   if (a->section != synthetic_opd && b->section == synthetic_opd)
2598     return 1;
2599
2600   /* then other code symbols.  */
2601   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2602       == (SEC_CODE | SEC_ALLOC)
2603       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2604          != (SEC_CODE | SEC_ALLOC))
2605     return -1;
2606
2607   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2608       != (SEC_CODE | SEC_ALLOC)
2609       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2610          == (SEC_CODE | SEC_ALLOC))
2611     return 1;
2612
2613   if (synthetic_relocatable)
2614     {
2615       if (a->section->id < b->section->id)
2616         return -1;
2617
2618       if (a->section->id > b->section->id)
2619         return 1;
2620     }
2621
2622   if (a->value + a->section->vma < b->value + b->section->vma)
2623     return -1;
2624
2625   if (a->value + a->section->vma > b->value + b->section->vma)
2626     return 1;
2627
2628   /* For syms with the same value, prefer strong dynamic global function
2629      syms over other syms.  */
2630   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2631     return -1;
2632
2633   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2634     return 1;
2635
2636   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2637     return -1;
2638
2639   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2640     return 1;
2641
2642   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2643     return -1;
2644
2645   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2646     return 1;
2647
2648   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2649     return -1;
2650
2651   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2652     return 1;
2653
2654   return 0;
2655 }
2656
2657 /* Search SYMS for a symbol of the given VALUE.  */
2658
2659 static asymbol *
2660 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2661 {
2662   long mid;
2663
2664   if (id == -1)
2665     {
2666       while (lo < hi)
2667         {
2668           mid = (lo + hi) >> 1;
2669           if (syms[mid]->value + syms[mid]->section->vma < value)
2670             lo = mid + 1;
2671           else if (syms[mid]->value + syms[mid]->section->vma > value)
2672             hi = mid;
2673           else
2674             return syms[mid];
2675         }
2676     }
2677   else
2678     {
2679       while (lo < hi)
2680         {
2681           mid = (lo + hi) >> 1;
2682           if (syms[mid]->section->id < id)
2683             lo = mid + 1;
2684           else if (syms[mid]->section->id > id)
2685             hi = mid;
2686           else if (syms[mid]->value < value)
2687             lo = mid + 1;
2688           else if (syms[mid]->value > value)
2689             hi = mid;
2690           else
2691             return syms[mid];
2692         }
2693     }
2694   return NULL;
2695 }
2696
2697 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2698    entry syms.  */
2699
2700 static long
2701 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2702                                 long static_count, asymbol **static_syms,
2703                                 long dyn_count, asymbol **dyn_syms,
2704                                 asymbol **ret)
2705 {
2706   asymbol *s;
2707   long i;
2708   long count;
2709   char *names;
2710   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2711   asection *opd;
2712   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2713   asymbol **syms;
2714
2715   *ret = NULL;
2716
2717   opd = bfd_get_section_by_name (abfd, ".opd");
2718   if (opd == NULL)
2719     return 0;
2720
2721   symcount = static_count;
2722   if (!relocatable)
2723     symcount += dyn_count;
2724   if (symcount == 0)
2725     return 0;
2726
2727   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2728   if (syms == NULL)
2729     return -1;
2730
2731   if (!relocatable && static_count != 0 && dyn_count != 0)
2732     {
2733       /* Use both symbol tables.  */
2734       memcpy (syms, static_syms, static_count * sizeof (*syms));
2735       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2736     }
2737   else if (!relocatable && static_count == 0)
2738     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2739   else
2740     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2741
2742   synthetic_opd = opd;
2743   synthetic_relocatable = relocatable;
2744   qsort (syms, symcount, sizeof (*syms), compare_symbols);
2745
2746   if (!relocatable && symcount > 1)
2747     {
2748       long j;
2749       /* Trim duplicate syms, since we may have merged the normal and
2750          dynamic symbols.  Actually, we only care about syms that have
2751          different values, so trim any with the same value.  */
2752       for (i = 1, j = 1; i < symcount; ++i)
2753         if (syms[i - 1]->value + syms[i - 1]->section->vma
2754             != syms[i]->value + syms[i]->section->vma)
2755           syms[j++] = syms[i];
2756       symcount = j;
2757     }
2758
2759   i = 0;
2760   if (syms[i]->section == opd)
2761     ++i;
2762   codesecsym = i;
2763
2764   for (; i < symcount; ++i)
2765     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2766          != (SEC_CODE | SEC_ALLOC))
2767         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2768       break;
2769   codesecsymend = i;
2770
2771   for (; i < symcount; ++i)
2772     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2773       break;
2774   secsymend = i;
2775
2776   for (; i < symcount; ++i)
2777     if (syms[i]->section != opd)
2778       break;
2779   opdsymend = i;
2780
2781   for (; i < symcount; ++i)
2782     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2783         != (SEC_CODE | SEC_ALLOC))
2784       break;
2785   symcount = i;
2786
2787   count = 0;
2788   if (opdsymend == secsymend)
2789     goto done;
2790
2791   if (relocatable)
2792     {
2793       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2794       arelent *r;
2795       size_t size;
2796       long relcount;
2797
2798       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2799       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2800       if (relcount == 0)
2801         goto done;
2802
2803       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2804         {
2805           count = -1;
2806           goto done;
2807         }
2808
2809       size = 0;
2810       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2811         {
2812           asymbol *sym;
2813
2814           while (r < opd->relocation + relcount
2815                  && r->address < syms[i]->value + opd->vma)
2816             ++r;
2817
2818           if (r == opd->relocation + relcount)
2819             break;
2820
2821           if (r->address != syms[i]->value + opd->vma)
2822             continue;
2823
2824           if (r->howto->type != R_PPC64_ADDR64)
2825             continue;
2826
2827           sym = *r->sym_ptr_ptr;
2828           if (!sym_exists_at (syms, opdsymend, symcount,
2829                               sym->section->id, sym->value + r->addend))
2830             {
2831               ++count;
2832               size += sizeof (asymbol);
2833               size += strlen (syms[i]->name) + 2;
2834             }
2835         }
2836
2837       s = *ret = bfd_malloc (size);
2838       if (s == NULL)
2839         {
2840           count = -1;
2841           goto done;
2842         }
2843
2844       names = (char *) (s + count);
2845
2846       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2847         {
2848           asymbol *sym;
2849
2850           while (r < opd->relocation + relcount
2851                  && r->address < syms[i]->value + opd->vma)
2852             ++r;
2853
2854           if (r == opd->relocation + relcount)
2855             break;
2856
2857           if (r->address != syms[i]->value + opd->vma)
2858             continue;
2859
2860           if (r->howto->type != R_PPC64_ADDR64)
2861             continue;
2862
2863           sym = *r->sym_ptr_ptr;
2864           if (!sym_exists_at (syms, opdsymend, symcount,
2865                               sym->section->id, sym->value + r->addend))
2866             {
2867               size_t len;
2868
2869               *s = *syms[i];
2870               s->section = sym->section;
2871               s->value = sym->value + r->addend;
2872               s->name = names;
2873               *names++ = '.';
2874               len = strlen (syms[i]->name);
2875               memcpy (names, syms[i]->name, len + 1);
2876               names += len + 1;
2877               s++;
2878             }
2879         }
2880     }
2881   else
2882     {
2883       bfd_byte *contents;
2884       size_t size;
2885
2886       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
2887         {
2888           if (contents)
2889             {
2890             free_contents_and_exit:
2891               free (contents);
2892             }
2893           count = -1;
2894           goto done;
2895         }
2896
2897       size = 0;
2898       for (i = secsymend; i < opdsymend; ++i)
2899         {
2900           bfd_vma ent;
2901
2902           ent = bfd_get_64 (abfd, contents + syms[i]->value);
2903           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2904             {
2905               ++count;
2906               size += sizeof (asymbol);
2907               size += strlen (syms[i]->name) + 2;
2908             }
2909         }
2910
2911       s = *ret = bfd_malloc (size);
2912       if (s == NULL)
2913         goto free_contents_and_exit;
2914
2915       names = (char *) (s + count);
2916
2917       for (i = secsymend; i < opdsymend; ++i)
2918         {
2919           bfd_vma ent;
2920
2921           ent = bfd_get_64 (abfd, contents + syms[i]->value);
2922           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2923             {
2924               long lo, hi;
2925               size_t len;
2926               asection *sec = abfd->sections;
2927
2928               *s = *syms[i];
2929               lo = codesecsym;
2930               hi = codesecsymend;
2931               while (lo < hi)
2932                 {
2933                   long mid = (lo + hi) >> 1;
2934                   if (syms[mid]->section->vma < ent)
2935                     lo = mid + 1;
2936                   else if (syms[mid]->section->vma > ent)
2937                     hi = mid;
2938                   else
2939                     {
2940                       sec = syms[mid]->section;
2941                       break;
2942                     }
2943                 }
2944
2945               if (lo >= hi && lo > codesecsym)
2946                 sec = syms[lo - 1]->section;
2947
2948               for (; sec != NULL; sec = sec->next)
2949                 {
2950                   if (sec->vma > ent)
2951                     break;
2952                   if ((sec->flags & SEC_ALLOC) == 0
2953                       || (sec->flags & SEC_LOAD) == 0)
2954                     break;
2955                   if ((sec->flags & SEC_CODE) != 0)
2956                     s->section = sec;
2957                 }
2958               s->value = ent - s->section->vma;
2959               s->name = names;
2960               *names++ = '.';
2961               len = strlen (syms[i]->name);
2962               memcpy (names, syms[i]->name, len + 1);
2963               names += len + 1;
2964               s++;
2965             }
2966         }
2967       free (contents);
2968     }
2969
2970  done:
2971   free (syms);
2972   return count;
2973 }
2974 \f
2975 /* The following functions are specific to the ELF linker, while
2976    functions above are used generally.  Those named ppc64_elf_* are
2977    called by the main ELF linker code.  They appear in this file more
2978    or less in the order in which they are called.  eg.
2979    ppc64_elf_check_relocs is called early in the link process,
2980    ppc64_elf_finish_dynamic_sections is one of the last functions
2981    called.
2982
2983    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2984    functions have both a function code symbol and a function descriptor
2985    symbol.  A call to foo in a relocatable object file looks like:
2986
2987    .            .text
2988    .    x:
2989    .            bl      .foo
2990    .            nop
2991
2992    The function definition in another object file might be:
2993
2994    .            .section .opd
2995    .    foo:    .quad   .foo
2996    .            .quad   .TOC.@tocbase
2997    .            .quad   0
2998    .
2999    .            .text
3000    .    .foo:   blr
3001
3002    When the linker resolves the call during a static link, the branch
3003    unsurprisingly just goes to .foo and the .opd information is unused.
3004    If the function definition is in a shared library, things are a little
3005    different:  The call goes via a plt call stub, the opd information gets
3006    copied to the plt, and the linker patches the nop.
3007
3008    .    x:
3009    .            bl      .foo_stub
3010    .            ld      2,40(1)
3011    .
3012    .
3013    .    .foo_stub:
3014    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3015    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3016    .            std     2,40(1)                 # this is the general idea
3017    .            ld      11,0(12)
3018    .            ld      2,8(12)
3019    .            mtctr   11
3020    .            ld      11,16(12)
3021    .            bctr
3022    .
3023    .            .section .plt
3024    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3025
3026    The "reloc ()" notation is supposed to indicate that the linker emits
3027    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3028    copying.
3029
3030    What are the difficulties here?  Well, firstly, the relocations
3031    examined by the linker in check_relocs are against the function code
3032    sym .foo, while the dynamic relocation in the plt is emitted against
3033    the function descriptor symbol, foo.  Somewhere along the line, we need
3034    to carefully copy dynamic link information from one symbol to the other.
3035    Secondly, the generic part of the elf linker will make .foo a dynamic
3036    symbol as is normal for most other backends.  We need foo dynamic
3037    instead, at least for an application final link.  However, when
3038    creating a shared library containing foo, we need to have both symbols
3039    dynamic so that references to .foo are satisfied during the early
3040    stages of linking.  Otherwise the linker might decide to pull in a
3041    definition from some other object, eg. a static library.
3042
3043    Update: As of August 2004, we support a new convention.  Function
3044    calls may use the function descriptor symbol, ie. "bl foo".  This
3045    behaves exactly as "bl .foo".  */
3046
3047 /* The linker needs to keep track of the number of relocs that it
3048    decides to copy as dynamic relocs in check_relocs for each symbol.
3049    This is so that it can later discard them if they are found to be
3050    unnecessary.  We store the information in a field extending the
3051    regular ELF linker hash table.  */
3052
3053 struct ppc_dyn_relocs
3054 {
3055   struct ppc_dyn_relocs *next;
3056
3057   /* The input section of the reloc.  */
3058   asection *sec;
3059
3060   /* Total number of relocs copied for the input section.  */
3061   bfd_size_type count;
3062
3063   /* Number of pc-relative relocs copied for the input section.  */
3064   bfd_size_type pc_count;
3065 };
3066
3067 /* Track GOT entries needed for a given symbol.  We might need more
3068    than one got entry per symbol.  */
3069 struct got_entry
3070 {
3071   struct got_entry *next;
3072
3073   /* The symbol addend that we'll be placing in the GOT.  */
3074   bfd_vma addend;
3075
3076   /* Unlike other ELF targets, we use separate GOT entries for the same
3077      symbol referenced from different input files.  This is to support
3078      automatic multiple TOC/GOT sections, where the TOC base can vary
3079      from one input file to another.
3080
3081      Point to the BFD owning this GOT entry.  */
3082   bfd *owner;
3083
3084   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3085      TLS_TPREL or TLS_DTPREL for tls entries.  */
3086   char tls_type;
3087
3088   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
3089   union
3090     {
3091       bfd_signed_vma refcount;
3092       bfd_vma offset;
3093     } got;
3094 };
3095
3096 /* The same for PLT.  */
3097 struct plt_entry
3098 {
3099   struct plt_entry *next;
3100
3101   bfd_vma addend;
3102
3103   union
3104     {
3105       bfd_signed_vma refcount;
3106       bfd_vma offset;
3107     } plt;
3108 };
3109
3110 /* Of those relocs that might be copied as dynamic relocs, this macro
3111    selects those that must be copied when linking a shared library,
3112    even when the symbol is local.  */
3113
3114 #define MUST_BE_DYN_RELOC(RTYPE)                \
3115   ((RTYPE) != R_PPC64_REL32                     \
3116    && (RTYPE) != R_PPC64_REL64                  \
3117    && (RTYPE) != R_PPC64_REL30)
3118
3119 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3120    copying dynamic variables from a shared lib into an app's dynbss
3121    section, and instead use a dynamic relocation to point into the
3122    shared lib.  With code that gcc generates, it's vital that this be
3123    enabled;  In the PowerPC64 ABI, the address of a function is actually
3124    the address of a function descriptor, which resides in the .opd
3125    section.  gcc uses the descriptor directly rather than going via the
3126    GOT as some other ABI's do, which means that initialized function
3127    pointers must reference the descriptor.  Thus, a function pointer
3128    initialized to the address of a function in a shared library will
3129    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3130    redefines the function descriptor symbol to point to the copy.  This
3131    presents a problem as a plt entry for that function is also
3132    initialized from the function descriptor symbol and the copy reloc
3133    may not be initialized first.  */
3134 #define ELIMINATE_COPY_RELOCS 1
3135
3136 /* Section name for stubs is the associated section name plus this
3137    string.  */
3138 #define STUB_SUFFIX ".stub"
3139
3140 /* Linker stubs.
3141    ppc_stub_long_branch:
3142    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3143    destination, but a 24 bit branch in a stub section will reach.
3144    .    b       dest
3145
3146    ppc_stub_plt_branch:
3147    Similar to the above, but a 24 bit branch in the stub section won't
3148    reach its destination.
3149    .    addis   %r12,%r2,xxx@toc@ha
3150    .    ld      %r11,xxx@toc@l(%r12)
3151    .    mtctr   %r11
3152    .    bctr
3153
3154    ppc_stub_plt_call:
3155    Used to call a function in a shared library.  If it so happens that
3156    the plt entry referenced crosses a 64k boundary, then an extra
3157    "addis %r12,%r12,1" will be inserted before the load at xxx+8 or
3158    xxx+16 as appropriate.
3159    .    addis   %r12,%r2,xxx@toc@ha
3160    .    std     %r2,40(%r1)
3161    .    ld      %r11,xxx+0@toc@l(%r12)
3162    .    ld      %r2,xxx+8@toc@l(%r12)
3163    .    mtctr   %r11
3164    .    ld      %r11,xxx+16@toc@l(%r12)
3165    .    bctr
3166
3167    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3168    code to adjust the value and save r2 to support multiple toc sections.
3169    A ppc_stub_long_branch with an r2 offset looks like:
3170    .    std     %r2,40(%r1)
3171    .    addis   %r2,%r2,off@ha
3172    .    addi    %r2,%r2,off@l
3173    .    b       dest
3174
3175    A ppc_stub_plt_branch with an r2 offset looks like:
3176    .    std     %r2,40(%r1)
3177    .    addis   %r12,%r2,xxx@toc@ha
3178    .    ld      %r11,xxx@toc@l(%r12)
3179    .    addis   %r2,%r2,off@ha
3180    .    addi    %r2,%r2,off@l
3181    .    mtctr   %r11
3182    .    bctr
3183 */
3184
3185 enum ppc_stub_type {
3186   ppc_stub_none,
3187   ppc_stub_long_branch,
3188   ppc_stub_long_branch_r2off,
3189   ppc_stub_plt_branch,
3190   ppc_stub_plt_branch_r2off,
3191   ppc_stub_plt_call
3192 };
3193
3194 struct ppc_stub_hash_entry {
3195
3196   /* Base hash table entry structure.  */
3197   struct bfd_hash_entry root;
3198
3199   enum ppc_stub_type stub_type;
3200
3201   /* The stub section.  */
3202   asection *stub_sec;
3203
3204   /* Offset within stub_sec of the beginning of this stub.  */
3205   bfd_vma stub_offset;
3206
3207   /* Given the symbol's value and its section we can determine its final
3208      value when building the stubs (so the stub knows where to jump.  */
3209   bfd_vma target_value;
3210   asection *target_section;
3211
3212   /* The symbol table entry, if any, that this was derived from.  */
3213   struct ppc_link_hash_entry *h;
3214
3215   /* And the reloc addend that this was derived from.  */
3216   bfd_vma addend;
3217
3218   /* Where this stub is being called from, or, in the case of combined
3219      stub sections, the first input section in the group.  */
3220   asection *id_sec;
3221 };
3222
3223 struct ppc_branch_hash_entry {
3224
3225   /* Base hash table entry structure.  */
3226   struct bfd_hash_entry root;
3227
3228   /* Offset within branch lookup table.  */
3229   unsigned int offset;
3230
3231   /* Generation marker.  */
3232   unsigned int iter;
3233 };
3234
3235 struct ppc_link_hash_entry
3236 {
3237   struct elf_link_hash_entry elf;
3238
3239   union {
3240     /* A pointer to the most recently used stub hash entry against this
3241        symbol.  */
3242     struct ppc_stub_hash_entry *stub_cache;
3243
3244     /* A pointer to the next symbol starting with a '.'  */
3245     struct ppc_link_hash_entry *next_dot_sym;
3246   } u;
3247
3248   /* Track dynamic relocs copied for this symbol.  */
3249   struct ppc_dyn_relocs *dyn_relocs;
3250
3251   /* Link between function code and descriptor symbols.  */
3252   struct ppc_link_hash_entry *oh;
3253
3254   /* Flag function code and descriptor symbols.  */
3255   unsigned int is_func:1;
3256   unsigned int is_func_descriptor:1;
3257   unsigned int fake:1;
3258
3259   /* Whether global opd/toc sym has been adjusted or not.
3260      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3261      should be set for all globals defined in any opd/toc section.  */
3262   unsigned int adjust_done:1;
3263
3264   /* Set if we twiddled this symbol to weak at some stage.  */
3265   unsigned int was_undefined:1;
3266
3267   /* Contexts in which symbol is used in the GOT (or TOC).
3268      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3269      corresponding relocs are encountered during check_relocs.
3270      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3271      indicate the corresponding GOT entry type is not needed.
3272      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3273      a TPREL one.  We use a separate flag rather than setting TPREL
3274      just for convenience in distinguishing the two cases.  */
3275 #define TLS_GD           1      /* GD reloc. */
3276 #define TLS_LD           2      /* LD reloc. */
3277 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3278 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3279 #define TLS_TLS         16      /* Any TLS reloc.  */
3280 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3281 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3282   char tls_mask;
3283 };
3284
3285 /* ppc64 ELF linker hash table.  */
3286
3287 struct ppc_link_hash_table
3288 {
3289   struct elf_link_hash_table elf;
3290
3291   /* The stub hash table.  */
3292   struct bfd_hash_table stub_hash_table;
3293
3294   /* Another hash table for plt_branch stubs.  */
3295   struct bfd_hash_table branch_hash_table;
3296
3297   /* Linker stub bfd.  */
3298   bfd *stub_bfd;
3299
3300   /* Linker call-backs.  */
3301   asection * (*add_stub_section) (const char *, asection *);
3302   void (*layout_sections_again) (void);
3303
3304   /* Array to keep track of which stub sections have been created, and
3305      information on stub grouping.  */
3306   struct map_stub {
3307     /* This is the section to which stubs in the group will be attached.  */
3308     asection *link_sec;
3309     /* The stub section.  */
3310     asection *stub_sec;
3311     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3312     bfd_vma toc_off;
3313   } *stub_group;
3314
3315   /* Temp used when calculating TOC pointers.  */
3316   bfd_vma toc_curr;
3317
3318   /* Highest input section id.  */
3319   int top_id;
3320
3321   /* Highest output section index.  */
3322   int top_index;
3323
3324   /* Used when adding symbols.  */
3325   struct ppc_link_hash_entry *dot_syms;
3326
3327   /* List of input sections for each output section.  */
3328   asection **input_list;
3329
3330   /* Short-cuts to get to dynamic linker sections.  */
3331   asection *got;
3332   asection *plt;
3333   asection *relplt;
3334   asection *dynbss;
3335   asection *relbss;
3336   asection *glink;
3337   asection *sfpr;
3338   asection *brlt;
3339   asection *relbrlt;
3340
3341   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3342   struct ppc_link_hash_entry *tls_get_addr;
3343   struct ppc_link_hash_entry *tls_get_addr_fd;
3344
3345   /* Statistics.  */
3346   unsigned long stub_count[ppc_stub_plt_call];
3347
3348   /* Number of stubs against global syms.  */
3349   unsigned long stub_globals;
3350
3351   /* Set if we should emit symbols for stubs.  */
3352   unsigned int emit_stub_syms:1;
3353
3354   /* Support for multiple toc sections.  */
3355   unsigned int no_multi_toc:1;
3356   unsigned int multi_toc_needed:1;
3357
3358   /* Set on error.  */
3359   unsigned int stub_error:1;
3360
3361   /* Flag set when small branches are detected.  Used to
3362      select suitable defaults for the stub group size.  */
3363   unsigned int has_14bit_branch:1;
3364
3365   /* Temp used by ppc64_elf_check_directives.  */
3366   unsigned int twiddled_syms:1;
3367
3368   /* Incremented every time we size stubs.  */
3369   unsigned int stub_iteration;
3370
3371   /* Small local sym to section mapping cache.  */
3372   struct sym_sec_cache sym_sec;
3373 };
3374
3375 /* Rename some of the generic section flags to better document how they
3376    are used here.  */
3377 #define has_toc_reloc has_gp_reloc
3378 #define makes_toc_func_call need_finalize_relax
3379 #define call_check_in_progress reloc_done
3380
3381 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3382
3383 #define ppc_hash_table(p) \
3384   ((struct ppc_link_hash_table *) ((p)->hash))
3385
3386 #define ppc_stub_hash_lookup(table, string, create, copy) \
3387   ((struct ppc_stub_hash_entry *) \
3388    bfd_hash_lookup ((table), (string), (create), (copy)))
3389
3390 #define ppc_branch_hash_lookup(table, string, create, copy) \
3391   ((struct ppc_branch_hash_entry *) \
3392    bfd_hash_lookup ((table), (string), (create), (copy)))
3393
3394 /* Create an entry in the stub hash table.  */
3395
3396 static struct bfd_hash_entry *
3397 stub_hash_newfunc (struct bfd_hash_entry *entry,
3398                    struct bfd_hash_table *table,
3399                    const char *string)
3400 {
3401   /* Allocate the structure if it has not already been allocated by a
3402      subclass.  */
3403   if (entry == NULL)
3404     {
3405       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3406       if (entry == NULL)
3407         return entry;
3408     }
3409
3410   /* Call the allocation method of the superclass.  */
3411   entry = bfd_hash_newfunc (entry, table, string);
3412   if (entry != NULL)
3413     {
3414       struct ppc_stub_hash_entry *eh;
3415
3416       /* Initialize the local fields.  */
3417       eh = (struct ppc_stub_hash_entry *) entry;
3418       eh->stub_type = ppc_stub_none;
3419       eh->stub_sec = NULL;
3420       eh->stub_offset = 0;
3421       eh->target_value = 0;
3422       eh->target_section = NULL;
3423       eh->h = NULL;
3424       eh->id_sec = NULL;
3425     }
3426
3427   return entry;
3428 }
3429
3430 /* Create an entry in the branch hash table.  */
3431
3432 static struct bfd_hash_entry *
3433 branch_hash_newfunc (struct bfd_hash_entry *entry,
3434                      struct bfd_hash_table *table,
3435                      const char *string)
3436 {
3437   /* Allocate the structure if it has not already been allocated by a
3438      subclass.  */
3439   if (entry == NULL)
3440     {
3441       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3442       if (entry == NULL)
3443         return entry;
3444     }
3445
3446   /* Call the allocation method of the superclass.  */
3447   entry = bfd_hash_newfunc (entry, table, string);
3448   if (entry != NULL)
3449     {
3450       struct ppc_branch_hash_entry *eh;
3451
3452       /* Initialize the local fields.  */
3453       eh = (struct ppc_branch_hash_entry *) entry;
3454       eh->offset = 0;
3455       eh->iter = 0;
3456     }
3457
3458   return entry;
3459 }
3460
3461 /* Create an entry in a ppc64 ELF linker hash table.  */
3462
3463 static struct bfd_hash_entry *
3464 link_hash_newfunc (struct bfd_hash_entry *entry,
3465                    struct bfd_hash_table *table,
3466                    const char *string)
3467 {
3468   /* Allocate the structure if it has not already been allocated by a
3469      subclass.  */
3470   if (entry == NULL)
3471     {
3472       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3473       if (entry == NULL)
3474         return entry;
3475     }
3476
3477   /* Call the allocation method of the superclass.  */
3478   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3479   if (entry != NULL)
3480     {
3481       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3482
3483       memset (&eh->u.stub_cache, 0,
3484               (sizeof (struct ppc_link_hash_entry)
3485                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3486
3487       /* When making function calls, old ABI code references function entry
3488          points (dot symbols), while new ABI code references the function
3489          descriptor symbol.  We need to make any combination of reference and
3490          definition work together, without breaking archive linking.
3491
3492          For a defined function "foo" and an undefined call to "bar":
3493          An old object defines "foo" and ".foo", references ".bar" (possibly
3494          "bar" too).
3495          A new object defines "foo" and references "bar".
3496
3497          A new object thus has no problem with its undefined symbols being
3498          satisfied by definitions in an old object.  On the other hand, the
3499          old object won't have ".bar" satisfied by a new object.
3500
3501          Keep a list of newly added dot-symbols.  */
3502
3503       if (string[0] == '.')
3504         {
3505           struct ppc_link_hash_table *htab;
3506
3507           htab = (struct ppc_link_hash_table *) table;
3508           eh->u.next_dot_sym = htab->dot_syms;
3509           htab->dot_syms = eh;
3510         }
3511     }
3512
3513   return entry;
3514 }
3515
3516 /* Create a ppc64 ELF linker hash table.  */
3517
3518 static struct bfd_link_hash_table *
3519 ppc64_elf_link_hash_table_create (bfd *abfd)
3520 {
3521   struct ppc_link_hash_table *htab;
3522   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3523
3524   htab = bfd_zmalloc (amt);
3525   if (htab == NULL)
3526     return NULL;
3527
3528   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3529                                       sizeof (struct ppc_link_hash_entry)))
3530     {
3531       free (htab);
3532       return NULL;
3533     }
3534
3535   /* Init the stub hash table too.  */
3536   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3537                             sizeof (struct ppc_stub_hash_entry)))
3538     return NULL;
3539
3540   /* And the branch hash table.  */
3541   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3542                             sizeof (struct ppc_branch_hash_entry)))
3543     return NULL;
3544
3545   /* Initializing two fields of the union is just cosmetic.  We really
3546      only care about glist, but when compiled on a 32-bit host the
3547      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3548      debugger inspection of these fields look nicer.  */
3549   htab->elf.init_got_refcount.refcount = 0;
3550   htab->elf.init_got_refcount.glist = NULL;
3551   htab->elf.init_plt_refcount.refcount = 0;
3552   htab->elf.init_plt_refcount.glist = NULL;
3553   htab->elf.init_got_offset.offset = 0;
3554   htab->elf.init_got_offset.glist = NULL;
3555   htab->elf.init_plt_offset.offset = 0;
3556   htab->elf.init_plt_offset.glist = NULL;
3557
3558   return &htab->elf.root;
3559 }
3560
3561 /* Free the derived linker hash table.  */
3562
3563 static void
3564 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3565 {
3566   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3567
3568   bfd_hash_table_free (&ret->stub_hash_table);
3569   bfd_hash_table_free (&ret->branch_hash_table);
3570   _bfd_generic_link_hash_table_free (hash);
3571 }
3572
3573 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3574
3575 void
3576 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3577 {
3578   struct ppc_link_hash_table *htab;
3579
3580   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3581
3582 /* Always hook our dynamic sections into the first bfd, which is the
3583    linker created stub bfd.  This ensures that the GOT header is at
3584    the start of the output TOC section.  */
3585   htab = ppc_hash_table (info);
3586   htab->stub_bfd = abfd;
3587   htab->elf.dynobj = abfd;
3588 }
3589
3590 /* Build a name for an entry in the stub hash table.  */
3591
3592 static char *
3593 ppc_stub_name (const asection *input_section,
3594                const asection *sym_sec,
3595                const struct ppc_link_hash_entry *h,
3596                const Elf_Internal_Rela *rel)
3597 {
3598   char *stub_name;
3599   bfd_size_type len;
3600
3601   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3602      offsets from a sym as a branch target?  In fact, we could
3603      probably assume the addend is always zero.  */
3604   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3605
3606   if (h)
3607     {
3608       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3609       stub_name = bfd_malloc (len);
3610       if (stub_name == NULL)
3611         return stub_name;
3612
3613       sprintf (stub_name, "%08x.%s+%x",
3614                input_section->id & 0xffffffff,
3615                h->elf.root.root.string,
3616                (int) rel->r_addend & 0xffffffff);
3617     }
3618   else
3619     {
3620       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3621       stub_name = bfd_malloc (len);
3622       if (stub_name == NULL)
3623         return stub_name;
3624
3625       sprintf (stub_name, "%08x.%x:%x+%x",
3626                input_section->id & 0xffffffff,
3627                sym_sec->id & 0xffffffff,
3628                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3629                (int) rel->r_addend & 0xffffffff);
3630     }
3631   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3632     stub_name[len - 2] = 0;
3633   return stub_name;
3634 }
3635
3636 /* Look up an entry in the stub hash.  Stub entries are cached because
3637    creating the stub name takes a bit of time.  */
3638
3639 static struct ppc_stub_hash_entry *
3640 ppc_get_stub_entry (const asection *input_section,
3641                     const asection *sym_sec,
3642                     struct ppc_link_hash_entry *h,
3643                     const Elf_Internal_Rela *rel,
3644                     struct ppc_link_hash_table *htab)
3645 {
3646   struct ppc_stub_hash_entry *stub_entry;
3647   const asection *id_sec;
3648
3649   /* If this input section is part of a group of sections sharing one
3650      stub section, then use the id of the first section in the group.
3651      Stub names need to include a section id, as there may well be
3652      more than one stub used to reach say, printf, and we need to
3653      distinguish between them.  */
3654   id_sec = htab->stub_group[input_section->id].link_sec;
3655
3656   if (h != NULL && h->u.stub_cache != NULL
3657       && h->u.stub_cache->h == h
3658       && h->u.stub_cache->id_sec == id_sec)
3659     {
3660       stub_entry = h->u.stub_cache;
3661     }
3662   else
3663     {
3664       char *stub_name;
3665
3666       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3667       if (stub_name == NULL)
3668         return NULL;
3669
3670       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3671                                          stub_name, FALSE, FALSE);
3672       if (h != NULL)
3673         h->u.stub_cache = stub_entry;
3674
3675       free (stub_name);
3676     }
3677
3678   return stub_entry;
3679 }
3680
3681 /* Add a new stub entry to the stub hash.  Not all fields of the new
3682    stub entry are initialised.  */
3683
3684 static struct ppc_stub_hash_entry *
3685 ppc_add_stub (const char *stub_name,
3686               asection *section,
3687               struct ppc_link_hash_table *htab)
3688 {
3689   asection *link_sec;
3690   asection *stub_sec;
3691   struct ppc_stub_hash_entry *stub_entry;
3692
3693   link_sec = htab->stub_group[section->id].link_sec;
3694   stub_sec = htab->stub_group[section->id].stub_sec;
3695   if (stub_sec == NULL)
3696     {
3697       stub_sec = htab->stub_group[link_sec->id].stub_sec;
3698       if (stub_sec == NULL)
3699         {
3700           size_t namelen;
3701           bfd_size_type len;
3702           char *s_name;
3703
3704           namelen = strlen (link_sec->name);
3705           len = namelen + sizeof (STUB_SUFFIX);
3706           s_name = bfd_alloc (htab->stub_bfd, len);
3707           if (s_name == NULL)
3708             return NULL;
3709
3710           memcpy (s_name, link_sec->name, namelen);
3711           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3712           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3713           if (stub_sec == NULL)
3714             return NULL;
3715           htab->stub_group[link_sec->id].stub_sec = stub_sec;
3716         }
3717       htab->stub_group[section->id].stub_sec = stub_sec;
3718     }
3719
3720   /* Enter this entry into the linker stub hash table.  */
3721   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3722                                      TRUE, FALSE);
3723   if (stub_entry == NULL)
3724     {
3725       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3726                              section->owner, stub_name);
3727       return NULL;
3728     }
3729
3730   stub_entry->stub_sec = stub_sec;
3731   stub_entry->stub_offset = 0;
3732   stub_entry->id_sec = link_sec;
3733   return stub_entry;
3734 }
3735
3736 /* Create sections for linker generated code.  */
3737
3738 static bfd_boolean
3739 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3740 {
3741   struct ppc_link_hash_table *htab;
3742   flagword flags;
3743
3744   htab = ppc_hash_table (info);
3745
3746   /* Create .sfpr for code to save and restore fp regs.  */
3747   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3748            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3749   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
3750                                                    flags);
3751   if (htab->sfpr == NULL
3752       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3753     return FALSE;
3754
3755   /* Create .glink for lazy dynamic linking support.  */
3756   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3757                                                     flags);
3758   if (htab->glink == NULL
3759       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
3760     return FALSE;
3761
3762   /* Create branch lookup table for plt_branch stubs.  */
3763   if (info->shared)
3764     {
3765       flags = (SEC_ALLOC | SEC_LOAD
3766                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3767       htab->brlt
3768         = bfd_make_section_anyway_with_flags (dynobj, ".data.rel.ro.brlt",
3769                                               flags);
3770     }
3771   else
3772     {
3773       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3774                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3775       htab->brlt
3776         = bfd_make_section_anyway_with_flags (dynobj, ".rodata.brlt", flags);
3777     }
3778
3779   if (htab->brlt == NULL
3780       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
3781     return FALSE;
3782
3783   if (info->shared)
3784     {
3785       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3786                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3787       htab->relbrlt
3788         = bfd_make_section_anyway_with_flags (dynobj, ".rela.data.rel.ro.brlt",
3789                                               flags);
3790     }
3791   else if (info->emitrelocations)
3792     {
3793       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3794                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3795       htab->relbrlt
3796         = bfd_make_section_anyway_with_flags (dynobj, ".rela.rodata.brlt",
3797                                               flags);
3798     }
3799   else
3800     return TRUE;
3801
3802   if (!htab->relbrlt
3803       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3804     return FALSE;
3805
3806   return TRUE;
3807 }
3808
3809 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3810    not already done.  */
3811
3812 static bfd_boolean
3813 create_got_section (bfd *abfd, struct bfd_link_info *info)
3814 {
3815   asection *got, *relgot;
3816   flagword flags;
3817   struct ppc_link_hash_table *htab = ppc_hash_table (info);
3818
3819   if (!htab->got)
3820     {
3821       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
3822         return FALSE;
3823
3824       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
3825       if (!htab->got)
3826         abort ();
3827     }
3828
3829   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3830            | SEC_LINKER_CREATED);
3831
3832   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3833   if (!got
3834       || !bfd_set_section_alignment (abfd, got, 3))
3835     return FALSE;
3836
3837   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
3838                                                flags | SEC_READONLY);
3839   if (!relgot
3840       || ! bfd_set_section_alignment (abfd, relgot, 3))
3841     return FALSE;
3842
3843   ppc64_elf_tdata (abfd)->got = got;
3844   ppc64_elf_tdata (abfd)->relgot = relgot;
3845   return TRUE;
3846 }
3847
3848 /* Create the dynamic sections, and set up shortcuts.  */
3849
3850 static bfd_boolean
3851 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3852 {
3853   struct ppc_link_hash_table *htab;
3854
3855   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3856     return FALSE;
3857
3858   htab = ppc_hash_table (info);
3859   if (!htab->got)
3860     htab->got = bfd_get_section_by_name (dynobj, ".got");
3861   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
3862   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
3863   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
3864   if (!info->shared)
3865     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
3866
3867   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
3868       || (!info->shared && !htab->relbss))
3869     abort ();
3870
3871   return TRUE;
3872 }
3873
3874 /* Merge PLT info on FROM with that on TO.  */
3875
3876 static void
3877 move_plt_plist (struct ppc_link_hash_entry *from,
3878                 struct ppc_link_hash_entry *to)
3879 {
3880   if (from->elf.plt.plist != NULL)
3881     {
3882       if (to->elf.plt.plist != NULL)
3883         {
3884           struct plt_entry **entp;
3885           struct plt_entry *ent;
3886
3887           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
3888             {
3889               struct plt_entry *dent;
3890
3891               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
3892                 if (dent->addend == ent->addend)
3893                   {
3894                     dent->plt.refcount += ent->plt.refcount;
3895                     *entp = ent->next;
3896                     break;
3897                   }
3898               if (dent == NULL)
3899                 entp = &ent->next;
3900             }
3901           *entp = to->elf.plt.plist;
3902         }
3903
3904       to->elf.plt.plist = from->elf.plt.plist;
3905       from->elf.plt.plist = NULL;
3906     }
3907 }
3908
3909 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3910
3911 static void
3912 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
3913                                 struct elf_link_hash_entry *dir,
3914                                 struct elf_link_hash_entry *ind)
3915 {
3916   struct ppc_link_hash_entry *edir, *eind;
3917
3918   edir = (struct ppc_link_hash_entry *) dir;
3919   eind = (struct ppc_link_hash_entry *) ind;
3920
3921   /* Copy over any dynamic relocs we may have on the indirect sym.  */
3922   if (eind->dyn_relocs != NULL)
3923     {
3924       if (edir->dyn_relocs != NULL)
3925         {
3926           struct ppc_dyn_relocs **pp;
3927           struct ppc_dyn_relocs *p;
3928
3929           /* Add reloc counts against the indirect sym to the direct sym
3930              list.  Merge any entries against the same section.  */
3931           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3932             {
3933               struct ppc_dyn_relocs *q;
3934
3935               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3936                 if (q->sec == p->sec)
3937                   {
3938                     q->pc_count += p->pc_count;
3939                     q->count += p->count;
3940                     *pp = p->next;
3941                     break;
3942                   }
3943               if (q == NULL)
3944                 pp = &p->next;
3945             }
3946           *pp = edir->dyn_relocs;
3947         }
3948
3949       edir->dyn_relocs = eind->dyn_relocs;
3950       eind->dyn_relocs = NULL;
3951     }
3952
3953   edir->is_func |= eind->is_func;
3954   edir->is_func_descriptor |= eind->is_func_descriptor;
3955   edir->tls_mask |= eind->tls_mask;
3956
3957   /* If called to transfer flags for a weakdef during processing
3958      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
3959      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
3960   if (!(ELIMINATE_COPY_RELOCS
3961         && eind->elf.root.type != bfd_link_hash_indirect
3962         && edir->elf.dynamic_adjusted))
3963     edir->elf.non_got_ref |= eind->elf.non_got_ref;
3964
3965   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3966   edir->elf.ref_regular |= eind->elf.ref_regular;
3967   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3968   edir->elf.needs_plt |= eind->elf.needs_plt;
3969
3970   /* If we were called to copy over info for a weak sym, that's all.  */
3971   if (eind->elf.root.type != bfd_link_hash_indirect)
3972     return;
3973
3974   /* Copy over got entries that we may have already seen to the
3975      symbol which just became indirect.  */
3976   if (eind->elf.got.glist != NULL)
3977     {
3978       if (edir->elf.got.glist != NULL)
3979         {
3980           struct got_entry **entp;
3981           struct got_entry *ent;
3982
3983           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3984             {
3985               struct got_entry *dent;
3986
3987               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3988                 if (dent->addend == ent->addend
3989                     && dent->owner == ent->owner
3990                     && dent->tls_type == ent->tls_type)
3991                   {
3992                     dent->got.refcount += ent->got.refcount;
3993                     *entp = ent->next;
3994                     break;
3995                   }
3996               if (dent == NULL)
3997                 entp = &ent->next;
3998             }
3999           *entp = edir->elf.got.glist;
4000         }
4001
4002       edir->elf.got.glist = eind->elf.got.glist;
4003       eind->elf.got.glist = NULL;
4004     }
4005
4006   /* And plt entries.  */
4007   move_plt_plist (eind, edir);
4008
4009   if (eind->elf.dynindx != -1)
4010     {
4011       if (edir->elf.dynindx != -1)
4012         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4013                                 edir->elf.dynstr_index);
4014       edir->elf.dynindx = eind->elf.dynindx;
4015       edir->elf.dynstr_index = eind->elf.dynstr_index;
4016       eind->elf.dynindx = -1;
4017       eind->elf.dynstr_index = 0;
4018     }
4019 }
4020
4021 /* Find the function descriptor hash entry from the given function code
4022    hash entry FH.  Link the entries via their OH fields.  */
4023
4024 static struct ppc_link_hash_entry *
4025 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4026 {
4027   struct ppc_link_hash_entry *fdh = fh->oh;
4028
4029   if (fdh == NULL)
4030     {
4031       const char *fd_name = fh->elf.root.root.string + 1;
4032
4033       fdh = (struct ppc_link_hash_entry *)
4034         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4035       if (fdh != NULL)
4036         {
4037           fdh->is_func_descriptor = 1;
4038           fdh->oh = fh;
4039           fh->is_func = 1;
4040           fh->oh = fdh;
4041         }
4042     }
4043
4044   return fdh;
4045 }
4046
4047 /* Make a fake function descriptor sym for the code sym FH.  */
4048
4049 static struct ppc_link_hash_entry *
4050 make_fdh (struct bfd_link_info *info,
4051           struct ppc_link_hash_entry *fh)
4052 {
4053   bfd *abfd;
4054   asymbol *newsym;
4055   struct bfd_link_hash_entry *bh;
4056   struct ppc_link_hash_entry *fdh;
4057
4058   abfd = fh->elf.root.u.undef.abfd;
4059   newsym = bfd_make_empty_symbol (abfd);
4060   newsym->name = fh->elf.root.root.string + 1;
4061   newsym->section = bfd_und_section_ptr;
4062   newsym->value = 0;
4063   newsym->flags = BSF_WEAK;
4064
4065   bh = NULL;
4066   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4067                                          newsym->flags, newsym->section,
4068                                          newsym->value, NULL, FALSE, FALSE,
4069                                          &bh))
4070     return NULL;
4071
4072   fdh = (struct ppc_link_hash_entry *) bh;
4073   fdh->elf.non_elf = 0;
4074   fdh->fake = 1;
4075   fdh->is_func_descriptor = 1;
4076   fdh->oh = fh;
4077   fh->is_func = 1;
4078   fh->oh = fdh;
4079   return fdh;
4080 }
4081
4082 /* Fix function descriptor symbols defined in .opd sections to be
4083    function type.  */
4084
4085 static bfd_boolean
4086 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4087                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
4088                            Elf_Internal_Sym *isym,
4089                            const char **name ATTRIBUTE_UNUSED,
4090                            flagword *flags ATTRIBUTE_UNUSED,
4091                            asection **sec,
4092                            bfd_vma *value ATTRIBUTE_UNUSED)
4093 {
4094   if (*sec != NULL
4095       && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4096     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4097
4098   return TRUE;
4099 }
4100
4101 /* This function makes an old ABI object reference to ".bar" cause the
4102    inclusion of a new ABI object archive that defines "bar".
4103    NAME is a symbol defined in an archive.  Return a symbol in the hash
4104    table that might be satisfied by the archive symbols.  */
4105
4106 static struct elf_link_hash_entry *
4107 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4108                                  struct bfd_link_info *info,
4109                                  const char *name)
4110 {
4111   struct elf_link_hash_entry *h;
4112   char *dot_name;
4113   size_t len;
4114
4115   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4116   if (h != NULL
4117       /* Don't return this sym if it is a fake function descriptor
4118          created by add_symbol_adjust.  */
4119       && !(h->root.type == bfd_link_hash_undefweak
4120            && ((struct ppc_link_hash_entry *) h)->fake))
4121     return h;
4122
4123   if (name[0] == '.')
4124     return h;
4125
4126   len = strlen (name);
4127   dot_name = bfd_alloc (abfd, len + 2);
4128   if (dot_name == NULL)
4129     return (struct elf_link_hash_entry *) 0 - 1;
4130   dot_name[0] = '.';
4131   memcpy (dot_name + 1, name, len + 1);
4132   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4133   bfd_release (abfd, dot_name);
4134   return h;
4135 }
4136
4137 /* This function satisfies all old ABI object references to ".bar" if a
4138    new ABI object defines "bar".  Well, at least, undefined dot symbols
4139    are made weak.  This stops later archive searches from including an
4140    object if we already have a function descriptor definition.  It also
4141    prevents the linker complaining about undefined symbols.
4142    We also check and correct mismatched symbol visibility here.  The
4143    most restrictive visibility of the function descriptor and the
4144    function entry symbol is used.  */
4145
4146 static bfd_boolean
4147 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4148 {
4149   struct ppc_link_hash_table *htab;
4150   struct ppc_link_hash_entry *fdh;
4151
4152   if (eh->elf.root.type == bfd_link_hash_indirect)
4153     return TRUE;
4154
4155   if (eh->elf.root.type == bfd_link_hash_warning)
4156     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4157
4158   if (eh->elf.root.root.string[0] != '.')
4159     abort ();
4160
4161   htab = ppc_hash_table (info);
4162   fdh = get_fdh (eh, htab);
4163   if (fdh == NULL
4164       && !info->relocatable
4165       && (eh->elf.root.type == bfd_link_hash_undefined
4166           || eh->elf.root.type == bfd_link_hash_undefweak)
4167       && eh->elf.ref_regular)
4168     {
4169       /* Make an undefweak function descriptor sym, which is enough to
4170          pull in an --as-needed shared lib, but won't cause link
4171          errors.  Archives are handled elsewhere.  */
4172       fdh = make_fdh (info, eh);
4173       if (fdh == NULL)
4174         return FALSE;
4175       else
4176         fdh->elf.ref_regular = 1;
4177     }
4178   else if (fdh != NULL)
4179     {
4180       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4181       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4182       if (entry_vis < descr_vis)
4183         fdh->elf.other += entry_vis - descr_vis;
4184       else if (entry_vis > descr_vis)
4185         eh->elf.other += descr_vis - entry_vis;
4186
4187       if ((fdh->elf.root.type == bfd_link_hash_defined
4188            || fdh->elf.root.type == bfd_link_hash_defweak)
4189           && eh->elf.root.type == bfd_link_hash_undefined)
4190         {
4191           eh->elf.root.type = bfd_link_hash_undefweak;
4192           eh->was_undefined = 1;
4193           htab->twiddled_syms = 1;
4194         }
4195     }
4196
4197   return TRUE;
4198 }
4199
4200 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4201
4202 static bfd_boolean
4203 ppc64_elf_check_directives (bfd *ibfd, struct bfd_link_info *info)
4204 {
4205   struct ppc_link_hash_table *htab;
4206   struct ppc_link_hash_entry **p, *eh;
4207
4208   htab = ppc_hash_table (info);
4209   if (!is_ppc64_elf_target (htab->elf.root.creator))
4210     return TRUE;
4211
4212   if (is_ppc64_elf_target (ibfd->xvec))
4213     {
4214       p = &htab->dot_syms;
4215       while ((eh = *p) != NULL)
4216         {
4217           *p = NULL;
4218           if (!add_symbol_adjust (eh, info))
4219             return FALSE;
4220           p = &eh->u.next_dot_sym;
4221         }
4222     }
4223
4224   /* Clear the list for non-ppc64 input files.  */
4225   p = &htab->dot_syms;
4226   while ((eh = *p) != NULL)
4227     {
4228       *p = NULL;
4229       p = &eh->u.next_dot_sym;
4230     }
4231
4232   /* We need to fix the undefs list for any syms we have twiddled to
4233      undef_weak.  */
4234   if (htab->twiddled_syms)
4235     {
4236       bfd_link_repair_undef_list (&htab->elf.root);
4237       htab->twiddled_syms = 0;
4238     }
4239   return TRUE;
4240 }
4241
4242 static bfd_boolean
4243 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4244                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4245 {
4246   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4247   char *local_got_tls_masks;
4248
4249   if (local_got_ents == NULL)
4250     {
4251       bfd_size_type size = symtab_hdr->sh_info;
4252
4253       size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4254       local_got_ents = bfd_zalloc (abfd, size);
4255       if (local_got_ents == NULL)
4256         return FALSE;
4257       elf_local_got_ents (abfd) = local_got_ents;
4258     }
4259
4260   if ((tls_type & TLS_EXPLICIT) == 0)
4261     {
4262       struct got_entry *ent;
4263
4264       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4265         if (ent->addend == r_addend
4266             && ent->owner == abfd
4267             && ent->tls_type == tls_type)
4268           break;
4269       if (ent == NULL)
4270         {
4271           bfd_size_type amt = sizeof (*ent);
4272           ent = bfd_alloc (abfd, amt);
4273           if (ent == NULL)
4274             return FALSE;
4275           ent->next = local_got_ents[r_symndx];
4276           ent->addend = r_addend;
4277           ent->owner = abfd;
4278           ent->tls_type = tls_type;
4279           ent->got.refcount = 0;
4280           local_got_ents[r_symndx] = ent;
4281         }
4282       ent->got.refcount += 1;
4283     }
4284
4285   local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4286   local_got_tls_masks[r_symndx] |= tls_type;
4287   return TRUE;
4288 }
4289
4290 static bfd_boolean
4291 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
4292 {
4293   struct plt_entry *ent;
4294
4295   for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4296     if (ent->addend == addend)
4297       break;
4298   if (ent == NULL)
4299     {
4300       bfd_size_type amt = sizeof (*ent);
4301       ent = bfd_alloc (abfd, amt);
4302       if (ent == NULL)
4303         return FALSE;
4304       ent->next = eh->elf.plt.plist;
4305       ent->addend = addend;
4306       ent->plt.refcount = 0;
4307       eh->elf.plt.plist = ent;
4308     }
4309   ent->plt.refcount += 1;
4310   eh->elf.needs_plt = 1;
4311   if (eh->elf.root.root.string[0] == '.'
4312       && eh->elf.root.root.string[1] != '\0')
4313     eh->is_func = 1;
4314   return TRUE;
4315 }
4316
4317 /* Look through the relocs for a section during the first phase, and
4318    calculate needed space in the global offset table, procedure
4319    linkage table, and dynamic reloc sections.  */
4320
4321 static bfd_boolean
4322 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4323                         asection *sec, const Elf_Internal_Rela *relocs)
4324 {
4325   struct ppc_link_hash_table *htab;
4326   Elf_Internal_Shdr *symtab_hdr;
4327   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4328   const Elf_Internal_Rela *rel;
4329   const Elf_Internal_Rela *rel_end;
4330   asection *sreloc;
4331   asection **opd_sym_map;
4332
4333   if (info->relocatable)
4334     return TRUE;
4335
4336   /* Don't do anything special with non-loaded, non-alloced sections.
4337      In particular, any relocs in such sections should not affect GOT
4338      and PLT reference counting (ie. we don't allow them to create GOT
4339      or PLT entries), there's no possibility or desire to optimize TLS
4340      relocs, and there's not much point in propagating relocs to shared
4341      libs that the dynamic linker won't relocate.  */
4342   if ((sec->flags & SEC_ALLOC) == 0)
4343     return TRUE;
4344
4345   htab = ppc_hash_table (info);
4346   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4347
4348   sym_hashes = elf_sym_hashes (abfd);
4349   sym_hashes_end = (sym_hashes
4350                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4351                     - symtab_hdr->sh_info);
4352
4353   sreloc = NULL;
4354   opd_sym_map = NULL;
4355   if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4356     {
4357       /* Garbage collection needs some extra help with .opd sections.
4358          We don't want to necessarily keep everything referenced by
4359          relocs in .opd, as that would keep all functions.  Instead,
4360          if we reference an .opd symbol (a function descriptor), we
4361          want to keep the function code symbol's section.  This is
4362          easy for global symbols, but for local syms we need to keep
4363          information about the associated function section.  Later, if
4364          edit_opd deletes entries, we'll use this array to adjust
4365          local syms in .opd.  */
4366       union opd_info {
4367         asection *func_section;
4368         long entry_adjust;
4369       };
4370       bfd_size_type amt;
4371
4372       amt = sec->size * sizeof (union opd_info) / 8;
4373       opd_sym_map = bfd_zalloc (abfd, amt);
4374       if (opd_sym_map == NULL)
4375         return FALSE;
4376       ppc64_elf_section_data (sec)->opd.func_sec = opd_sym_map;
4377     }
4378
4379   if (htab->sfpr == NULL
4380       && !create_linkage_sections (htab->elf.dynobj, info))
4381     return FALSE;
4382
4383   rel_end = relocs + sec->reloc_count;
4384   for (rel = relocs; rel < rel_end; rel++)
4385     {
4386       unsigned long r_symndx;
4387       struct elf_link_hash_entry *h;
4388       enum elf_ppc64_reloc_type r_type;
4389       int tls_type = 0;
4390
4391       r_symndx = ELF64_R_SYM (rel->r_info);
4392       if (r_symndx < symtab_hdr->sh_info)
4393         h = NULL;
4394       else
4395         {
4396           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4397           while (h->root.type == bfd_link_hash_indirect
4398                  || h->root.type == bfd_link_hash_warning)
4399             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4400         }
4401
4402       r_type = ELF64_R_TYPE (rel->r_info);
4403       switch (r_type)
4404         {
4405         case R_PPC64_GOT_TLSLD16:
4406         case R_PPC64_GOT_TLSLD16_LO:
4407         case R_PPC64_GOT_TLSLD16_HI:
4408         case R_PPC64_GOT_TLSLD16_HA:
4409           ppc64_tlsld_got (abfd)->refcount += 1;
4410           tls_type = TLS_TLS | TLS_LD;
4411           goto dogottls;
4412
4413         case R_PPC64_GOT_TLSGD16:
4414         case R_PPC64_GOT_TLSGD16_LO:
4415         case R_PPC64_GOT_TLSGD16_HI:
4416         case R_PPC64_GOT_TLSGD16_HA:
4417           tls_type = TLS_TLS | TLS_GD;
4418           goto dogottls;
4419
4420         case R_PPC64_GOT_TPREL16_DS:
4421         case R_PPC64_GOT_TPREL16_LO_DS:
4422         case R_PPC64_GOT_TPREL16_HI:
4423         case R_PPC64_GOT_TPREL16_HA:
4424           if (info->shared)
4425             info->flags |= DF_STATIC_TLS;
4426           tls_type = TLS_TLS | TLS_TPREL;
4427           goto dogottls;
4428
4429         case R_PPC64_GOT_DTPREL16_DS:
4430         case R_PPC64_GOT_DTPREL16_LO_DS:
4431         case R_PPC64_GOT_DTPREL16_HI:
4432         case R_PPC64_GOT_DTPREL16_HA:
4433           tls_type = TLS_TLS | TLS_DTPREL;
4434         dogottls:
4435           sec->has_tls_reloc = 1;
4436           /* Fall thru */
4437
4438         case R_PPC64_GOT16:
4439         case R_PPC64_GOT16_DS:
4440         case R_PPC64_GOT16_HA:
4441         case R_PPC64_GOT16_HI:
4442         case R_PPC64_GOT16_LO:
4443         case R_PPC64_GOT16_LO_DS:
4444           /* This symbol requires a global offset table entry.  */
4445           sec->has_toc_reloc = 1;
4446           if (ppc64_elf_tdata (abfd)->got == NULL
4447               && !create_got_section (abfd, info))
4448             return FALSE;
4449
4450           if (h != NULL)
4451             {
4452               struct ppc_link_hash_entry *eh;
4453               struct got_entry *ent;
4454
4455               eh = (struct ppc_link_hash_entry *) h;
4456               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4457                 if (ent->addend == rel->r_addend
4458                     && ent->owner == abfd
4459                     && ent->tls_type == tls_type)
4460                   break;
4461               if (ent == NULL)
4462                 {
4463                   bfd_size_type amt = sizeof (*ent);
4464                   ent = bfd_alloc (abfd, amt);
4465                   if (ent == NULL)
4466                     return FALSE;
4467                   ent->next = eh->elf.got.glist;
4468                   ent->addend = rel->r_addend;
4469                   ent->owner = abfd;
4470                   ent->tls_type = tls_type;
4471                   ent->got.refcount = 0;
4472                   eh->elf.got.glist = ent;
4473                 }
4474               ent->got.refcount += 1;
4475               eh->tls_mask |= tls_type;
4476             }
4477           else
4478             /* This is a global offset table entry for a local symbol.  */
4479             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4480                                         rel->r_addend, tls_type))
4481               return FALSE;
4482           break;
4483
4484         case R_PPC64_PLT16_HA:
4485         case R_PPC64_PLT16_HI:
4486         case R_PPC64_PLT16_LO:
4487         case R_PPC64_PLT32:
4488         case R_PPC64_PLT64:
4489           /* This symbol requires a procedure linkage table entry.  We
4490              actually build the entry in adjust_dynamic_symbol,
4491              because this might be a case of linking PIC code without
4492              linking in any dynamic objects, in which case we don't
4493              need to generate a procedure linkage table after all.  */
4494           if (h == NULL)
4495             {
4496               /* It does not make sense to have a procedure linkage
4497                  table entry for a local symbol.  */
4498               bfd_set_error (bfd_error_bad_value);
4499               return FALSE;
4500             }
4501           else
4502             if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4503                                   rel->r_addend))
4504               return FALSE;
4505           break;
4506
4507           /* The following relocations don't need to propagate the
4508              relocation if linking a shared object since they are
4509              section relative.  */
4510         case R_PPC64_SECTOFF:
4511         case R_PPC64_SECTOFF_LO:
4512         case R_PPC64_SECTOFF_HI:
4513         case R_PPC64_SECTOFF_HA:
4514         case R_PPC64_SECTOFF_DS:
4515         case R_PPC64_SECTOFF_LO_DS:
4516         case R_PPC64_DTPREL16:
4517         case R_PPC64_DTPREL16_LO:
4518         case R_PPC64_DTPREL16_HI:
4519         case R_PPC64_DTPREL16_HA:
4520         case R_PPC64_DTPREL16_DS:
4521         case R_PPC64_DTPREL16_LO_DS:
4522         case R_PPC64_DTPREL16_HIGHER:
4523         case R_PPC64_DTPREL16_HIGHERA:
4524         case R_PPC64_DTPREL16_HIGHEST:
4525         case R_PPC64_DTPREL16_HIGHESTA:
4526           break;
4527
4528           /* Nor do these.  */
4529         case R_PPC64_TOC16:
4530         case R_PPC64_TOC16_LO:
4531         case R_PPC64_TOC16_HI:
4532         case R_PPC64_TOC16_HA:
4533         case R_PPC64_TOC16_DS:
4534         case R_PPC64_TOC16_LO_DS:
4535           sec->has_toc_reloc = 1;
4536           break;
4537
4538           /* This relocation describes the C++ object vtable hierarchy.
4539              Reconstruct it for later use during GC.  */
4540         case R_PPC64_GNU_VTINHERIT:
4541           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4542             return FALSE;
4543           break;
4544
4545           /* This relocation describes which C++ vtable entries are actually
4546              used.  Record for later use during GC.  */
4547         case R_PPC64_GNU_VTENTRY:
4548           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4549             return FALSE;
4550           break;
4551
4552         case R_PPC64_REL14:
4553         case R_PPC64_REL14_BRTAKEN:
4554         case R_PPC64_REL14_BRNTAKEN:
4555           {
4556             asection *dest = NULL;
4557
4558             /* Heuristic: If jumping outside our section, chances are
4559                we are going to need a stub.  */
4560             if (h != NULL)
4561               {
4562                 /* If the sym is weak it may be overridden later, so
4563                    don't assume we know where a weak sym lives.  */
4564                 if (h->root.type == bfd_link_hash_defined)
4565                   dest = h->root.u.def.section;
4566               }
4567             else
4568               dest = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4569                                                 sec, r_symndx);
4570             if (dest != sec)
4571               htab->has_14bit_branch = 1;
4572           }
4573           /* Fall through.  */
4574
4575         case R_PPC64_REL24:
4576           if (h != NULL)
4577             {
4578               /* We may need a .plt entry if the function this reloc
4579                  refers to is in a shared lib.  */
4580               if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4581                                     rel->r_addend))
4582                 return FALSE;
4583               if (h == &htab->tls_get_addr->elf
4584                   || h == &htab->tls_get_addr_fd->elf)
4585                 sec->has_tls_reloc = 1;
4586               else if (htab->tls_get_addr == NULL
4587                        && CONST_STRNEQ (h->root.root.string, ".__tls_get_addr")
4588                        && (h->root.root.string[15] == 0
4589                            || h->root.root.string[15] == '@'))
4590                 {
4591                   htab->tls_get_addr = (struct ppc_link_hash_entry *) h;
4592                   sec->has_tls_reloc = 1;
4593                 }
4594               else if (htab->tls_get_addr_fd == NULL
4595                        && CONST_STRNEQ (h->root.root.string, "__tls_get_addr")
4596                        && (h->root.root.string[14] == 0
4597                            || h->root.root.string[14] == '@'))
4598                 {
4599                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) h;
4600                   sec->has_tls_reloc = 1;
4601                 }
4602             }
4603           break;
4604
4605         case R_PPC64_TPREL64:
4606           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4607           if (info->shared)
4608             info->flags |= DF_STATIC_TLS;
4609           goto dotlstoc;
4610
4611         case R_PPC64_DTPMOD64:
4612           if (rel + 1 < rel_end
4613               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4614               && rel[1].r_offset == rel->r_offset + 8)
4615             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4616           else
4617             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4618           goto dotlstoc;
4619
4620         case R_PPC64_DTPREL64:
4621           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4622           if (rel != relocs
4623               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4624               && rel[-1].r_offset == rel->r_offset - 8)
4625             /* This is the second reloc of a dtpmod, dtprel pair.
4626                Don't mark with TLS_DTPREL.  */
4627             goto dodyn;
4628
4629         dotlstoc:
4630           sec->has_tls_reloc = 1;
4631           if (h != NULL)
4632             {
4633               struct ppc_link_hash_entry *eh;
4634               eh = (struct ppc_link_hash_entry *) h;
4635               eh->tls_mask |= tls_type;
4636             }
4637           else
4638             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4639                                         rel->r_addend, tls_type))
4640               return FALSE;
4641
4642           if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4643             {
4644               /* One extra to simplify get_tls_mask.  */
4645               bfd_size_type amt = sec->size * sizeof (unsigned) / 8 + 1;
4646               ppc64_elf_section_data (sec)->t_symndx = bfd_zalloc (abfd, amt);
4647               if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4648                 return FALSE;
4649             }
4650           BFD_ASSERT (rel->r_offset % 8 == 0);
4651           ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8] = r_symndx;
4652
4653           /* Mark the second slot of a GD or LD entry.
4654              -1 to indicate GD and -2 to indicate LD.  */
4655           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4656             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -1;
4657           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4658             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -2;
4659           goto dodyn;
4660
4661         case R_PPC64_TPREL16:
4662         case R_PPC64_TPREL16_LO:
4663         case R_PPC64_TPREL16_HI:
4664         case R_PPC64_TPREL16_HA:
4665         case R_PPC64_TPREL16_DS:
4666         case R_PPC64_TPREL16_LO_DS:
4667         case R_PPC64_TPREL16_HIGHER:
4668         case R_PPC64_TPREL16_HIGHERA:
4669         case R_PPC64_TPREL16_HIGHEST:
4670         case R_PPC64_TPREL16_HIGHESTA:
4671           if (info->shared)
4672             {
4673               info->flags |= DF_STATIC_TLS;
4674               goto dodyn;
4675             }
4676           break;
4677
4678         case R_PPC64_ADDR64:
4679           if (opd_sym_map != NULL
4680               && rel + 1 < rel_end
4681               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
4682             {
4683               if (h != NULL)
4684                 {
4685                   if (h->root.root.string[0] == '.'
4686                       && h->root.root.string[1] != 0
4687                       && get_fdh ((struct ppc_link_hash_entry *) h, htab))
4688                     ;
4689                   else
4690                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
4691                 }
4692               else
4693                 {
4694                   asection *s;
4695
4696                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
4697                                                  r_symndx);
4698                   if (s == NULL)
4699                     return FALSE;
4700                   else if (s != sec)
4701                     opd_sym_map[rel->r_offset / 8] = s;
4702                 }
4703             }
4704           /* Fall through.  */
4705
4706         case R_PPC64_REL30:
4707         case R_PPC64_REL32:
4708         case R_PPC64_REL64:
4709         case R_PPC64_ADDR14:
4710         case R_PPC64_ADDR14_BRNTAKEN:
4711         case R_PPC64_ADDR14_BRTAKEN:
4712         case R_PPC64_ADDR16:
4713         case R_PPC64_ADDR16_DS:
4714         case R_PPC64_ADDR16_HA:
4715         case R_PPC64_ADDR16_HI:
4716         case R_PPC64_ADDR16_HIGHER:
4717         case R_PPC64_ADDR16_HIGHERA:
4718         case R_PPC64_ADDR16_HIGHEST:
4719         case R_PPC64_ADDR16_HIGHESTA:
4720         case R_PPC64_ADDR16_LO:
4721         case R_PPC64_ADDR16_LO_DS:
4722         case R_PPC64_ADDR24:
4723         case R_PPC64_ADDR32:
4724         case R_PPC64_UADDR16:
4725         case R_PPC64_UADDR32:
4726         case R_PPC64_UADDR64:
4727         case R_PPC64_TOC:
4728           if (h != NULL && !info->shared)
4729             /* We may need a copy reloc.  */
4730             h->non_got_ref = 1;
4731
4732           /* Don't propagate .opd relocs.  */
4733           if (NO_OPD_RELOCS && opd_sym_map != NULL)
4734             break;
4735
4736           /* If we are creating a shared library, and this is a reloc
4737              against a global symbol, or a non PC relative reloc
4738              against a local symbol, then we need to copy the reloc
4739              into the shared library.  However, if we are linking with
4740              -Bsymbolic, we do not need to copy a reloc against a
4741              global symbol which is defined in an object we are
4742              including in the link (i.e., DEF_REGULAR is set).  At
4743              this point we have not seen all the input files, so it is
4744              possible that DEF_REGULAR is not set now but will be set
4745              later (it is never cleared).  In case of a weak definition,
4746              DEF_REGULAR may be cleared later by a strong definition in
4747              a shared library.  We account for that possibility below by
4748              storing information in the dyn_relocs field of the hash
4749              table entry.  A similar situation occurs when creating
4750              shared libraries and symbol visibility changes render the
4751              symbol local.
4752
4753              If on the other hand, we are creating an executable, we
4754              may need to keep relocations for symbols satisfied by a
4755              dynamic library if we manage to avoid copy relocs for the
4756              symbol.  */
4757         dodyn:
4758           if ((info->shared
4759                && (MUST_BE_DYN_RELOC (r_type)
4760                    || (h != NULL
4761                        && (! info->symbolic
4762                            || h->root.type == bfd_link_hash_defweak
4763                            || !h->def_regular))))
4764               || (ELIMINATE_COPY_RELOCS
4765                   && !info->shared
4766                   && h != NULL
4767                   && (h->root.type == bfd_link_hash_defweak
4768                       || !h->def_regular)))
4769             {
4770               struct ppc_dyn_relocs *p;
4771               struct ppc_dyn_relocs **head;
4772
4773               /* We must copy these reloc types into the output file.
4774                  Create a reloc section in dynobj and make room for
4775                  this reloc.  */
4776               if (sreloc == NULL)
4777                 {
4778                   const char *name;
4779                   bfd *dynobj;
4780
4781                   name = (bfd_elf_string_from_elf_section
4782                           (abfd,
4783                            elf_elfheader (abfd)->e_shstrndx,
4784                            elf_section_data (sec)->rel_hdr.sh_name));
4785                   if (name == NULL)
4786                     return FALSE;
4787
4788                   if (! CONST_STRNEQ (name, ".rela")
4789                       || strcmp (bfd_get_section_name (abfd, sec),
4790                                  name + 5) != 0)
4791                     {
4792                       (*_bfd_error_handler)
4793                         (_("%B: bad relocation section name `%s\'"),
4794                          abfd, name);
4795                       bfd_set_error (bfd_error_bad_value);
4796                     }
4797
4798                   dynobj = htab->elf.dynobj;
4799                   sreloc = bfd_get_section_by_name (dynobj, name);
4800                   if (sreloc == NULL)
4801                     {
4802                       flagword flags;
4803
4804                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
4805                                | SEC_IN_MEMORY | SEC_LINKER_CREATED
4806                                | SEC_ALLOC | SEC_LOAD);
4807                       sreloc = bfd_make_section_with_flags (dynobj,
4808                                                             name,
4809                                                             flags);
4810                       if (sreloc == NULL
4811                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
4812                         return FALSE;
4813                     }
4814                   elf_section_data (sec)->sreloc = sreloc;
4815                 }
4816
4817               /* If this is a global symbol, we count the number of
4818                  relocations we need for this symbol.  */
4819               if (h != NULL)
4820                 {
4821                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
4822                 }
4823               else
4824                 {
4825                   /* Track dynamic relocs needed for local syms too.
4826                      We really need local syms available to do this
4827                      easily.  Oh well.  */
4828
4829                   asection *s;
4830                   void *vpp;
4831
4832                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4833                                                  sec, r_symndx);
4834                   if (s == NULL)
4835                     return FALSE;
4836
4837                   vpp = &elf_section_data (s)->local_dynrel;
4838                   head = (struct ppc_dyn_relocs **) vpp;
4839                 }
4840
4841               p = *head;
4842               if (p == NULL || p->sec != sec)
4843                 {
4844                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4845                   if (p == NULL)
4846                     return FALSE;
4847                   p->next = *head;
4848                   *head = p;
4849                   p->sec = sec;
4850                   p->count = 0;
4851                   p->pc_count = 0;
4852                 }
4853
4854               p->count += 1;
4855               if (!MUST_BE_DYN_RELOC (r_type))
4856                 p->pc_count += 1;
4857             }
4858           break;
4859
4860         default:
4861           break;
4862         }
4863     }
4864
4865   return TRUE;
4866 }
4867
4868 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
4869    of the code entry point, and its section.  */
4870
4871 static bfd_vma
4872 opd_entry_value (asection *opd_sec,
4873                  bfd_vma offset,
4874                  asection **code_sec,
4875                  bfd_vma *code_off)
4876 {
4877   bfd *opd_bfd = opd_sec->owner;
4878   Elf_Internal_Rela *relocs;
4879   Elf_Internal_Rela *lo, *hi, *look;
4880   bfd_vma val;
4881
4882   /* No relocs implies we are linking a --just-symbols object.  */
4883   if (opd_sec->reloc_count == 0)
4884     {
4885       bfd_vma val;
4886
4887       if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
4888         return (bfd_vma) -1;
4889
4890       if (code_sec != NULL)
4891         {
4892           asection *sec, *likely = NULL;
4893           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
4894             if (sec->vma <= val
4895                 && (sec->flags & SEC_LOAD) != 0
4896                 && (sec->flags & SEC_ALLOC) != 0)
4897               likely = sec;
4898           if (likely != NULL)
4899             {
4900               *code_sec = likely;
4901               if (code_off != NULL)
4902                 *code_off = val - likely->vma;
4903             }
4904         }
4905       return val;
4906     }
4907
4908   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
4909   if (relocs == NULL)
4910     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
4911
4912   /* Go find the opd reloc at the sym address.  */
4913   lo = relocs;
4914   BFD_ASSERT (lo != NULL);
4915   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
4916   val = (bfd_vma) -1;
4917   while (lo < hi)
4918     {
4919       look = lo + (hi - lo) / 2;
4920       if (look->r_offset < offset)
4921         lo = look + 1;
4922       else if (look->r_offset > offset)
4923         hi = look;
4924       else
4925         {
4926           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (opd_bfd)->symtab_hdr;
4927           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
4928               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
4929             {
4930               unsigned long symndx = ELF64_R_SYM (look->r_info);
4931               asection *sec;
4932
4933               if (symndx < symtab_hdr->sh_info)
4934                 {
4935                   Elf_Internal_Sym *sym;
4936
4937                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
4938                   if (sym == NULL)
4939                     {
4940                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
4941                                                   symtab_hdr->sh_info,
4942                                                   0, NULL, NULL, NULL);
4943                       if (sym == NULL)
4944                         break;
4945                       symtab_hdr->contents = (bfd_byte *) sym;
4946                     }
4947
4948                   sym += symndx;
4949                   val = sym->st_value;
4950                   sec = NULL;
4951                   if ((sym->st_shndx != SHN_UNDEF
4952                        && sym->st_shndx < SHN_LORESERVE)
4953                       || sym->st_shndx > SHN_HIRESERVE)
4954                     sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
4955                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
4956                 }
4957               else
4958                 {
4959                   struct elf_link_hash_entry **sym_hashes;
4960                   struct elf_link_hash_entry *rh;
4961
4962                   sym_hashes = elf_sym_hashes (opd_bfd);
4963                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
4964                   while (rh->root.type == bfd_link_hash_indirect
4965                          || rh->root.type == bfd_link_hash_warning)
4966                     rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
4967                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
4968                               || rh->root.type == bfd_link_hash_defweak);
4969                   val = rh->root.u.def.value;
4970                   sec = rh->root.u.def.section;
4971                 }
4972               val += look->r_addend;
4973               if (code_off != NULL)
4974                 *code_off = val;
4975               if (code_sec != NULL)
4976                 *code_sec = sec;
4977               if (sec != NULL && sec->output_section != NULL)
4978                 val += sec->output_section->vma + sec->output_offset;
4979             }
4980           break;
4981         }
4982     }
4983
4984   return val;
4985 }
4986
4987 /* Mark sections containing dynamically referenced symbols.  When
4988    building shared libraries, we must assume that any visible symbol is
4989    referenced.  */
4990
4991 static bfd_boolean
4992 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
4993 {
4994   struct bfd_link_info *info = (struct bfd_link_info *) inf;
4995   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
4996
4997   if (eh->elf.root.type == bfd_link_hash_warning)
4998     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4999
5000   /* Dynamic linking info is on the func descriptor sym.  */
5001   if (eh->oh != NULL
5002       && eh->oh->is_func_descriptor
5003       && (eh->oh->elf.root.type == bfd_link_hash_defined
5004           || eh->oh->elf.root.type == bfd_link_hash_defweak))
5005     eh = eh->oh;
5006
5007   if ((eh->elf.root.type == bfd_link_hash_defined
5008        || eh->elf.root.type == bfd_link_hash_defweak)
5009       && (eh->elf.ref_dynamic
5010           || (!info->executable
5011               && eh->elf.def_regular
5012               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5013               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5014     {
5015       asection *code_sec;
5016
5017       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5018
5019       /* Function descriptor syms cause the associated
5020          function code sym section to be marked.  */
5021       if (eh->is_func_descriptor
5022           && (eh->oh->elf.root.type == bfd_link_hash_defined
5023               || eh->oh->elf.root.type == bfd_link_hash_defweak))
5024         eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
5025       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5026                && opd_entry_value (eh->elf.root.u.def.section,
5027                                    eh->elf.root.u.def.value,
5028                                    &code_sec, NULL) != (bfd_vma) -1)
5029         code_sec->flags |= SEC_KEEP;
5030     }
5031
5032   return TRUE;
5033 }
5034
5035 /* Return the section that should be marked against GC for a given
5036    relocation.  */
5037
5038 static asection *
5039 ppc64_elf_gc_mark_hook (asection *sec,
5040                         struct bfd_link_info *info,
5041                         Elf_Internal_Rela *rel,
5042                         struct elf_link_hash_entry *h,
5043                         Elf_Internal_Sym *sym)
5044 {
5045   asection *rsec;
5046
5047   /* First mark all our entry sym sections.  */
5048   if (info->gc_sym_list != NULL)
5049     {
5050       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5051       struct bfd_sym_chain *sym = info->gc_sym_list;
5052
5053       info->gc_sym_list = NULL;
5054       for (; sym != NULL; sym = sym->next)
5055         {
5056           struct ppc_link_hash_entry *eh;
5057
5058           eh = (struct ppc_link_hash_entry *)
5059             elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5060           if (eh == NULL)
5061             continue;
5062           if (eh->elf.root.type != bfd_link_hash_defined
5063               && eh->elf.root.type != bfd_link_hash_defweak)
5064             continue;
5065
5066           if (eh->is_func_descriptor
5067               && (eh->oh->elf.root.type == bfd_link_hash_defined
5068                   || eh->oh->elf.root.type == bfd_link_hash_defweak))
5069             rsec = eh->oh->elf.root.u.def.section;
5070           else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5071                    && opd_entry_value (eh->elf.root.u.def.section,
5072                                        eh->elf.root.u.def.value,
5073                                        &rsec, NULL) != (bfd_vma) -1)
5074             ;
5075           else
5076             continue;
5077
5078           if (!rsec->gc_mark)
5079             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5080
5081           rsec = eh->elf.root.u.def.section;
5082           if (!rsec->gc_mark)
5083             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5084         }
5085     }
5086
5087   /* Syms return NULL if we're marking .opd, so we avoid marking all
5088      function sections, as all functions are referenced in .opd.  */
5089   rsec = NULL;
5090   if (get_opd_info (sec) != NULL)
5091     return rsec;
5092
5093   if (h != NULL)
5094     {
5095       enum elf_ppc64_reloc_type r_type;
5096       struct ppc_link_hash_entry *eh;
5097
5098       r_type = ELF64_R_TYPE (rel->r_info);
5099       switch (r_type)
5100         {
5101         case R_PPC64_GNU_VTINHERIT:
5102         case R_PPC64_GNU_VTENTRY:
5103           break;
5104
5105         default:
5106           switch (h->root.type)
5107             {
5108             case bfd_link_hash_defined:
5109             case bfd_link_hash_defweak:
5110               eh = (struct ppc_link_hash_entry *) h;
5111               if (eh->oh != NULL
5112                   && eh->oh->is_func_descriptor
5113                   && (eh->oh->elf.root.type == bfd_link_hash_defined
5114                       || eh->oh->elf.root.type == bfd_link_hash_defweak))
5115                 eh = eh->oh;
5116
5117               /* Function descriptor syms cause the associated
5118                  function code sym section to be marked.  */
5119               if (eh->is_func_descriptor
5120                   && (eh->oh->elf.root.type == bfd_link_hash_defined
5121                       || eh->oh->elf.root.type == bfd_link_hash_defweak))
5122                 {
5123                   /* They also mark their opd section.  */
5124                   if (!eh->elf.root.u.def.section->gc_mark)
5125                     _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
5126                                       ppc64_elf_gc_mark_hook);
5127
5128                   rsec = eh->oh->elf.root.u.def.section;
5129                 }
5130               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5131                        && opd_entry_value (eh->elf.root.u.def.section,
5132                                            eh->elf.root.u.def.value,
5133                                            &rsec, NULL) != (bfd_vma) -1)
5134                 {
5135                   if (!eh->elf.root.u.def.section->gc_mark)
5136                     _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
5137                                       ppc64_elf_gc_mark_hook);
5138                 }
5139               else
5140                 rsec = h->root.u.def.section;
5141               break;
5142
5143             case bfd_link_hash_common:
5144               rsec = h->root.u.c.p->section;
5145               break;
5146
5147             default:
5148               break;
5149             }
5150         }
5151     }
5152   else
5153     {
5154       asection **opd_sym_section;
5155
5156       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5157       opd_sym_section = get_opd_info (rsec);
5158       if (opd_sym_section != NULL)
5159         {
5160           if (!rsec->gc_mark)
5161             _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5162
5163           rsec = opd_sym_section[(sym->st_value + rel->r_addend) / 8];
5164         }
5165     }
5166
5167   return rsec;
5168 }
5169
5170 /* Update the .got, .plt. and dynamic reloc reference counts for the
5171    section being removed.  */
5172
5173 static bfd_boolean
5174 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5175                          asection *sec, const Elf_Internal_Rela *relocs)
5176 {
5177   struct ppc_link_hash_table *htab;
5178   Elf_Internal_Shdr *symtab_hdr;
5179   struct elf_link_hash_entry **sym_hashes;
5180   struct got_entry **local_got_ents;
5181   const Elf_Internal_Rela *rel, *relend;
5182
5183   if ((sec->flags & SEC_ALLOC) == 0)
5184     return TRUE;
5185
5186   elf_section_data (sec)->local_dynrel = NULL;
5187
5188   htab = ppc_hash_table (info);
5189   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5190   sym_hashes = elf_sym_hashes (abfd);
5191   local_got_ents = elf_local_got_ents (abfd);
5192
5193   relend = relocs + sec->reloc_count;
5194   for (rel = relocs; rel < relend; rel++)
5195     {
5196       unsigned long r_symndx;
5197       enum elf_ppc64_reloc_type r_type;
5198       struct elf_link_hash_entry *h = NULL;
5199       char tls_type = 0;
5200
5201       r_symndx = ELF64_R_SYM (rel->r_info);
5202       r_type = ELF64_R_TYPE (rel->r_info);
5203       if (r_symndx >= symtab_hdr->sh_info)
5204         {
5205           struct ppc_link_hash_entry *eh;
5206           struct ppc_dyn_relocs **pp;
5207           struct ppc_dyn_relocs *p;
5208
5209           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5210           while (h->root.type == bfd_link_hash_indirect
5211                  || h->root.type == bfd_link_hash_warning)
5212             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5213           eh = (struct ppc_link_hash_entry *) h;
5214
5215           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5216             if (p->sec == sec)
5217               {
5218                 /* Everything must go for SEC.  */
5219                 *pp = p->next;
5220                 break;
5221               }
5222         }
5223
5224       switch (r_type)
5225         {
5226         case R_PPC64_GOT_TLSLD16:
5227         case R_PPC64_GOT_TLSLD16_LO:
5228         case R_PPC64_GOT_TLSLD16_HI:
5229         case R_PPC64_GOT_TLSLD16_HA:
5230           ppc64_tlsld_got (abfd)->refcount -= 1;
5231           tls_type = TLS_TLS | TLS_LD;
5232           goto dogot;
5233
5234         case R_PPC64_GOT_TLSGD16:
5235         case R_PPC64_GOT_TLSGD16_LO:
5236         case R_PPC64_GOT_TLSGD16_HI:
5237         case R_PPC64_GOT_TLSGD16_HA:
5238           tls_type = TLS_TLS | TLS_GD;
5239           goto dogot;
5240
5241         case R_PPC64_GOT_TPREL16_DS:
5242         case R_PPC64_GOT_TPREL16_LO_DS:
5243         case R_PPC64_GOT_TPREL16_HI:
5244         case R_PPC64_GOT_TPREL16_HA:
5245           tls_type = TLS_TLS | TLS_TPREL;
5246           goto dogot;
5247
5248         case R_PPC64_GOT_DTPREL16_DS:
5249         case R_PPC64_GOT_DTPREL16_LO_DS:
5250         case R_PPC64_GOT_DTPREL16_HI:
5251         case R_PPC64_GOT_DTPREL16_HA:
5252           tls_type = TLS_TLS | TLS_DTPREL;
5253           goto dogot;
5254
5255         case R_PPC64_GOT16:
5256         case R_PPC64_GOT16_DS:
5257         case R_PPC64_GOT16_HA:
5258         case R_PPC64_GOT16_HI:
5259         case R_PPC64_GOT16_LO:
5260         case R_PPC64_GOT16_LO_DS:
5261         dogot:
5262           {
5263             struct got_entry *ent;
5264
5265             if (h != NULL)
5266               ent = h->got.glist;
5267             else
5268               ent = local_got_ents[r_symndx];
5269
5270             for (; ent != NULL; ent = ent->next)
5271               if (ent->addend == rel->r_addend
5272                   && ent->owner == abfd
5273                   && ent->tls_type == tls_type)
5274                 break;
5275             if (ent == NULL)
5276               abort ();
5277             if (ent->got.refcount > 0)
5278               ent->got.refcount -= 1;
5279           }
5280           break;
5281
5282         case R_PPC64_PLT16_HA:
5283         case R_PPC64_PLT16_HI:
5284         case R_PPC64_PLT16_LO:
5285         case R_PPC64_PLT32:
5286         case R_PPC64_PLT64:
5287         case R_PPC64_REL14:
5288         case R_PPC64_REL14_BRNTAKEN:
5289         case R_PPC64_REL14_BRTAKEN:
5290         case R_PPC64_REL24:
5291           if (h != NULL)
5292             {
5293               struct plt_entry *ent;
5294
5295               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5296                 if (ent->addend == rel->r_addend)
5297                   break;
5298               if (ent == NULL)
5299                 abort ();
5300               if (ent->plt.refcount > 0)
5301                 ent->plt.refcount -= 1;
5302             }
5303           break;
5304
5305         default:
5306           break;
5307         }
5308     }
5309   return TRUE;
5310 }
5311
5312 /* The maximum size of .sfpr.  */
5313 #define SFPR_MAX (218*4)
5314
5315 struct sfpr_def_parms
5316 {
5317   const char name[12];
5318   unsigned char lo, hi;
5319   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5320   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5321 };
5322
5323 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5324
5325 static unsigned int
5326 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5327 {
5328   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5329   unsigned int i;
5330   size_t len = strlen (parm->name);
5331   bfd_boolean writing = FALSE;
5332   char sym[16];
5333
5334   memcpy (sym, parm->name, len);
5335   sym[len + 2] = 0;
5336
5337   for (i = parm->lo; i <= parm->hi; i++)
5338     {
5339       struct elf_link_hash_entry *h;
5340
5341       sym[len + 0] = i / 10 + '0';
5342       sym[len + 1] = i % 10 + '0';
5343       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5344       if (h != NULL
5345           && !h->def_regular)
5346         {
5347           h->root.type = bfd_link_hash_defined;
5348           h->root.u.def.section = htab->sfpr;
5349           h->root.u.def.value = htab->sfpr->size;
5350           h->type = STT_FUNC;
5351           h->def_regular = 1;
5352           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5353           writing = TRUE;
5354           if (htab->sfpr->contents == NULL)
5355             {
5356               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5357               if (htab->sfpr->contents == NULL)
5358                 return FALSE;
5359             }
5360         }
5361       if (writing)
5362         {
5363           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5364           if (i != parm->hi)
5365             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5366           else
5367             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5368           htab->sfpr->size = p - htab->sfpr->contents;
5369         }
5370     }
5371
5372   return TRUE;
5373 }
5374
5375 static bfd_byte *
5376 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5377 {
5378   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5379   return p + 4;
5380 }
5381
5382 static bfd_byte *
5383 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5384 {
5385   p = savegpr0 (abfd, p, r);
5386   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5387   p = p + 4;
5388   bfd_put_32 (abfd, BLR, p);
5389   return p + 4;
5390 }
5391
5392 static bfd_byte *
5393 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5394 {
5395   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5396   return p + 4;
5397 }
5398
5399 static bfd_byte *
5400 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5401 {
5402   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5403   p = p + 4;
5404   p = restgpr0 (abfd, p, r);
5405   bfd_put_32 (abfd, MTLR_R0, p);
5406   p = p + 4;
5407   if (r == 29)
5408     {
5409       p = restgpr0 (abfd, p, 30);
5410       p = restgpr0 (abfd, p, 31);
5411     }
5412   bfd_put_32 (abfd, BLR, p);
5413   return p + 4;
5414 }
5415
5416 static bfd_byte *
5417 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5418 {
5419   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5420   return p + 4;
5421 }
5422
5423 static bfd_byte *
5424 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5425 {
5426   p = savegpr1 (abfd, p, r);
5427   bfd_put_32 (abfd, BLR, p);
5428   return p + 4;
5429 }
5430
5431 static bfd_byte *
5432 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5433 {
5434   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5435   return p + 4;
5436 }
5437
5438 static bfd_byte *
5439 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5440 {
5441   p = restgpr1 (abfd, p, r);
5442   bfd_put_32 (abfd, BLR, p);
5443   return p + 4;
5444 }
5445
5446 static bfd_byte *
5447 savefpr (bfd *abfd, bfd_byte *p, int r)
5448 {
5449   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5450   return p + 4;
5451 }
5452
5453 static bfd_byte *
5454 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5455 {
5456   p = savefpr (abfd, p, r);
5457   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5458   p = p + 4;
5459   bfd_put_32 (abfd, BLR, p);
5460   return p + 4;
5461 }
5462
5463 static bfd_byte *
5464 restfpr (bfd *abfd, bfd_byte *p, int r)
5465 {
5466   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5467   return p + 4;
5468 }
5469
5470 static bfd_byte *
5471 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5472 {
5473   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5474   p = p + 4;
5475   p = restfpr (abfd, p, r);
5476   bfd_put_32 (abfd, MTLR_R0, p);
5477   p = p + 4;
5478   if (r == 29)
5479     {
5480       p = restfpr (abfd, p, 30);
5481       p = restfpr (abfd, p, 31);
5482     }
5483   bfd_put_32 (abfd, BLR, p);
5484   return p + 4;
5485 }
5486
5487 static bfd_byte *
5488 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5489 {
5490   p = savefpr (abfd, p, r);
5491   bfd_put_32 (abfd, BLR, p);
5492   return p + 4;
5493 }
5494
5495 static bfd_byte *
5496 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5497 {
5498   p = restfpr (abfd, p, r);
5499   bfd_put_32 (abfd, BLR, p);
5500   return p + 4;
5501 }
5502
5503 static bfd_byte *
5504 savevr (bfd *abfd, bfd_byte *p, int r)
5505 {
5506   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5507   p = p + 4;
5508   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5509   return p + 4;
5510 }
5511
5512 static bfd_byte *
5513 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5514 {
5515   p = savevr (abfd, p, r);
5516   bfd_put_32 (abfd, BLR, p);
5517   return p + 4;
5518 }
5519
5520 static bfd_byte *
5521 restvr (bfd *abfd, bfd_byte *p, int r)
5522 {
5523   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5524   p = p + 4;
5525   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5526   return p + 4;
5527 }
5528
5529 static bfd_byte *
5530 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5531 {
5532   p = restvr (abfd, p, r);
5533   bfd_put_32 (abfd, BLR, p);
5534   return p + 4;
5535 }
5536
5537 /* Called via elf_link_hash_traverse to transfer dynamic linking
5538    information on function code symbol entries to their corresponding
5539    function descriptor symbol entries.  */
5540
5541 static bfd_boolean
5542 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5543 {
5544   struct bfd_link_info *info;
5545   struct ppc_link_hash_table *htab;
5546   struct plt_entry *ent;
5547   struct ppc_link_hash_entry *fh;
5548   struct ppc_link_hash_entry *fdh;
5549   bfd_boolean force_local;
5550
5551   fh = (struct ppc_link_hash_entry *) h;
5552   if (fh->elf.root.type == bfd_link_hash_indirect)
5553     return TRUE;
5554
5555   if (fh->elf.root.type == bfd_link_hash_warning)
5556     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5557
5558   info = inf;
5559   htab = ppc_hash_table (info);
5560
5561   /* Resolve undefined references to dot-symbols as the value
5562      in the function descriptor, if we have one in a regular object.
5563      This is to satisfy cases like ".quad .foo".  Calls to functions
5564      in dynamic objects are handled elsewhere.  */
5565   if (fh->elf.root.type == bfd_link_hash_undefweak
5566       && fh->was_undefined
5567       && (fh->oh->elf.root.type == bfd_link_hash_defined
5568           || fh->oh->elf.root.type == bfd_link_hash_defweak)
5569       && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5570       && opd_entry_value (fh->oh->elf.root.u.def.section,
5571                           fh->oh->elf.root.u.def.value,
5572                           &fh->elf.root.u.def.section,
5573                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
5574     {
5575       fh->elf.root.type = fh->oh->elf.root.type;
5576       fh->elf.forced_local = 1;
5577     }
5578
5579   /* If this is a function code symbol, transfer dynamic linking
5580      information to the function descriptor symbol.  */
5581   if (!fh->is_func)
5582     return TRUE;
5583
5584   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
5585     if (ent->plt.refcount > 0)
5586       break;
5587   if (ent == NULL
5588       || fh->elf.root.root.string[0] != '.'
5589       || fh->elf.root.root.string[1] == '\0')
5590     return TRUE;
5591
5592   /* Find the corresponding function descriptor symbol.  Create it
5593      as undefined if necessary.  */
5594
5595   fdh = get_fdh (fh, htab);
5596   if (fdh != NULL)
5597     while (fdh->elf.root.type == bfd_link_hash_indirect
5598            || fdh->elf.root.type == bfd_link_hash_warning)
5599       fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5600
5601   if (fdh == NULL
5602       && info->shared
5603       && (fh->elf.root.type == bfd_link_hash_undefined
5604           || fh->elf.root.type == bfd_link_hash_undefweak))
5605     {
5606       fdh = make_fdh (info, fh);
5607       if (fdh == NULL)
5608         return FALSE;
5609     }
5610
5611   /* Fake function descriptors are made undefweak.  If the function
5612      code symbol is strong undefined, make the fake sym the same.
5613      If the function code symbol is defined, then force the fake
5614      descriptor local;  We can't support overriding of symbols in a
5615      shared library on a fake descriptor.  */
5616
5617   if (fdh != NULL
5618       && fdh->fake
5619       && fdh->elf.root.type == bfd_link_hash_undefweak)
5620     {
5621       if (fh->elf.root.type == bfd_link_hash_undefined)
5622         {
5623           fdh->elf.root.type = bfd_link_hash_undefined;
5624           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
5625         }
5626       else if (fh->elf.root.type == bfd_link_hash_defined
5627                || fh->elf.root.type == bfd_link_hash_defweak)
5628         {
5629           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
5630         }
5631     }
5632
5633   if (fdh != NULL
5634       && !fdh->elf.forced_local
5635       && (info->shared
5636           || fdh->elf.def_dynamic
5637           || fdh->elf.ref_dynamic
5638           || (fdh->elf.root.type == bfd_link_hash_undefweak
5639               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5640     {
5641       if (fdh->elf.dynindx == -1)
5642         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5643           return FALSE;
5644       fdh->elf.ref_regular |= fh->elf.ref_regular;
5645       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5646       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5647       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
5648       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
5649         {
5650           move_plt_plist (fh, fdh);
5651           fdh->elf.needs_plt = 1;
5652         }
5653       fdh->is_func_descriptor = 1;
5654       fdh->oh = fh;
5655       fh->oh = fdh;
5656     }
5657
5658   /* Now that the info is on the function descriptor, clear the
5659      function code sym info.  Any function code syms for which we
5660      don't have a definition in a regular file, we force local.
5661      This prevents a shared library from exporting syms that have
5662      been imported from another library.  Function code syms that
5663      are really in the library we must leave global to prevent the
5664      linker dragging in a definition from a static library.  */
5665   force_local = (!fh->elf.def_regular
5666                  || fdh == NULL
5667                  || !fdh->elf.def_regular
5668                  || fdh->elf.forced_local);
5669   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5670
5671   return TRUE;
5672 }
5673
5674 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
5675    this hook to a) provide some gcc support functions, and b) transfer
5676    dynamic linking information gathered so far on function code symbol
5677    entries, to their corresponding function descriptor symbol entries.  */
5678
5679 static bfd_boolean
5680 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5681                             struct bfd_link_info *info)
5682 {
5683   struct ppc_link_hash_table *htab;
5684   unsigned int i;
5685   const struct sfpr_def_parms funcs[] =
5686     {
5687       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5688       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5689       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5690       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5691       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5692       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5693       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5694       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5695       { "._savef", 14, 31, savefpr, savefpr1_tail },
5696       { "._restf", 14, 31, restfpr, restfpr1_tail },
5697       { "_savevr_", 20, 31, savevr, savevr_tail },
5698       { "_restvr_", 20, 31, restvr, restvr_tail }
5699     };
5700
5701   htab = ppc_hash_table (info);
5702   if (htab->sfpr == NULL)
5703     /* We don't have any relocs.  */
5704     return TRUE;
5705
5706   /* Provide any missing _save* and _rest* functions.  */
5707   htab->sfpr->size = 0;
5708   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5709     if (!sfpr_define (info, &funcs[i]))
5710       return FALSE;
5711
5712   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5713
5714   if (htab->sfpr->size == 0)
5715     htab->sfpr->flags |= SEC_EXCLUDE;
5716
5717   return TRUE;
5718 }
5719
5720 /* Adjust a symbol defined by a dynamic object and referenced by a
5721    regular object.  The current definition is in some section of the
5722    dynamic object, but we're not including those sections.  We have to
5723    change the definition to something the rest of the link can
5724    understand.  */
5725
5726 static bfd_boolean
5727 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5728                                  struct elf_link_hash_entry *h)
5729 {
5730   struct ppc_link_hash_table *htab;
5731   asection *s;
5732   unsigned int power_of_two;
5733
5734   htab = ppc_hash_table (info);
5735
5736   /* Deal with function syms.  */
5737   if (h->type == STT_FUNC
5738       || h->needs_plt)
5739     {
5740       /* Clear procedure linkage table information for any symbol that
5741          won't need a .plt entry.  */
5742       struct plt_entry *ent;
5743       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5744         if (ent->plt.refcount > 0)
5745           break;
5746       if (ent == NULL
5747           || SYMBOL_CALLS_LOCAL (info, h)
5748           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5749               && h->root.type == bfd_link_hash_undefweak))
5750         {
5751           h->plt.plist = NULL;
5752           h->needs_plt = 0;
5753         }
5754     }
5755   else
5756     h->plt.plist = NULL;
5757
5758   /* If this is a weak symbol, and there is a real definition, the
5759      processor independent code will have arranged for us to see the
5760      real definition first, and we can just use the same value.  */
5761   if (h->u.weakdef != NULL)
5762     {
5763       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5764                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5765       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5766       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5767       if (ELIMINATE_COPY_RELOCS)
5768         h->non_got_ref = h->u.weakdef->non_got_ref;
5769       return TRUE;
5770     }
5771
5772   /* If we are creating a shared library, we must presume that the
5773      only references to the symbol are via the global offset table.
5774      For such cases we need not do anything here; the relocations will
5775      be handled correctly by relocate_section.  */
5776   if (info->shared)
5777     return TRUE;
5778
5779   /* If there are no references to this symbol that do not use the
5780      GOT, we don't need to generate a copy reloc.  */
5781   if (!h->non_got_ref)
5782     return TRUE;
5783
5784   if (ELIMINATE_COPY_RELOCS)
5785     {
5786       struct ppc_link_hash_entry * eh;
5787       struct ppc_dyn_relocs *p;
5788
5789       eh = (struct ppc_link_hash_entry *) h;
5790       for (p = eh->dyn_relocs; p != NULL; p = p->next)
5791         {
5792           s = p->sec->output_section;
5793           if (s != NULL && (s->flags & SEC_READONLY) != 0)
5794             break;
5795         }
5796
5797       /* If we didn't find any dynamic relocs in read-only sections, then
5798          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
5799       if (p == NULL)
5800         {
5801           h->non_got_ref = 0;
5802           return TRUE;
5803         }
5804     }
5805
5806   if (h->plt.plist != NULL)
5807     {
5808       /* We should never get here, but unfortunately there are versions
5809          of gcc out there that improperly (for this ABI) put initialized
5810          function pointers, vtable refs and suchlike in read-only
5811          sections.  Allow them to proceed, but warn that this might
5812          break at runtime.  */
5813       (*_bfd_error_handler)
5814         (_("copy reloc against `%s' requires lazy plt linking; "
5815            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
5816          h->root.root.string);
5817     }
5818
5819   /* This is a reference to a symbol defined by a dynamic object which
5820      is not a function.  */
5821
5822   if (h->size == 0)
5823     {
5824       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
5825                              h->root.root.string);
5826       return TRUE;
5827     }
5828
5829   /* We must allocate the symbol in our .dynbss section, which will
5830      become part of the .bss section of the executable.  There will be
5831      an entry for this symbol in the .dynsym section.  The dynamic
5832      object will contain position independent code, so all references
5833      from the dynamic object to this symbol will go through the global
5834      offset table.  The dynamic linker will use the .dynsym entry to
5835      determine the address it must put in the global offset table, so
5836      both the dynamic object and the regular object will refer to the
5837      same memory location for the variable.  */
5838
5839   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
5840      to copy the initial value out of the dynamic object and into the
5841      runtime process image.  We need to remember the offset into the
5842      .rela.bss section we are going to use.  */
5843   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5844     {
5845       htab->relbss->size += sizeof (Elf64_External_Rela);
5846       h->needs_copy = 1;
5847     }
5848
5849   /* We need to figure out the alignment required for this symbol.  I
5850      have no idea how ELF linkers handle this.  */
5851   power_of_two = bfd_log2 (h->size);
5852   if (power_of_two > 4)
5853     power_of_two = 4;
5854
5855   /* Apply the required alignment.  */
5856   s = htab->dynbss;
5857   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5858   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
5859     {
5860       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
5861         return FALSE;
5862     }
5863
5864   /* Define the symbol as being at this point in the section.  */
5865   h->root.u.def.section = s;
5866   h->root.u.def.value = s->size;
5867
5868   /* Increment the section size to make room for the symbol.  */
5869   s->size += h->size;
5870
5871   return TRUE;
5872 }
5873
5874 /* If given a function descriptor symbol, hide both the function code
5875    sym and the descriptor.  */
5876 static void
5877 ppc64_elf_hide_symbol (struct bfd_link_info *info,
5878                        struct elf_link_hash_entry *h,
5879                        bfd_boolean force_local)
5880 {
5881   struct ppc_link_hash_entry *eh;
5882   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
5883
5884   eh = (struct ppc_link_hash_entry *) h;
5885   if (eh->is_func_descriptor)
5886     {
5887       struct ppc_link_hash_entry *fh = eh->oh;
5888
5889       if (fh == NULL)
5890         {
5891           const char *p, *q;
5892           struct ppc_link_hash_table *htab;
5893           char save;
5894
5895           /* We aren't supposed to use alloca in BFD because on
5896              systems which do not have alloca the version in libiberty
5897              calls xmalloc, which might cause the program to crash
5898              when it runs out of memory.  This function doesn't have a
5899              return status, so there's no way to gracefully return an
5900              error.  So cheat.  We know that string[-1] can be safely
5901              accessed;  It's either a string in an ELF string table,
5902              or allocated in an objalloc structure.  */
5903
5904           p = eh->elf.root.root.string - 1;
5905           save = *p;
5906           *(char *) p = '.';
5907           htab = ppc_hash_table (info);
5908           fh = (struct ppc_link_hash_entry *)
5909             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5910           *(char *) p = save;
5911
5912           /* Unfortunately, if it so happens that the string we were
5913              looking for was allocated immediately before this string,
5914              then we overwrote the string terminator.  That's the only
5915              reason the lookup should fail.  */
5916           if (fh == NULL)
5917             {
5918               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
5919               while (q >= eh->elf.root.root.string && *q == *p)
5920                 --q, --p;
5921               if (q < eh->elf.root.root.string && *p == '.')
5922                 fh = (struct ppc_link_hash_entry *)
5923                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5924             }
5925           if (fh != NULL)
5926             {
5927               eh->oh = fh;
5928               fh->oh = eh;
5929             }
5930         }
5931       if (fh != NULL)
5932         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5933     }
5934 }
5935
5936 static bfd_boolean
5937 get_sym_h (struct elf_link_hash_entry **hp,
5938            Elf_Internal_Sym **symp,
5939            asection **symsecp,
5940            char **tls_maskp,
5941            Elf_Internal_Sym **locsymsp,
5942            unsigned long r_symndx,
5943            bfd *ibfd)
5944 {
5945   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5946
5947   if (r_symndx >= symtab_hdr->sh_info)
5948     {
5949       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
5950       struct elf_link_hash_entry *h;
5951
5952       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5953       while (h->root.type == bfd_link_hash_indirect
5954              || h->root.type == bfd_link_hash_warning)
5955         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5956
5957       if (hp != NULL)
5958         *hp = h;
5959
5960       if (symp != NULL)
5961         *symp = NULL;
5962
5963       if (symsecp != NULL)
5964         {
5965           asection *symsec = NULL;
5966           if (h->root.type == bfd_link_hash_defined
5967               || h->root.type == bfd_link_hash_defweak)
5968             symsec = h->root.u.def.section;
5969           *symsecp = symsec;
5970         }
5971
5972       if (tls_maskp != NULL)
5973         {
5974           struct ppc_link_hash_entry *eh;
5975
5976           eh = (struct ppc_link_hash_entry *) h;
5977           *tls_maskp = &eh->tls_mask;
5978         }
5979     }
5980   else
5981     {
5982       Elf_Internal_Sym *sym;
5983       Elf_Internal_Sym *locsyms = *locsymsp;
5984
5985       if (locsyms == NULL)
5986         {
5987           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
5988           if (locsyms == NULL)
5989             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
5990                                             symtab_hdr->sh_info,
5991                                             0, NULL, NULL, NULL);
5992           if (locsyms == NULL)
5993             return FALSE;
5994           *locsymsp = locsyms;
5995         }
5996       sym = locsyms + r_symndx;
5997
5998       if (hp != NULL)
5999         *hp = NULL;
6000
6001       if (symp != NULL)
6002         *symp = sym;
6003
6004       if (symsecp != NULL)
6005         {
6006           asection *symsec = NULL;
6007           if ((sym->st_shndx != SHN_UNDEF
6008                && sym->st_shndx < SHN_LORESERVE)
6009               || sym->st_shndx > SHN_HIRESERVE)
6010             symsec = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6011           *symsecp = symsec;
6012         }
6013
6014       if (tls_maskp != NULL)
6015         {
6016           struct got_entry **lgot_ents;
6017           char *tls_mask;
6018
6019           tls_mask = NULL;
6020           lgot_ents = elf_local_got_ents (ibfd);
6021           if (lgot_ents != NULL)
6022             {
6023               char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
6024               tls_mask = &lgot_masks[r_symndx];
6025             }
6026           *tls_maskp = tls_mask;
6027         }
6028     }
6029   return TRUE;
6030 }
6031
6032 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6033    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6034    type suitable for optimization, and 1 otherwise.  */
6035
6036 static int
6037 get_tls_mask (char **tls_maskp, unsigned long *toc_symndx,
6038               Elf_Internal_Sym **locsymsp,
6039               const Elf_Internal_Rela *rel, bfd *ibfd)
6040 {
6041   unsigned long r_symndx;
6042   int next_r;
6043   struct elf_link_hash_entry *h;
6044   Elf_Internal_Sym *sym;
6045   asection *sec;
6046   bfd_vma off;
6047
6048   r_symndx = ELF64_R_SYM (rel->r_info);
6049   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6050     return 0;
6051
6052   if ((*tls_maskp != NULL && **tls_maskp != 0)
6053       || sec == NULL
6054       || ppc64_elf_section_data (sec)->t_symndx == NULL)
6055     return 1;
6056
6057   /* Look inside a TOC section too.  */
6058   if (h != NULL)
6059     {
6060       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6061       off = h->root.u.def.value;
6062     }
6063   else
6064     off = sym->st_value;
6065   off += rel->r_addend;
6066   BFD_ASSERT (off % 8 == 0);
6067   r_symndx = ppc64_elf_section_data (sec)->t_symndx[off / 8];
6068   next_r = ppc64_elf_section_data (sec)->t_symndx[off / 8 + 1];
6069   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6070     return 0;
6071   if (toc_symndx != NULL)
6072     *toc_symndx = r_symndx;
6073   if ((h == NULL
6074        || ((h->root.type == bfd_link_hash_defined
6075             || h->root.type == bfd_link_hash_defweak)
6076            && !h->def_dynamic))
6077       && (next_r == -1 || next_r == -2))
6078     return 1 - next_r;
6079   return 1;
6080 }
6081
6082 /* Adjust all global syms defined in opd sections.  In gcc generated
6083    code for the old ABI, these will already have been done.  */
6084
6085 static bfd_boolean
6086 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6087 {
6088   struct ppc_link_hash_entry *eh;
6089   asection *sym_sec;
6090   long *opd_adjust;
6091
6092   if (h->root.type == bfd_link_hash_indirect)
6093     return TRUE;
6094
6095   if (h->root.type == bfd_link_hash_warning)
6096     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6097
6098   if (h->root.type != bfd_link_hash_defined
6099       && h->root.type != bfd_link_hash_defweak)
6100     return TRUE;
6101
6102   eh = (struct ppc_link_hash_entry *) h;
6103   if (eh->adjust_done)
6104     return TRUE;
6105
6106   sym_sec = eh->elf.root.u.def.section;
6107   opd_adjust = get_opd_info (sym_sec);
6108   if (opd_adjust != NULL)
6109     {
6110       long adjust = opd_adjust[eh->elf.root.u.def.value / 8];
6111       if (adjust == -1)
6112         {
6113           /* This entry has been deleted.  */
6114           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6115           if (dsec == NULL)
6116             {
6117               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6118                 if (elf_discarded_section (dsec))
6119                   {
6120                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6121                     break;
6122                   }
6123             }
6124           eh->elf.root.u.def.value = 0;
6125           eh->elf.root.u.def.section = dsec;
6126         }
6127       else
6128         eh->elf.root.u.def.value += adjust;
6129       eh->adjust_done = 1;
6130     }
6131   return TRUE;
6132 }
6133
6134 /* Handles decrementing dynamic reloc counts for the reloc specified by
6135    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6136    have already been determined.  */
6137
6138 static bfd_boolean
6139 dec_dynrel_count (bfd_vma r_info,
6140                   asection *sec,
6141                   struct bfd_link_info *info,
6142                   Elf_Internal_Sym **local_syms,
6143                   struct elf_link_hash_entry *h,
6144                   asection *sym_sec)
6145 {
6146   enum elf_ppc64_reloc_type r_type;
6147   struct ppc_dyn_relocs *p;
6148   struct ppc_dyn_relocs **pp;
6149
6150   /* Can this reloc be dynamic?  This switch, and later tests here
6151      should be kept in sync with the code in check_relocs.  */
6152   r_type = ELF64_R_TYPE (r_info);
6153   switch (r_type)
6154     {
6155     default:
6156       return TRUE;
6157
6158     case R_PPC64_TPREL16:
6159     case R_PPC64_TPREL16_LO:
6160     case R_PPC64_TPREL16_HI:
6161     case R_PPC64_TPREL16_HA:
6162     case R_PPC64_TPREL16_DS:
6163     case R_PPC64_TPREL16_LO_DS:
6164     case R_PPC64_TPREL16_HIGHER:
6165     case R_PPC64_TPREL16_HIGHERA:
6166     case R_PPC64_TPREL16_HIGHEST:
6167     case R_PPC64_TPREL16_HIGHESTA:
6168       if (!info->shared)
6169         return TRUE;
6170
6171     case R_PPC64_TPREL64:
6172     case R_PPC64_DTPMOD64:
6173     case R_PPC64_DTPREL64:
6174     case R_PPC64_ADDR64:
6175     case R_PPC64_REL30:
6176     case R_PPC64_REL32:
6177     case R_PPC64_REL64:
6178     case R_PPC64_ADDR14:
6179     case R_PPC64_ADDR14_BRNTAKEN:
6180     case R_PPC64_ADDR14_BRTAKEN:
6181     case R_PPC64_ADDR16:
6182     case R_PPC64_ADDR16_DS:
6183     case R_PPC64_ADDR16_HA:
6184     case R_PPC64_ADDR16_HI:
6185     case R_PPC64_ADDR16_HIGHER:
6186     case R_PPC64_ADDR16_HIGHERA:
6187     case R_PPC64_ADDR16_HIGHEST:
6188     case R_PPC64_ADDR16_HIGHESTA:
6189     case R_PPC64_ADDR16_LO:
6190     case R_PPC64_ADDR16_LO_DS:
6191     case R_PPC64_ADDR24:
6192     case R_PPC64_ADDR32:
6193     case R_PPC64_UADDR16:
6194     case R_PPC64_UADDR32:
6195     case R_PPC64_UADDR64:
6196     case R_PPC64_TOC:
6197       break;
6198     }
6199
6200   if (local_syms != NULL)
6201     {
6202       unsigned long r_symndx;
6203       Elf_Internal_Sym *sym;
6204       bfd *ibfd = sec->owner;
6205
6206       r_symndx = ELF64_R_SYM (r_info);
6207       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6208         return FALSE;
6209     }
6210
6211   if ((info->shared
6212        && (MUST_BE_DYN_RELOC (r_type)
6213            || (h != NULL
6214                && (!info->symbolic
6215                    || h->root.type == bfd_link_hash_defweak
6216                    || !h->def_regular))))
6217       || (ELIMINATE_COPY_RELOCS
6218           && !info->shared
6219           && h != NULL
6220           && (h->root.type == bfd_link_hash_defweak
6221               || !h->def_regular)))
6222     ;
6223   else
6224     return TRUE;
6225
6226   if (h != NULL)
6227     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6228   else
6229     {
6230       if (sym_sec != NULL)
6231         {
6232           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6233           pp = (struct ppc_dyn_relocs **) vpp;
6234         }
6235       else
6236         {
6237           void *vpp = &elf_section_data (sec)->local_dynrel;
6238           pp = (struct ppc_dyn_relocs **) vpp;
6239         }
6240
6241       /* elf_gc_sweep may have already removed all dyn relocs associated
6242          with local syms for a given section.  Don't report a dynreloc
6243          miscount.  */
6244       if (*pp == NULL)
6245         return TRUE;
6246     }
6247
6248   while ((p = *pp) != NULL)
6249     {
6250       if (p->sec == sec)
6251         {
6252           if (!MUST_BE_DYN_RELOC (r_type))
6253             p->pc_count -= 1;
6254           p->count -= 1;
6255           if (p->count == 0)
6256             *pp = p->next;
6257           return TRUE;
6258         }
6259       pp = &p->next;
6260     }
6261
6262   (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6263                            sec->owner, sec);
6264   bfd_set_error (bfd_error_bad_value);
6265   return FALSE;
6266 }
6267
6268 /* Remove unused Official Procedure Descriptor entries.  Currently we
6269    only remove those associated with functions in discarded link-once
6270    sections, or weakly defined functions that have been overridden.  It
6271    would be possible to remove many more entries for statically linked
6272    applications.  */
6273
6274 bfd_boolean
6275 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6276                     bfd_boolean no_opd_opt,
6277                     bfd_boolean non_overlapping)
6278 {
6279   bfd *ibfd;
6280   bfd_boolean some_edited = FALSE;
6281   asection *need_pad = NULL;
6282
6283   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6284     {
6285       asection *sec;
6286       Elf_Internal_Rela *relstart, *rel, *relend;
6287       Elf_Internal_Shdr *symtab_hdr;
6288       Elf_Internal_Sym *local_syms;
6289       struct elf_link_hash_entry **sym_hashes;
6290       bfd_vma offset;
6291       bfd_size_type amt;
6292       long *opd_adjust;
6293       bfd_boolean need_edit, add_aux_fields;
6294       bfd_size_type cnt_16b = 0;
6295
6296       sec = bfd_get_section_by_name (ibfd, ".opd");
6297       if (sec == NULL || sec->size == 0)
6298         continue;
6299
6300       amt = sec->size * sizeof (long) / 8;
6301       opd_adjust = get_opd_info (sec);
6302       if (opd_adjust == NULL)
6303         {
6304           /* check_relocs hasn't been called.  Must be a ld -r link
6305              or --just-symbols object.   */
6306           opd_adjust = bfd_alloc (obfd, amt);
6307           if (opd_adjust == NULL)
6308             return FALSE;
6309           ppc64_elf_section_data (sec)->opd.adjust = opd_adjust;
6310         }
6311       memset (opd_adjust, 0, amt);
6312
6313       if (no_opd_opt)
6314         continue;
6315
6316       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6317         continue;
6318
6319       if (sec->output_section == bfd_abs_section_ptr)
6320         continue;
6321
6322       /* Look through the section relocs.  */
6323       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6324         continue;
6325
6326       local_syms = NULL;
6327       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6328       sym_hashes = elf_sym_hashes (ibfd);
6329
6330       /* Read the relocations.  */
6331       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6332                                             info->keep_memory);
6333       if (relstart == NULL)
6334         return FALSE;
6335
6336       /* First run through the relocs to check they are sane, and to
6337          determine whether we need to edit this opd section.  */
6338       need_edit = FALSE;
6339       need_pad = sec;
6340       offset = 0;
6341       relend = relstart + sec->reloc_count;
6342       for (rel = relstart; rel < relend; )
6343         {
6344           enum elf_ppc64_reloc_type r_type;
6345           unsigned long r_symndx;
6346           asection *sym_sec;
6347           struct elf_link_hash_entry *h;
6348           Elf_Internal_Sym *sym;
6349
6350           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6351              only interested in the reloc pointing to a function entry
6352              point.  */
6353           if (rel->r_offset != offset
6354               || rel + 1 >= relend
6355               || (rel + 1)->r_offset != offset + 8)
6356             {
6357               /* If someone messes with .opd alignment then after a
6358                  "ld -r" we might have padding in the middle of .opd.
6359                  Also, there's nothing to prevent someone putting
6360                  something silly in .opd with the assembler.  No .opd
6361                  optimization for them!  */
6362             broken_opd:
6363               (*_bfd_error_handler)
6364                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6365               need_edit = FALSE;
6366               break;
6367             }
6368
6369           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6370               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6371             {
6372               (*_bfd_error_handler)
6373                 (_("%B: unexpected reloc type %u in .opd section"),
6374                  ibfd, r_type);
6375               need_edit = FALSE;
6376               break;
6377             }
6378
6379           r_symndx = ELF64_R_SYM (rel->r_info);
6380           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6381                           r_symndx, ibfd))
6382             goto error_ret;
6383
6384           if (sym_sec == NULL || sym_sec->owner == NULL)
6385             {
6386               const char *sym_name;
6387               if (h != NULL)
6388                 sym_name = h->root.root.string;
6389               else
6390                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6391                                              sym_sec);
6392
6393               (*_bfd_error_handler)
6394                 (_("%B: undefined sym `%s' in .opd section"),
6395                  ibfd, sym_name);
6396               need_edit = FALSE;
6397               break;
6398             }
6399
6400           /* opd entries are always for functions defined in the
6401              current input bfd.  If the symbol isn't defined in the
6402              input bfd, then we won't be using the function in this
6403              bfd;  It must be defined in a linkonce section in another
6404              bfd, or is weak.  It's also possible that we are
6405              discarding the function due to a linker script /DISCARD/,
6406              which we test for via the output_section.  */
6407           if (sym_sec->owner != ibfd
6408               || sym_sec->output_section == bfd_abs_section_ptr)
6409             need_edit = TRUE;
6410
6411           rel += 2;
6412           if (rel == relend
6413               || (rel + 1 == relend && rel->r_offset == offset + 16))
6414             {
6415               if (sec->size == offset + 24)
6416                 {
6417                   need_pad = NULL;
6418                   break;
6419                 }
6420               if (rel == relend && sec->size == offset + 16)
6421                 {
6422                   cnt_16b++;
6423                   break;
6424                 }
6425               goto broken_opd;
6426             }
6427
6428           if (rel->r_offset == offset + 24)
6429             offset += 24;
6430           else if (rel->r_offset != offset + 16)
6431             goto broken_opd;
6432           else if (rel + 1 < relend
6433                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6434                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6435             {
6436               offset += 16;
6437               cnt_16b++;
6438             }
6439           else if (rel + 2 < relend
6440                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6441                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6442             {
6443               offset += 24;
6444               rel += 1;
6445             }
6446           else
6447             goto broken_opd;
6448         }
6449
6450       add_aux_fields = non_overlapping && cnt_16b > 0;
6451
6452       if (need_edit || add_aux_fields)
6453         {
6454           Elf_Internal_Rela *write_rel;
6455           bfd_byte *rptr, *wptr;
6456           bfd_byte *new_contents = NULL;
6457           bfd_boolean skip;
6458           long opd_ent_size;
6459
6460           /* This seems a waste of time as input .opd sections are all
6461              zeros as generated by gcc, but I suppose there's no reason
6462              this will always be so.  We might start putting something in
6463              the third word of .opd entries.  */
6464           if ((sec->flags & SEC_IN_MEMORY) == 0)
6465             {
6466               bfd_byte *loc;
6467               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6468                 {
6469                   if (loc != NULL)
6470                     free (loc);
6471                 error_ret:
6472                   if (local_syms != NULL
6473                       && symtab_hdr->contents != (unsigned char *) local_syms)
6474                     free (local_syms);
6475                   if (elf_section_data (sec)->relocs != relstart)
6476                     free (relstart);
6477                   return FALSE;
6478                 }
6479               sec->contents = loc;
6480               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6481             }
6482
6483           elf_section_data (sec)->relocs = relstart;
6484
6485           new_contents = sec->contents;
6486           if (add_aux_fields)
6487             {
6488               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6489               if (new_contents == NULL)
6490                 return FALSE;
6491               need_pad = FALSE;
6492             }
6493           wptr = new_contents;
6494           rptr = sec->contents;
6495
6496           write_rel = relstart;
6497           skip = FALSE;
6498           offset = 0;
6499           opd_ent_size = 0;
6500           for (rel = relstart; rel < relend; rel++)
6501             {
6502               unsigned long r_symndx;
6503               asection *sym_sec;
6504               struct elf_link_hash_entry *h;
6505               Elf_Internal_Sym *sym;
6506
6507               r_symndx = ELF64_R_SYM (rel->r_info);
6508               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6509                               r_symndx, ibfd))
6510                 goto error_ret;
6511
6512               if (rel->r_offset == offset)
6513                 {
6514                   struct ppc_link_hash_entry *fdh = NULL;
6515
6516                   /* See if the .opd entry is full 24 byte or
6517                      16 byte (with fd_aux entry overlapped with next
6518                      fd_func).  */
6519                   opd_ent_size = 24;
6520                   if ((rel + 2 == relend && sec->size == offset + 16)
6521                       || (rel + 3 < relend
6522                           && rel[2].r_offset == offset + 16
6523                           && rel[3].r_offset == offset + 24
6524                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6525                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6526                     opd_ent_size = 16;
6527
6528                   if (h != NULL
6529                       && h->root.root.string[0] == '.')
6530                     {
6531                       fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6532                                      ppc_hash_table (info));
6533                       if (fdh != NULL
6534                           && fdh->elf.root.type != bfd_link_hash_defined
6535                           && fdh->elf.root.type != bfd_link_hash_defweak)
6536                         fdh = NULL;
6537                     }
6538
6539                   skip = (sym_sec->owner != ibfd
6540                           || sym_sec->output_section == bfd_abs_section_ptr);
6541                   if (skip)
6542                     {
6543                       if (fdh != NULL && sym_sec->owner == ibfd)
6544                         {
6545                           /* Arrange for the function descriptor sym
6546                              to be dropped.  */
6547                           fdh->elf.root.u.def.value = 0;
6548                           fdh->elf.root.u.def.section = sym_sec;
6549                         }
6550                       opd_adjust[rel->r_offset / 8] = -1;
6551                     }
6552                   else
6553                     {
6554                       /* We'll be keeping this opd entry.  */
6555
6556                       if (fdh != NULL)
6557                         {
6558                           /* Redefine the function descriptor symbol to
6559                              this location in the opd section.  It is
6560                              necessary to update the value here rather
6561                              than using an array of adjustments as we do
6562                              for local symbols, because various places
6563                              in the generic ELF code use the value
6564                              stored in u.def.value.  */
6565                           fdh->elf.root.u.def.value = wptr - new_contents;
6566                           fdh->adjust_done = 1;
6567                         }
6568
6569                       /* Local syms are a bit tricky.  We could
6570                          tweak them as they can be cached, but
6571                          we'd need to look through the local syms
6572                          for the function descriptor sym which we
6573                          don't have at the moment.  So keep an
6574                          array of adjustments.  */
6575                       opd_adjust[rel->r_offset / 8]
6576                         = (wptr - new_contents) - (rptr - sec->contents);
6577
6578                       if (wptr != rptr)
6579                         memcpy (wptr, rptr, opd_ent_size);
6580                       wptr += opd_ent_size;
6581                       if (add_aux_fields && opd_ent_size == 16)
6582                         {
6583                           memset (wptr, '\0', 8);
6584                           wptr += 8;
6585                         }
6586                     }
6587                   rptr += opd_ent_size;
6588                   offset += opd_ent_size;
6589                 }
6590
6591               if (skip)
6592                 {
6593                   if (!NO_OPD_RELOCS
6594                       && !info->relocatable
6595                       && !dec_dynrel_count (rel->r_info, sec, info,
6596                                             NULL, h, sym_sec))
6597                     goto error_ret;
6598                 }
6599               else
6600                 {
6601                   /* We need to adjust any reloc offsets to point to the
6602                      new opd entries.  While we're at it, we may as well
6603                      remove redundant relocs.  */
6604                   rel->r_offset += opd_adjust[(offset - opd_ent_size) / 8];
6605                   if (write_rel != rel)
6606                     memcpy (write_rel, rel, sizeof (*rel));
6607                   ++write_rel;
6608                 }
6609             }
6610
6611           sec->size = wptr - new_contents;
6612           sec->reloc_count = write_rel - relstart;
6613           if (add_aux_fields)
6614             {
6615               free (sec->contents);
6616               sec->contents = new_contents;
6617             }
6618
6619           /* Fudge the header size too, as this is used later in
6620              elf_bfd_final_link if we are emitting relocs.  */
6621           elf_section_data (sec)->rel_hdr.sh_size
6622             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6623           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
6624           some_edited = TRUE;
6625         }
6626       else if (elf_section_data (sec)->relocs != relstart)
6627         free (relstart);
6628
6629       if (local_syms != NULL
6630           && symtab_hdr->contents != (unsigned char *) local_syms)
6631         {
6632           if (!info->keep_memory)
6633             free (local_syms);
6634           else
6635             symtab_hdr->contents = (unsigned char *) local_syms;
6636         }
6637     }
6638
6639   if (some_edited)
6640     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6641
6642   /* If we are doing a final link and the last .opd entry is just 16 byte
6643      long, add a 8 byte padding after it.  */
6644   if (need_pad != NULL && !info->relocatable)
6645     {
6646       bfd_byte *p;
6647
6648       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6649         {
6650           BFD_ASSERT (need_pad->size > 0);
6651
6652           p = bfd_malloc (need_pad->size + 8);
6653           if (p == NULL)
6654             return FALSE;
6655
6656           if (! bfd_get_section_contents (need_pad->owner, need_pad,
6657                                           p, 0, need_pad->size))
6658             return FALSE;
6659
6660           need_pad->contents = p;
6661           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6662         }
6663       else
6664         {
6665           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6666           if (p == NULL)
6667             return FALSE;
6668
6669           need_pad->contents = p;
6670         }
6671
6672       memset (need_pad->contents + need_pad->size, 0, 8);
6673       need_pad->size += 8;
6674     }
6675
6676   return TRUE;
6677 }
6678
6679 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
6680
6681 asection *
6682 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
6683 {
6684   struct ppc_link_hash_table *htab;
6685
6686   htab = ppc_hash_table (info);
6687   if (htab->tls_get_addr != NULL)
6688     {
6689       struct ppc_link_hash_entry *h = htab->tls_get_addr;
6690
6691       while (h->elf.root.type == bfd_link_hash_indirect
6692              || h->elf.root.type == bfd_link_hash_warning)
6693         h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6694
6695       htab->tls_get_addr = h;
6696
6697       if (htab->tls_get_addr_fd == NULL
6698           && h->oh != NULL
6699           && h->oh->is_func_descriptor
6700           && (h->oh->elf.root.type == bfd_link_hash_defined
6701               || h->oh->elf.root.type == bfd_link_hash_defweak))
6702         htab->tls_get_addr_fd = h->oh;
6703     }
6704
6705   if (htab->tls_get_addr_fd != NULL)
6706     {
6707       struct ppc_link_hash_entry *h = htab->tls_get_addr_fd;
6708
6709       while (h->elf.root.type == bfd_link_hash_indirect
6710              || h->elf.root.type == bfd_link_hash_warning)
6711         h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6712
6713       htab->tls_get_addr_fd = h;
6714     }
6715
6716   return _bfd_elf_tls_setup (obfd, info);
6717 }
6718
6719 /* Run through all the TLS relocs looking for optimization
6720    opportunities.  The linker has been hacked (see ppc64elf.em) to do
6721    a preliminary section layout so that we know the TLS segment
6722    offsets.  We can't optimize earlier because some optimizations need
6723    to know the tp offset, and we need to optimize before allocating
6724    dynamic relocations.  */
6725
6726 bfd_boolean
6727 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6728 {
6729   bfd *ibfd;
6730   asection *sec;
6731   struct ppc_link_hash_table *htab;
6732
6733   if (info->relocatable || info->shared)
6734     return TRUE;
6735
6736   htab = ppc_hash_table (info);
6737   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6738     {
6739       Elf_Internal_Sym *locsyms = NULL;
6740       asection *toc = bfd_get_section_by_name (ibfd, ".toc");
6741       unsigned char *toc_ref = NULL;
6742
6743       /* Look at all the sections for this file, with TOC last.  */
6744       for (sec = (ibfd->sections == toc && toc && toc->next ? toc->next
6745                   : ibfd->sections);
6746            sec != NULL;
6747            sec = (sec == toc ? NULL
6748                   : sec->next == NULL ? toc
6749                   : sec->next == toc && toc->next ? toc->next
6750                   : sec->next))
6751         if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
6752           {
6753             Elf_Internal_Rela *relstart, *rel, *relend;
6754             int expecting_tls_get_addr;
6755             long toc_ref_index = 0;
6756
6757             /* Read the relocations.  */
6758             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6759                                                   info->keep_memory);
6760             if (relstart == NULL)
6761               return FALSE;
6762
6763             expecting_tls_get_addr = 0;
6764             relend = relstart + sec->reloc_count;
6765             for (rel = relstart; rel < relend; rel++)
6766               {
6767                 enum elf_ppc64_reloc_type r_type;
6768                 unsigned long r_symndx;
6769                 struct elf_link_hash_entry *h;
6770                 Elf_Internal_Sym *sym;
6771                 asection *sym_sec;
6772                 char *tls_mask;
6773                 char tls_set, tls_clear, tls_type = 0;
6774                 bfd_vma value;
6775                 bfd_boolean ok_tprel, is_local;
6776
6777                 r_symndx = ELF64_R_SYM (rel->r_info);
6778                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
6779                                 r_symndx, ibfd))
6780                   {
6781                   err_free_rel:
6782                     if (elf_section_data (sec)->relocs != relstart)
6783                       free (relstart);
6784                     if (toc_ref != NULL)
6785                       free (toc_ref);
6786                     if (locsyms != NULL
6787                         && (elf_tdata (ibfd)->symtab_hdr.contents
6788                             != (unsigned char *) locsyms))
6789                       free (locsyms);
6790                     return FALSE;
6791                   }
6792
6793                 if (h != NULL)
6794                   {
6795                     if (h->root.type != bfd_link_hash_defined
6796                         && h->root.type != bfd_link_hash_defweak)
6797                       continue;
6798                     value = h->root.u.def.value;
6799                   }
6800                 else
6801                   /* Symbols referenced by TLS relocs must be of type
6802                      STT_TLS.  So no need for .opd local sym adjust.  */
6803                   value = sym->st_value;
6804
6805                 ok_tprel = FALSE;
6806                 is_local = FALSE;
6807                 if (h == NULL
6808                     || !h->def_dynamic)
6809                   {
6810                     is_local = TRUE;
6811                     value += sym_sec->output_offset;
6812                     value += sym_sec->output_section->vma;
6813                     value -= htab->elf.tls_sec->vma;
6814                     ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
6815                                 < (bfd_vma) 1 << 32);
6816                   }
6817
6818                 r_type = ELF64_R_TYPE (rel->r_info);
6819                 switch (r_type)
6820                   {
6821                   case R_PPC64_GOT_TLSLD16:
6822                   case R_PPC64_GOT_TLSLD16_LO:
6823                   case R_PPC64_GOT_TLSLD16_HI:
6824                   case R_PPC64_GOT_TLSLD16_HA:
6825                     /* These relocs should never be against a symbol
6826                        defined in a shared lib.  Leave them alone if
6827                        that turns out to be the case.  */
6828                     ppc64_tlsld_got (ibfd)->refcount -= 1;
6829                     if (!is_local)
6830                       continue;
6831
6832                     /* LD -> LE */
6833                     tls_set = 0;
6834                     tls_clear = TLS_LD;
6835                     tls_type = TLS_TLS | TLS_LD;
6836                     expecting_tls_get_addr = 1;
6837                     break;
6838
6839                   case R_PPC64_GOT_TLSGD16:
6840                   case R_PPC64_GOT_TLSGD16_LO:
6841                   case R_PPC64_GOT_TLSGD16_HI:
6842                   case R_PPC64_GOT_TLSGD16_HA:
6843                     if (ok_tprel)
6844                       /* GD -> LE */
6845                       tls_set = 0;
6846                     else
6847                       /* GD -> IE */
6848                       tls_set = TLS_TLS | TLS_TPRELGD;
6849                     tls_clear = TLS_GD;
6850                     tls_type = TLS_TLS | TLS_GD;
6851                     expecting_tls_get_addr = 1;
6852                     break;
6853
6854                   case R_PPC64_GOT_TPREL16_DS:
6855                   case R_PPC64_GOT_TPREL16_LO_DS:
6856                   case R_PPC64_GOT_TPREL16_HI:
6857                   case R_PPC64_GOT_TPREL16_HA:
6858                     expecting_tls_get_addr = 0;
6859                     if (ok_tprel)
6860                       {
6861                         /* IE -> LE */
6862                         tls_set = 0;
6863                         tls_clear = TLS_TPREL;
6864                         tls_type = TLS_TLS | TLS_TPREL;
6865                         break;
6866                       }
6867                     else
6868                       continue;
6869
6870                   case R_PPC64_REL14:
6871                   case R_PPC64_REL14_BRTAKEN:
6872                   case R_PPC64_REL14_BRNTAKEN:
6873                   case R_PPC64_REL24:
6874                     if (h != NULL
6875                         && (h == &htab->tls_get_addr->elf
6876                             || h == &htab->tls_get_addr_fd->elf))
6877                       {
6878                         if (!expecting_tls_get_addr
6879                             && rel != relstart
6880                             && ((ELF64_R_TYPE (rel[-1].r_info)
6881                                  == R_PPC64_TOC16)
6882                                 || (ELF64_R_TYPE (rel[-1].r_info)
6883                                     == R_PPC64_TOC16_LO)))
6884                           {
6885                             /* Check for toc tls entries.  */
6886                             char *toc_tls;
6887                             int retval;
6888
6889                             retval = get_tls_mask (&toc_tls, NULL, &locsyms,
6890                                                    rel - 1, ibfd);
6891                             if (retval == 0)
6892                               goto err_free_rel;
6893                             if (retval > 1 && toc_tls != NULL)
6894                               {
6895                                 expecting_tls_get_addr = 1;
6896                                 if (toc_ref != NULL)
6897                                   toc_ref[toc_ref_index] = 1;
6898                               }
6899                           }
6900
6901                         if (expecting_tls_get_addr)
6902                           {
6903                             struct plt_entry *ent;
6904                             for (ent = h->plt.plist; ent; ent = ent->next)
6905                               if (ent->addend == 0)
6906                                 {
6907                                   if (ent->plt.refcount > 0)
6908                                     ent->plt.refcount -= 1;
6909                                   break;
6910                                 }
6911                           }
6912                       }
6913                     expecting_tls_get_addr = 0;
6914                     continue;
6915
6916                   case R_PPC64_TOC16:
6917                   case R_PPC64_TOC16_LO:
6918                   case R_PPC64_TLS:
6919                     expecting_tls_get_addr = 0;
6920                     if (sym_sec == toc && toc != NULL)
6921                       {
6922                         /* Mark this toc entry as referenced by a TLS
6923                            code sequence.  We can do that now in the
6924                            case of R_PPC64_TLS, and after checking for
6925                            tls_get_addr for the TOC16 relocs.  */
6926                         if (toc_ref == NULL)
6927                           {
6928                             toc_ref = bfd_zmalloc (toc->size / 8);
6929                             if (toc_ref == NULL)
6930                               goto err_free_rel;
6931                           }
6932                         if (h != NULL)
6933                           value = h->root.u.def.value;
6934                         else
6935                           value = sym->st_value;
6936                         value += rel->r_addend;
6937                         BFD_ASSERT (value < toc->size && value % 8 == 0);
6938                         toc_ref_index = value / 8;
6939                         if (r_type == R_PPC64_TLS)
6940                           toc_ref[toc_ref_index] = 1;
6941                       }
6942                     continue;
6943
6944                   case R_PPC64_TPREL64:
6945                     expecting_tls_get_addr = 0;
6946                     if (sec != toc
6947                         || toc_ref == NULL
6948                         || !toc_ref[rel->r_offset / 8])
6949                       continue;
6950                     if (ok_tprel)
6951                       {
6952                         /* IE -> LE */
6953                         tls_set = TLS_EXPLICIT;
6954                         tls_clear = TLS_TPREL;
6955                         break;
6956                       }
6957                     else
6958                       continue;
6959
6960                   case R_PPC64_DTPMOD64:
6961                     expecting_tls_get_addr = 0;
6962                     if (sec != toc
6963                         || toc_ref == NULL
6964                         || !toc_ref[rel->r_offset / 8])
6965                       continue;
6966                     if (rel + 1 < relend
6967                         && (rel[1].r_info
6968                             == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
6969                         && rel[1].r_offset == rel->r_offset + 8)
6970                       {
6971                         if (ok_tprel)
6972                           /* GD -> LE */
6973                           tls_set = TLS_EXPLICIT | TLS_GD;
6974                         else
6975                           /* GD -> IE */
6976                           tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
6977                         tls_clear = TLS_GD;
6978                       }
6979                     else
6980                       {
6981                         if (!is_local)
6982                           continue;
6983
6984                         /* LD -> LE */
6985                         tls_set = TLS_EXPLICIT;
6986                         tls_clear = TLS_LD;
6987                       }
6988                     break;
6989
6990                   default:
6991                     expecting_tls_get_addr = 0;
6992                     continue;
6993                   }
6994
6995                 if ((tls_set & TLS_EXPLICIT) == 0)
6996                   {
6997                     struct got_entry *ent;
6998
6999                     /* Adjust got entry for this reloc.  */
7000                     if (h != NULL)
7001                       ent = h->got.glist;
7002                     else
7003                       ent = elf_local_got_ents (ibfd)[r_symndx];
7004
7005                     for (; ent != NULL; ent = ent->next)
7006                       if (ent->addend == rel->r_addend
7007                           && ent->owner == ibfd
7008                           && ent->tls_type == tls_type)
7009                         break;
7010                     if (ent == NULL)
7011                       abort ();
7012
7013                     if (tls_set == 0)
7014                       {
7015                         /* We managed to get rid of a got entry.  */
7016                         if (ent->got.refcount > 0)
7017                           ent->got.refcount -= 1;
7018                       }
7019                   }
7020                 else
7021                   {
7022                     /* If we got rid of a DTPMOD/DTPREL reloc pair then
7023                        we'll lose one or two dyn relocs.  */
7024                     if (!dec_dynrel_count (rel->r_info, sec, info,
7025                                            NULL, h, sym_sec))
7026                       return FALSE;
7027
7028                     if (tls_set == (TLS_EXPLICIT | TLS_GD))
7029                       {
7030                         if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7031                                                NULL, h, sym_sec))
7032                           return FALSE;
7033                       }
7034                   }
7035
7036                 *tls_mask |= tls_set;
7037                 *tls_mask &= ~tls_clear;
7038               }
7039
7040             if (elf_section_data (sec)->relocs != relstart)
7041               free (relstart);
7042           }
7043
7044       if (toc_ref != NULL)
7045         free (toc_ref);
7046
7047       if (locsyms != NULL
7048           && (elf_tdata (ibfd)->symtab_hdr.contents
7049               != (unsigned char *) locsyms))
7050         {
7051           if (!info->keep_memory)
7052             free (locsyms);
7053           else
7054             elf_tdata (ibfd)->symtab_hdr.contents = (unsigned char *) locsyms;
7055         }
7056     }
7057   return TRUE;
7058 }
7059
7060 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7061    the values of any global symbols in a toc section that has been
7062    edited.  Globals in toc sections should be a rarity, so this function
7063    sets a flag if any are found in toc sections other than the one just
7064    edited, so that futher hash table traversals can be avoided.  */
7065
7066 struct adjust_toc_info
7067 {
7068   asection *toc;
7069   unsigned long *skip;
7070   bfd_boolean global_toc_syms;
7071 };
7072
7073 static bfd_boolean
7074 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7075 {
7076   struct ppc_link_hash_entry *eh;
7077   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7078
7079   if (h->root.type == bfd_link_hash_indirect)
7080     return TRUE;
7081
7082   if (h->root.type == bfd_link_hash_warning)
7083     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7084
7085   if (h->root.type != bfd_link_hash_defined
7086       && h->root.type != bfd_link_hash_defweak)
7087     return TRUE;
7088
7089   eh = (struct ppc_link_hash_entry *) h;
7090   if (eh->adjust_done)
7091     return TRUE;
7092
7093   if (eh->elf.root.u.def.section == toc_inf->toc)
7094     {
7095       unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7096       if (skip != (unsigned long) -1)
7097         eh->elf.root.u.def.value -= skip;
7098       else
7099         {
7100           (*_bfd_error_handler)
7101             (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7102           eh->elf.root.u.def.section = &bfd_abs_section;
7103           eh->elf.root.u.def.value = 0;
7104         }
7105       eh->adjust_done = 1;
7106     }
7107   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7108     toc_inf->global_toc_syms = TRUE;
7109
7110   return TRUE;
7111 }
7112
7113 /* Examine all relocs referencing .toc sections in order to remove
7114    unused .toc entries.  */
7115
7116 bfd_boolean
7117 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7118 {
7119   bfd *ibfd;
7120   struct adjust_toc_info toc_inf;
7121
7122   toc_inf.global_toc_syms = TRUE;
7123   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7124     {
7125       asection *toc, *sec;
7126       Elf_Internal_Shdr *symtab_hdr;
7127       Elf_Internal_Sym *local_syms;
7128       struct elf_link_hash_entry **sym_hashes;
7129       Elf_Internal_Rela *relstart, *rel;
7130       unsigned long *skip, *drop;
7131       unsigned char *used;
7132       unsigned char *keep, last, some_unused;
7133
7134       toc = bfd_get_section_by_name (ibfd, ".toc");
7135       if (toc == NULL
7136           || toc->size == 0
7137           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7138           || elf_discarded_section (toc))
7139         continue;
7140
7141       local_syms = NULL;
7142       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7143       sym_hashes = elf_sym_hashes (ibfd);
7144
7145       /* Look at sections dropped from the final link.  */
7146       skip = NULL;
7147       relstart = NULL;
7148       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7149         {
7150           if (sec->reloc_count == 0
7151               || !elf_discarded_section (sec)
7152               || get_opd_info (sec)
7153               || (sec->flags & SEC_ALLOC) == 0
7154               || (sec->flags & SEC_DEBUGGING) != 0)
7155             continue;
7156
7157           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7158           if (relstart == NULL)
7159             goto error_ret;
7160
7161           /* Run through the relocs to see which toc entries might be
7162              unused.  */
7163           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7164             {
7165               enum elf_ppc64_reloc_type r_type;
7166               unsigned long r_symndx;
7167               asection *sym_sec;
7168               struct elf_link_hash_entry *h;
7169               Elf_Internal_Sym *sym;
7170               bfd_vma val;
7171
7172               r_type = ELF64_R_TYPE (rel->r_info);
7173               switch (r_type)
7174                 {
7175                 default:
7176                   continue;
7177
7178                 case R_PPC64_TOC16:
7179                 case R_PPC64_TOC16_LO:
7180                 case R_PPC64_TOC16_HI:
7181                 case R_PPC64_TOC16_HA:
7182                 case R_PPC64_TOC16_DS:
7183                 case R_PPC64_TOC16_LO_DS:
7184                   break;
7185                 }
7186
7187               r_symndx = ELF64_R_SYM (rel->r_info);
7188               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7189                               r_symndx, ibfd))
7190                 goto error_ret;
7191
7192               if (sym_sec != toc)
7193                 continue;
7194
7195               if (h != NULL)
7196                 val = h->root.u.def.value;
7197               else
7198                 val = sym->st_value;
7199               val += rel->r_addend;
7200
7201               if (val >= toc->size)
7202                 continue;
7203
7204               /* Anything in the toc ought to be aligned to 8 bytes.
7205                  If not, don't mark as unused.  */
7206               if (val & 7)
7207                 continue;
7208
7209               if (skip == NULL)
7210                 {
7211                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7212                   if (skip == NULL)
7213                     goto error_ret;
7214                 }
7215
7216               skip[val >> 3] = 1;
7217             }
7218
7219           if (elf_section_data (sec)->relocs != relstart)
7220             free (relstart);
7221         }
7222
7223       if (skip == NULL)
7224         continue;
7225
7226       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7227       if (used == NULL)
7228         {
7229         error_ret:
7230           if (local_syms != NULL
7231               && symtab_hdr->contents != (unsigned char *) local_syms)
7232             free (local_syms);
7233           if (sec != NULL
7234               && relstart != NULL
7235               && elf_section_data (sec)->relocs != relstart)
7236             free (relstart);
7237           if (skip != NULL)
7238             free (skip);
7239           return FALSE;
7240         }
7241
7242       /* Now check all kept sections that might reference the toc.
7243          Check the toc itself last.  */
7244       for (sec = (ibfd->sections == toc && toc->next ? toc->next
7245                   : ibfd->sections);
7246            sec != NULL;
7247            sec = (sec == toc ? NULL
7248                   : sec->next == NULL ? toc
7249                   : sec->next == toc && toc->next ? toc->next
7250                   : sec->next))
7251         {
7252           int repeat;
7253
7254           if (sec->reloc_count == 0
7255               || elf_discarded_section (sec)
7256               || get_opd_info (sec)
7257               || (sec->flags & SEC_ALLOC) == 0
7258               || (sec->flags & SEC_DEBUGGING) != 0)
7259             continue;
7260
7261           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7262           if (relstart == NULL)
7263             goto error_ret;
7264
7265           /* Mark toc entries referenced as used.  */
7266           repeat = 0;
7267           do
7268             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7269               {
7270                 enum elf_ppc64_reloc_type r_type;
7271                 unsigned long r_symndx;
7272                 asection *sym_sec;
7273                 struct elf_link_hash_entry *h;
7274                 Elf_Internal_Sym *sym;
7275                 bfd_vma val;
7276
7277                 r_type = ELF64_R_TYPE (rel->r_info);
7278                 switch (r_type)
7279                   {
7280                   case R_PPC64_TOC16:
7281                   case R_PPC64_TOC16_LO:
7282                   case R_PPC64_TOC16_HI:
7283                   case R_PPC64_TOC16_HA:
7284                   case R_PPC64_TOC16_DS:
7285                   case R_PPC64_TOC16_LO_DS:
7286                     /* In case we're taking addresses of toc entries.  */
7287                   case R_PPC64_ADDR64:
7288                     break;
7289
7290                   default:
7291                     continue;
7292                   }
7293
7294                 r_symndx = ELF64_R_SYM (rel->r_info);
7295                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7296                                 r_symndx, ibfd))
7297                   {
7298                     free (used);
7299                     goto error_ret;
7300                   }
7301
7302                 if (sym_sec != toc)
7303                   continue;
7304
7305                 if (h != NULL)
7306                   val = h->root.u.def.value;
7307                 else
7308                   val = sym->st_value;
7309                 val += rel->r_addend;
7310
7311                 if (val >= toc->size)
7312                   continue;
7313
7314                 /* For the toc section, we only mark as used if
7315                    this entry itself isn't unused.  */
7316                 if (sec == toc
7317                     && !used[val >> 3]
7318                     && (used[rel->r_offset >> 3]
7319                         || !skip[rel->r_offset >> 3]))
7320                   /* Do all the relocs again, to catch reference
7321                      chains.  */
7322                   repeat = 1;
7323
7324                 used[val >> 3] = 1;
7325               }
7326           while (repeat);
7327         }
7328
7329       /* Merge the used and skip arrays.  Assume that TOC
7330          doublewords not appearing as either used or unused belong
7331          to to an entry more than one doubleword in size.  */
7332       for (drop = skip, keep = used, last = 0, some_unused = 0;
7333            drop < skip + (toc->size + 7) / 8;
7334            ++drop, ++keep)
7335         {
7336           if (*keep)
7337             {
7338               *drop = 0;
7339               last = 0;
7340             }
7341           else if (*drop)
7342             {
7343               some_unused = 1;
7344               last = 1;
7345             }
7346           else
7347             *drop = last;
7348         }
7349
7350       free (used);
7351
7352       if (some_unused)
7353         {
7354           bfd_byte *contents, *src;
7355           unsigned long off;
7356
7357           /* Shuffle the toc contents, and at the same time convert the
7358              skip array from booleans into offsets.  */
7359           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7360             goto error_ret;
7361
7362           elf_section_data (toc)->this_hdr.contents = contents;
7363
7364           for (src = contents, off = 0, drop = skip;
7365                src < contents + toc->size;
7366                src += 8, ++drop)
7367             {
7368               if (*drop)
7369                 {
7370                   *drop = (unsigned long) -1;
7371                   off += 8;
7372                 }
7373               else if (off != 0)
7374                 {
7375                   *drop = off;
7376                   memcpy (src - off, src, 8);
7377                 }
7378             }
7379           toc->rawsize = toc->size;
7380           toc->size = src - contents - off;
7381
7382           if (toc->reloc_count != 0)
7383             {
7384               Elf_Internal_Rela *wrel;
7385               bfd_size_type sz;
7386
7387               /* Read toc relocs.  */
7388               relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7389                                                     TRUE);
7390               if (relstart == NULL)
7391                 goto error_ret;
7392
7393               /* Remove unused toc relocs, and adjust those we keep.  */
7394               wrel = relstart;
7395               for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7396                 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7397                   {
7398                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7399                     wrel->r_info = rel->r_info;
7400                     wrel->r_addend = rel->r_addend;
7401                     ++wrel;
7402                   }
7403                 else if (!dec_dynrel_count (rel->r_info, toc, info,
7404                                             &local_syms, NULL, NULL))
7405                   goto error_ret;
7406
7407               toc->reloc_count = wrel - relstart;
7408               sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7409               elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7410               BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7411             }
7412
7413           /* Adjust addends for relocs against the toc section sym.  */
7414           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7415             {
7416               if (sec->reloc_count == 0
7417                   || elf_discarded_section (sec))
7418                 continue;
7419
7420               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7421                                                     TRUE);
7422               if (relstart == NULL)
7423                 goto error_ret;
7424
7425               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7426                 {
7427                   enum elf_ppc64_reloc_type r_type;
7428                   unsigned long r_symndx;
7429                   asection *sym_sec;
7430                   struct elf_link_hash_entry *h;
7431                   Elf_Internal_Sym *sym;
7432
7433                   r_type = ELF64_R_TYPE (rel->r_info);
7434                   switch (r_type)
7435                     {
7436                     default:
7437                       continue;
7438
7439                     case R_PPC64_TOC16:
7440                     case R_PPC64_TOC16_LO:
7441                     case R_PPC64_TOC16_HI:
7442                     case R_PPC64_TOC16_HA:
7443                     case R_PPC64_TOC16_DS:
7444                     case R_PPC64_TOC16_LO_DS:
7445                     case R_PPC64_ADDR64:
7446                       break;
7447                     }
7448
7449                   r_symndx = ELF64_R_SYM (rel->r_info);
7450                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7451                                   r_symndx, ibfd))
7452                     goto error_ret;
7453
7454                   if (sym_sec != toc || h != NULL || sym->st_value != 0)
7455                     continue;
7456
7457                   rel->r_addend -= skip[rel->r_addend >> 3];
7458                 }
7459             }
7460
7461           /* We shouldn't have local or global symbols defined in the TOC,
7462              but handle them anyway.  */
7463           if (local_syms != NULL)
7464             {
7465               Elf_Internal_Sym *sym;
7466
7467               for (sym = local_syms;
7468                    sym < local_syms + symtab_hdr->sh_info;
7469                    ++sym)
7470                 if (sym->st_shndx != SHN_UNDEF
7471                     && (sym->st_shndx < SHN_LORESERVE
7472                         || sym->st_shndx > SHN_HIRESERVE)
7473                     && sym->st_value != 0
7474                     && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7475                   {
7476                     if (skip[sym->st_value >> 3] != (unsigned long) -1)
7477                       sym->st_value -= skip[sym->st_value >> 3];
7478                     else
7479                       {
7480                         (*_bfd_error_handler)
7481                           (_("%s defined in removed toc entry"),
7482                            bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7483                                              NULL));
7484                         sym->st_value = 0;
7485                         sym->st_shndx = SHN_ABS;
7486                       }
7487                     symtab_hdr->contents = (unsigned char *) local_syms;
7488                   }
7489             }
7490
7491           /* Finally, adjust any global syms defined in the toc.  */
7492           if (toc_inf.global_toc_syms)
7493             {
7494               toc_inf.toc = toc;
7495               toc_inf.skip = skip;
7496               toc_inf.global_toc_syms = FALSE;
7497               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7498                                       &toc_inf);
7499             }
7500         }
7501
7502       if (local_syms != NULL
7503           && symtab_hdr->contents != (unsigned char *) local_syms)
7504         {
7505           if (!info->keep_memory)
7506             free (local_syms);
7507           else
7508             symtab_hdr->contents = (unsigned char *) local_syms;
7509         }
7510       free (skip);
7511     }
7512
7513   return TRUE;
7514 }
7515
7516 /* Allocate space in .plt, .got and associated reloc sections for
7517    dynamic relocs.  */
7518
7519 static bfd_boolean
7520 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7521 {
7522   struct bfd_link_info *info;
7523   struct ppc_link_hash_table *htab;
7524   asection *s;
7525   struct ppc_link_hash_entry *eh;
7526   struct ppc_dyn_relocs *p;
7527   struct got_entry *gent;
7528
7529   if (h->root.type == bfd_link_hash_indirect)
7530     return TRUE;
7531
7532   if (h->root.type == bfd_link_hash_warning)
7533     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7534
7535   info = (struct bfd_link_info *) inf;
7536   htab = ppc_hash_table (info);
7537
7538   if (htab->elf.dynamic_sections_created
7539       && h->dynindx != -1
7540       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7541     {
7542       struct plt_entry *pent;
7543       bfd_boolean doneone = FALSE;
7544       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7545         if (pent->plt.refcount > 0)
7546           {
7547             /* If this is the first .plt entry, make room for the special
7548                first entry.  */
7549             s = htab->plt;
7550             if (s->size == 0)
7551               s->size += PLT_INITIAL_ENTRY_SIZE;
7552
7553             pent->plt.offset = s->size;
7554
7555             /* Make room for this entry.  */
7556             s->size += PLT_ENTRY_SIZE;
7557
7558             /* Make room for the .glink code.  */
7559             s = htab->glink;
7560             if (s->size == 0)
7561               s->size += GLINK_CALL_STUB_SIZE;
7562             /* We need bigger stubs past index 32767.  */
7563             if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
7564               s->size += 4;
7565             s->size += 2*4;
7566
7567             /* We also need to make an entry in the .rela.plt section.  */
7568             s = htab->relplt;
7569             s->size += sizeof (Elf64_External_Rela);
7570             doneone = TRUE;
7571           }
7572         else
7573           pent->plt.offset = (bfd_vma) -1;
7574       if (!doneone)
7575         {
7576           h->plt.plist = NULL;
7577           h->needs_plt = 0;
7578         }
7579     }
7580   else
7581     {
7582       h->plt.plist = NULL;
7583       h->needs_plt = 0;
7584     }
7585
7586   eh = (struct ppc_link_hash_entry *) h;
7587   /* Run through the TLS GD got entries first if we're changing them
7588      to TPREL.  */
7589   if ((eh->tls_mask & TLS_TPRELGD) != 0)
7590     for (gent = h->got.glist; gent != NULL; gent = gent->next)
7591       if (gent->got.refcount > 0
7592           && (gent->tls_type & TLS_GD) != 0)
7593         {
7594           /* This was a GD entry that has been converted to TPREL.  If
7595              there happens to be a TPREL entry we can use that one.  */
7596           struct got_entry *ent;
7597           for (ent = h->got.glist; ent != NULL; ent = ent->next)
7598             if (ent->got.refcount > 0
7599                 && (ent->tls_type & TLS_TPREL) != 0
7600                 && ent->addend == gent->addend
7601                 && ent->owner == gent->owner)
7602               {
7603                 gent->got.refcount = 0;
7604                 break;
7605               }
7606
7607           /* If not, then we'll be using our own TPREL entry.  */
7608           if (gent->got.refcount != 0)
7609             gent->tls_type = TLS_TLS | TLS_TPREL;
7610         }
7611
7612   for (gent = h->got.glist; gent != NULL; gent = gent->next)
7613     if (gent->got.refcount > 0)
7614       {
7615         bfd_boolean dyn;
7616
7617         /* Make sure this symbol is output as a dynamic symbol.
7618            Undefined weak syms won't yet be marked as dynamic,
7619            nor will all TLS symbols.  */
7620         if (h->dynindx == -1
7621             && !h->forced_local)
7622           {
7623             if (! bfd_elf_link_record_dynamic_symbol (info, h))
7624               return FALSE;
7625           }
7626
7627         if ((gent->tls_type & TLS_LD) != 0
7628             && !h->def_dynamic)
7629           {
7630             gent->got.offset = ppc64_tlsld_got (gent->owner)->offset;
7631             continue;
7632           }
7633
7634         s = ppc64_elf_tdata (gent->owner)->got;
7635         gent->got.offset = s->size;
7636         s->size
7637           += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
7638         dyn = htab->elf.dynamic_sections_created;
7639         if ((info->shared
7640              || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
7641             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7642                 || h->root.type != bfd_link_hash_undefweak))
7643           ppc64_elf_tdata (gent->owner)->relgot->size
7644             += (gent->tls_type & eh->tls_mask & TLS_GD
7645                 ? 2 * sizeof (Elf64_External_Rela)
7646                 : sizeof (Elf64_External_Rela));
7647       }
7648     else
7649       gent->got.offset = (bfd_vma) -1;
7650
7651   if (eh->dyn_relocs == NULL)
7652     return TRUE;
7653
7654   /* In the shared -Bsymbolic case, discard space allocated for
7655      dynamic pc-relative relocs against symbols which turn out to be
7656      defined in regular objects.  For the normal shared case, discard
7657      space for relocs that have become local due to symbol visibility
7658      changes.  */
7659
7660   if (info->shared)
7661     {
7662       /* Relocs that use pc_count are those that appear on a call insn,
7663          or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
7664          generated via assembly.  We want calls to protected symbols to
7665          resolve directly to the function rather than going via the plt.
7666          If people want function pointer comparisons to work as expected
7667          then they should avoid writing weird assembly.  */
7668       if (SYMBOL_CALLS_LOCAL (info, h))
7669         {
7670           struct ppc_dyn_relocs **pp;
7671
7672           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
7673             {
7674               p->count -= p->pc_count;
7675               p->pc_count = 0;
7676               if (p->count == 0)
7677                 *pp = p->next;
7678               else
7679                 pp = &p->next;
7680             }
7681         }
7682
7683       /* Also discard relocs on undefined weak syms with non-default
7684          visibility.  */
7685       if (eh->dyn_relocs != NULL
7686           && h->root.type == bfd_link_hash_undefweak)
7687         {
7688           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
7689             eh->dyn_relocs = NULL;
7690
7691           /* Make sure this symbol is output as a dynamic symbol.
7692              Undefined weak syms won't yet be marked as dynamic.  */
7693           else if (h->dynindx == -1
7694                    && !h->forced_local)
7695             {
7696               if (! bfd_elf_link_record_dynamic_symbol (info, h))
7697                 return FALSE;
7698             }
7699         }
7700     }
7701   else if (ELIMINATE_COPY_RELOCS)
7702     {
7703       /* For the non-shared case, discard space for relocs against
7704          symbols which turn out to need copy relocs or are not
7705          dynamic.  */
7706
7707       if (!h->non_got_ref
7708           && h->def_dynamic
7709           && !h->def_regular)
7710         {
7711           /* Make sure this symbol is output as a dynamic symbol.
7712              Undefined weak syms won't yet be marked as dynamic.  */
7713           if (h->dynindx == -1
7714               && !h->forced_local)
7715             {
7716               if (! bfd_elf_link_record_dynamic_symbol (info, h))
7717                 return FALSE;
7718             }
7719
7720           /* If that succeeded, we know we'll be keeping all the
7721              relocs.  */
7722           if (h->dynindx != -1)
7723             goto keep;
7724         }
7725
7726       eh->dyn_relocs = NULL;
7727
7728     keep: ;
7729     }
7730
7731   /* Finally, allocate space.  */
7732   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7733     {
7734       asection *sreloc = elf_section_data (p->sec)->sreloc;
7735       sreloc->size += p->count * sizeof (Elf64_External_Rela);
7736     }
7737
7738   return TRUE;
7739 }
7740
7741 /* Find any dynamic relocs that apply to read-only sections.  */
7742
7743 static bfd_boolean
7744 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7745 {
7746   struct ppc_link_hash_entry *eh;
7747   struct ppc_dyn_relocs *p;
7748
7749   if (h->root.type == bfd_link_hash_warning)
7750     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7751
7752   eh = (struct ppc_link_hash_entry *) h;
7753   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7754     {
7755       asection *s = p->sec->output_section;
7756
7757       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7758         {
7759           struct bfd_link_info *info = inf;
7760
7761           info->flags |= DF_TEXTREL;
7762
7763           /* Not an error, just cut short the traversal.  */
7764           return FALSE;
7765         }
7766     }
7767   return TRUE;
7768 }
7769
7770 /* Set the sizes of the dynamic sections.  */
7771
7772 static bfd_boolean
7773 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
7774                                  struct bfd_link_info *info)
7775 {
7776   struct ppc_link_hash_table *htab;
7777   bfd *dynobj;
7778   asection *s;
7779   bfd_boolean relocs;
7780   bfd *ibfd;
7781
7782   htab = ppc_hash_table (info);
7783   dynobj = htab->elf.dynobj;
7784   if (dynobj == NULL)
7785     abort ();
7786
7787   if (htab->elf.dynamic_sections_created)
7788     {
7789       /* Set the contents of the .interp section to the interpreter.  */
7790       if (info->executable)
7791         {
7792           s = bfd_get_section_by_name (dynobj, ".interp");
7793           if (s == NULL)
7794             abort ();
7795           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
7796           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
7797         }
7798     }
7799
7800   /* Set up .got offsets for local syms, and space for local dynamic
7801      relocs.  */
7802   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7803     {
7804       struct got_entry **lgot_ents;
7805       struct got_entry **end_lgot_ents;
7806       char *lgot_masks;
7807       bfd_size_type locsymcount;
7808       Elf_Internal_Shdr *symtab_hdr;
7809       asection *srel;
7810
7811       if (!is_ppc64_elf_target (ibfd->xvec))
7812         continue;
7813
7814       if (ppc64_tlsld_got (ibfd)->refcount > 0)
7815         {
7816           s = ppc64_elf_tdata (ibfd)->got;
7817           ppc64_tlsld_got (ibfd)->offset = s->size;
7818           s->size += 16;
7819           if (info->shared)
7820             {
7821               srel = ppc64_elf_tdata (ibfd)->relgot;
7822               srel->size += sizeof (Elf64_External_Rela);
7823             }
7824         }
7825       else
7826         ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
7827
7828       for (s = ibfd->sections; s != NULL; s = s->next)
7829         {
7830           struct ppc_dyn_relocs *p;
7831
7832           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
7833             {
7834               if (!bfd_is_abs_section (p->sec)
7835                   && bfd_is_abs_section (p->sec->output_section))
7836                 {
7837                   /* Input section has been discarded, either because
7838                      it is a copy of a linkonce section or due to
7839                      linker script /DISCARD/, so we'll be discarding
7840                      the relocs too.  */
7841                 }
7842               else if (p->count != 0)
7843                 {
7844                   srel = elf_section_data (p->sec)->sreloc;
7845                   srel->size += p->count * sizeof (Elf64_External_Rela);
7846                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
7847                     info->flags |= DF_TEXTREL;
7848                 }
7849             }
7850         }
7851
7852       lgot_ents = elf_local_got_ents (ibfd);
7853       if (!lgot_ents)
7854         continue;
7855
7856       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7857       locsymcount = symtab_hdr->sh_info;
7858       end_lgot_ents = lgot_ents + locsymcount;
7859       lgot_masks = (char *) end_lgot_ents;
7860       s = ppc64_elf_tdata (ibfd)->got;
7861       srel = ppc64_elf_tdata (ibfd)->relgot;
7862       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
7863         {
7864           struct got_entry *ent;
7865
7866           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
7867             if (ent->got.refcount > 0)
7868               {
7869                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
7870                   {
7871                     if (ppc64_tlsld_got (ibfd)->offset == (bfd_vma) -1)
7872                       {
7873                         ppc64_tlsld_got (ibfd)->offset = s->size;
7874                         s->size += 16;
7875                         if (info->shared)
7876                           srel->size += sizeof (Elf64_External_Rela);
7877                       }
7878                     ent->got.offset = ppc64_tlsld_got (ibfd)->offset;
7879                   }
7880                 else
7881                   {
7882                     ent->got.offset = s->size;
7883                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
7884                       {
7885                         s->size += 16;
7886                         if (info->shared)
7887                           srel->size += 2 * sizeof (Elf64_External_Rela);
7888                       }
7889                     else
7890                       {
7891                         s->size += 8;
7892                         if (info->shared)
7893                           srel->size += sizeof (Elf64_External_Rela);
7894                       }
7895                   }
7896               }
7897             else
7898               ent->got.offset = (bfd_vma) -1;
7899         }
7900     }
7901
7902   /* Allocate global sym .plt and .got entries, and space for global
7903      sym dynamic relocs.  */
7904   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
7905
7906   /* We now have determined the sizes of the various dynamic sections.
7907      Allocate memory for them.  */
7908   relocs = FALSE;
7909   for (s = dynobj->sections; s != NULL; s = s->next)
7910     {
7911       if ((s->flags & SEC_LINKER_CREATED) == 0)
7912         continue;
7913
7914       if (s == htab->brlt || s == htab->relbrlt)
7915         /* These haven't been allocated yet;  don't strip.  */
7916         continue;
7917       else if (s == htab->got
7918                || s == htab->plt
7919                || s == htab->glink
7920                || s == htab->dynbss)
7921         {
7922           /* Strip this section if we don't need it; see the
7923              comment below.  */
7924         }
7925       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
7926         {
7927           if (s->size != 0)
7928             {
7929               if (s != htab->relplt)
7930                 relocs = TRUE;
7931
7932               /* We use the reloc_count field as a counter if we need
7933                  to copy relocs into the output file.  */
7934               s->reloc_count = 0;
7935             }
7936         }
7937       else
7938         {
7939           /* It's not one of our sections, so don't allocate space.  */
7940           continue;
7941         }
7942
7943       if (s->size == 0)
7944         {
7945           /* If we don't need this section, strip it from the
7946              output file.  This is mostly to handle .rela.bss and
7947              .rela.plt.  We must create both sections in
7948              create_dynamic_sections, because they must be created
7949              before the linker maps input sections to output
7950              sections.  The linker does that before
7951              adjust_dynamic_symbol is called, and it is that
7952              function which decides whether anything needs to go
7953              into these sections.  */
7954           s->flags |= SEC_EXCLUDE;
7955           continue;
7956         }
7957
7958       if ((s->flags & SEC_HAS_CONTENTS) == 0)
7959         continue;
7960
7961       /* Allocate memory for the section contents.  We use bfd_zalloc
7962          here in case unused entries are not reclaimed before the
7963          section's contents are written out.  This should not happen,
7964          but this way if it does we get a R_PPC64_NONE reloc in .rela
7965          sections instead of garbage.
7966          We also rely on the section contents being zero when writing
7967          the GOT.  */
7968       s->contents = bfd_zalloc (dynobj, s->size);
7969       if (s->contents == NULL)
7970         return FALSE;
7971     }
7972
7973   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7974     {
7975       if (!is_ppc64_elf_target (ibfd->xvec))
7976         continue;
7977
7978       s = ppc64_elf_tdata (ibfd)->got;
7979       if (s != NULL && s != htab->got)
7980         {
7981           if (s->size == 0)
7982             s->flags |= SEC_EXCLUDE;
7983           else
7984             {
7985               s->contents = bfd_zalloc (ibfd, s->size);
7986               if (s->contents == NULL)
7987                 return FALSE;
7988             }
7989         }
7990       s = ppc64_elf_tdata (ibfd)->relgot;
7991       if (s != NULL)
7992         {
7993           if (s->size == 0)
7994             s->flags |= SEC_EXCLUDE;
7995           else
7996             {
7997               s->contents = bfd_zalloc (ibfd, s->size);
7998               if (s->contents == NULL)
7999                 return FALSE;
8000               relocs = TRUE;
8001               s->reloc_count = 0;
8002             }
8003         }
8004     }
8005
8006   if (htab->elf.dynamic_sections_created)
8007     {
8008       /* Add some entries to the .dynamic section.  We fill in the
8009          values later, in ppc64_elf_finish_dynamic_sections, but we
8010          must add the entries now so that we get the correct size for
8011          the .dynamic section.  The DT_DEBUG entry is filled in by the
8012          dynamic linker and used by the debugger.  */
8013 #define add_dynamic_entry(TAG, VAL) \
8014   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8015
8016       if (info->executable)
8017         {
8018           if (!add_dynamic_entry (DT_DEBUG, 0))
8019             return FALSE;
8020         }
8021
8022       if (htab->plt != NULL && htab->plt->size != 0)
8023         {
8024           if (!add_dynamic_entry (DT_PLTGOT, 0)
8025               || !add_dynamic_entry (DT_PLTRELSZ, 0)
8026               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8027               || !add_dynamic_entry (DT_JMPREL, 0)
8028               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8029             return FALSE;
8030         }
8031
8032       if (NO_OPD_RELOCS)
8033         {
8034           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8035               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8036             return FALSE;
8037         }
8038
8039       if (relocs)
8040         {
8041           if (!add_dynamic_entry (DT_RELA, 0)
8042               || !add_dynamic_entry (DT_RELASZ, 0)
8043               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8044             return FALSE;
8045
8046           /* If any dynamic relocs apply to a read-only section,
8047              then we need a DT_TEXTREL entry.  */
8048           if ((info->flags & DF_TEXTREL) == 0)
8049             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8050
8051           if ((info->flags & DF_TEXTREL) != 0)
8052             {
8053               if (!add_dynamic_entry (DT_TEXTREL, 0))
8054                 return FALSE;
8055             }
8056         }
8057     }
8058 #undef add_dynamic_entry
8059
8060   return TRUE;
8061 }
8062
8063 /* Determine the type of stub needed, if any, for a call.  */
8064
8065 static inline enum ppc_stub_type
8066 ppc_type_of_stub (asection *input_sec,
8067                   const Elf_Internal_Rela *rel,
8068                   struct ppc_link_hash_entry **hash,
8069                   bfd_vma destination)
8070 {
8071   struct ppc_link_hash_entry *h = *hash;
8072   bfd_vma location;
8073   bfd_vma branch_offset;
8074   bfd_vma max_branch_offset;
8075   enum elf_ppc64_reloc_type r_type;
8076
8077   if (h != NULL)
8078     {
8079       struct ppc_link_hash_entry *fdh = h;
8080       if (fdh->oh != NULL
8081           && fdh->oh->is_func_descriptor)
8082         fdh = fdh->oh;
8083
8084       if (fdh->elf.dynindx != -1)
8085         {
8086           struct plt_entry *ent;
8087
8088           for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8089             if (ent->addend == rel->r_addend
8090                 && ent->plt.offset != (bfd_vma) -1)
8091               {
8092                 *hash = fdh;
8093                 return ppc_stub_plt_call;
8094               }
8095         }
8096
8097       /* Here, we know we don't have a plt entry.  If we don't have a
8098          either a defined function descriptor or a defined entry symbol
8099          in a regular object file, then it is pointless trying to make
8100          any other type of stub.  */
8101       if (!((fdh->elf.root.type == bfd_link_hash_defined
8102             || fdh->elf.root.type == bfd_link_hash_defweak)
8103             && fdh->elf.root.u.def.section->output_section != NULL)
8104           && !((h->elf.root.type == bfd_link_hash_defined
8105                 || h->elf.root.type == bfd_link_hash_defweak)
8106                && h->elf.root.u.def.section->output_section != NULL))
8107         return ppc_stub_none;
8108     }
8109
8110   /* Determine where the call point is.  */
8111   location = (input_sec->output_offset
8112               + input_sec->output_section->vma
8113               + rel->r_offset);
8114
8115   branch_offset = destination - location;
8116   r_type = ELF64_R_TYPE (rel->r_info);
8117
8118   /* Determine if a long branch stub is needed.  */
8119   max_branch_offset = 1 << 25;
8120   if (r_type != R_PPC64_REL24)
8121     max_branch_offset = 1 << 15;
8122
8123   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8124     /* We need a stub.  Figure out whether a long_branch or plt_branch
8125        is needed later.  */
8126     return ppc_stub_long_branch;
8127
8128   return ppc_stub_none;
8129 }
8130
8131 /* Build a .plt call stub.  */
8132
8133 static inline bfd_byte *
8134 build_plt_stub (bfd *obfd, bfd_byte *p, int offset)
8135 {
8136 #define PPC_LO(v) ((v) & 0xffff)
8137 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8138 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8139
8140   bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
8141   bfd_put_32 (obfd, STD_R2_40R1, p),                    p += 4;
8142   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
8143   if (PPC_HA (offset + 8) != PPC_HA (offset))
8144     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
8145   offset += 8;
8146   bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p),   p += 4;
8147   if (PPC_HA (offset + 8) != PPC_HA (offset))
8148     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
8149   offset += 8;
8150   bfd_put_32 (obfd, MTCTR_R11, p),                      p += 4;
8151   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
8152   bfd_put_32 (obfd, BCTR, p),                           p += 4;
8153   return p;
8154 }
8155
8156 static bfd_boolean
8157 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8158 {
8159   struct ppc_stub_hash_entry *stub_entry;
8160   struct ppc_branch_hash_entry *br_entry;
8161   struct bfd_link_info *info;
8162   struct ppc_link_hash_table *htab;
8163   bfd_byte *loc;
8164   bfd_byte *p;
8165   unsigned int indx;
8166   struct plt_entry *ent;
8167   bfd_vma dest, off;
8168   int size;
8169
8170   /* Massage our args to the form they really have.  */
8171   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8172   info = in_arg;
8173
8174   htab = ppc_hash_table (info);
8175
8176   /* Make a note of the offset within the stubs for this entry.  */
8177   stub_entry->stub_offset = stub_entry->stub_sec->size;
8178   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
8179
8180   htab->stub_count[stub_entry->stub_type - 1] += 1;
8181   switch (stub_entry->stub_type)
8182     {
8183     case ppc_stub_long_branch:
8184     case ppc_stub_long_branch_r2off:
8185       /* Branches are relative.  This is where we are going to.  */
8186       off = dest = (stub_entry->target_value
8187                     + stub_entry->target_section->output_offset
8188                     + stub_entry->target_section->output_section->vma);
8189
8190       /* And this is where we are coming from.  */
8191       off -= (stub_entry->stub_offset
8192               + stub_entry->stub_sec->output_offset
8193               + stub_entry->stub_sec->output_section->vma);
8194
8195       if (stub_entry->stub_type != ppc_stub_long_branch_r2off)
8196         size = 4;
8197       else
8198         {
8199           bfd_vma r2off;
8200
8201           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8202                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
8203           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8204           loc += 4;
8205           bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8206           loc += 4;
8207           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8208           loc += 4;
8209           off -= 12;
8210           size = 16;
8211         }
8212       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
8213
8214       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8215         {
8216           (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8217                                  stub_entry->root.string);
8218           htab->stub_error = TRUE;
8219           return FALSE;
8220         }
8221
8222       if (info->emitrelocations)
8223         {
8224           Elf_Internal_Rela *relocs, *r;
8225           struct bfd_elf_section_data *elfsec_data;
8226
8227           elfsec_data = elf_section_data (stub_entry->stub_sec);
8228           relocs = elfsec_data->relocs;
8229           if (relocs == NULL)
8230             {
8231               bfd_size_type relsize;
8232               relsize = stub_entry->stub_sec->reloc_count * sizeof (*relocs);
8233               relocs = bfd_alloc (htab->stub_bfd, relsize);
8234               if (relocs == NULL)
8235                 return FALSE;
8236               elfsec_data->relocs = relocs;
8237               elfsec_data->rel_hdr.sh_size = relsize;
8238               elfsec_data->rel_hdr.sh_entsize = 24;
8239               stub_entry->stub_sec->reloc_count = 0;
8240             }
8241           r = relocs + stub_entry->stub_sec->reloc_count;
8242           stub_entry->stub_sec->reloc_count += 1;
8243           r->r_offset = loc - stub_entry->stub_sec->contents;
8244           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8245           r->r_addend = dest;
8246           if (stub_entry->h != NULL)
8247             {
8248               struct elf_link_hash_entry **hashes;
8249               unsigned long symndx;
8250               struct ppc_link_hash_entry *h;
8251
8252               hashes = elf_sym_hashes (htab->stub_bfd);
8253               if (hashes == NULL)
8254                 {
8255                   bfd_size_type hsize;
8256
8257                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8258                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
8259                   if (hashes == NULL)
8260                     return FALSE;
8261                   elf_sym_hashes (htab->stub_bfd) = hashes;
8262                   htab->stub_globals = 1;
8263                 }
8264               symndx = htab->stub_globals++;
8265               h = stub_entry->h;
8266               hashes[symndx] = &h->elf;
8267               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8268               if (h->oh != NULL && h->oh->is_func)
8269                 h = h->oh;
8270               if (h->elf.root.u.def.section != stub_entry->target_section)
8271                 /* H is an opd symbol.  The addend must be zero.  */
8272                 r->r_addend = 0;
8273               else
8274                 {
8275                   off = (h->elf.root.u.def.value
8276                          + h->elf.root.u.def.section->output_offset
8277                          + h->elf.root.u.def.section->output_section->vma);
8278                   r->r_addend -= off;
8279                 }
8280             }
8281         }
8282       break;
8283
8284     case ppc_stub_plt_branch:
8285     case ppc_stub_plt_branch_r2off:
8286       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8287                                          stub_entry->root.string + 9,
8288                                          FALSE, FALSE);
8289       if (br_entry == NULL)
8290         {
8291           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
8292                                  stub_entry->root.string);
8293           htab->stub_error = TRUE;
8294           return FALSE;
8295         }
8296
8297       off = (stub_entry->target_value
8298              + stub_entry->target_section->output_offset
8299              + stub_entry->target_section->output_section->vma);
8300
8301       bfd_put_64 (htab->brlt->owner, off,
8302                   htab->brlt->contents + br_entry->offset);
8303
8304       if (htab->relbrlt != NULL)
8305         {
8306           /* Create a reloc for the branch lookup table entry.  */
8307           Elf_Internal_Rela rela;
8308           bfd_byte *rl;
8309
8310           rela.r_offset = (br_entry->offset
8311                            + htab->brlt->output_offset
8312                            + htab->brlt->output_section->vma);
8313           rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8314           rela.r_addend = off;
8315
8316           rl = htab->relbrlt->contents;
8317           rl += htab->relbrlt->reloc_count++ * sizeof (Elf64_External_Rela);
8318           bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
8319         }
8320
8321       off = (br_entry->offset
8322              + htab->brlt->output_offset
8323              + htab->brlt->output_section->vma
8324              - elf_gp (htab->brlt->output_section->owner)
8325              - htab->stub_group[stub_entry->id_sec->id].toc_off);
8326
8327       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8328         {
8329           (*_bfd_error_handler)
8330             (_("linkage table error against `%s'"),
8331              stub_entry->root.string);
8332           bfd_set_error (bfd_error_bad_value);
8333           htab->stub_error = TRUE;
8334           return FALSE;
8335         }
8336
8337       indx = off;
8338       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8339         {
8340           bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
8341           loc += 4;
8342           bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
8343           size = 16;
8344         }
8345       else
8346         {
8347           bfd_vma r2off;
8348
8349           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8350                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
8351           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8352           loc += 4;
8353           bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
8354           loc += 4;
8355           bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
8356           loc += 4;
8357           bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8358           loc += 4;
8359           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8360           size = 28;
8361         }
8362       loc += 4;
8363       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
8364       loc += 4;
8365       bfd_put_32 (htab->stub_bfd, BCTR, loc);
8366       break;
8367
8368     case ppc_stub_plt_call:
8369       /* Do the best we can for shared libraries built without
8370          exporting ".foo" for each "foo".  This can happen when symbol
8371          versioning scripts strip all bar a subset of symbols.  */
8372       if (stub_entry->h->oh != NULL
8373           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
8374           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
8375         {
8376           /* Point the symbol at the stub.  There may be multiple stubs,
8377              we don't really care;  The main thing is to make this sym
8378              defined somewhere.  Maybe defining the symbol in the stub
8379              section is a silly idea.  If we didn't do this, htab->top_id
8380              could disappear.  */
8381           stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
8382           stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
8383           stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
8384         }
8385
8386       /* Now build the stub.  */
8387       off = (bfd_vma) -1;
8388       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8389         if (ent->addend == stub_entry->addend)
8390           {
8391             off = ent->plt.offset;
8392             break;
8393           }
8394       if (off >= (bfd_vma) -2)
8395         abort ();
8396
8397       off &= ~ (bfd_vma) 1;
8398       off += (htab->plt->output_offset
8399               + htab->plt->output_section->vma
8400               - elf_gp (htab->plt->output_section->owner)
8401               - htab->stub_group[stub_entry->id_sec->id].toc_off);
8402
8403       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8404         {
8405           (*_bfd_error_handler)
8406             (_("linkage table error against `%s'"),
8407              stub_entry->h->elf.root.root.string);
8408           bfd_set_error (bfd_error_bad_value);
8409           htab->stub_error = TRUE;
8410           return FALSE;
8411         }
8412
8413       p = build_plt_stub (htab->stub_bfd, loc, off);
8414       size = p - loc;
8415       break;
8416
8417     default:
8418       BFD_FAIL ();
8419       return FALSE;
8420     }
8421
8422   stub_entry->stub_sec->size += size;
8423
8424   if (htab->emit_stub_syms)
8425     {
8426       struct elf_link_hash_entry *h;
8427       size_t len1, len2;
8428       char *name;
8429       const char *const stub_str[] = { "long_branch",
8430                                        "long_branch_r2off",
8431                                        "plt_branch",
8432                                        "plt_branch_r2off",
8433                                        "plt_call" };
8434
8435       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
8436       len2 = strlen (stub_entry->root.string);
8437       name = bfd_malloc (len1 + len2 + 2);
8438       if (name == NULL)
8439         return FALSE;
8440       memcpy (name, stub_entry->root.string, 9);
8441       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
8442       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
8443       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
8444       if (h == NULL)
8445         return FALSE;
8446       if (h->root.type == bfd_link_hash_new)
8447         {
8448           h->root.type = bfd_link_hash_defined;
8449           h->root.u.def.section = stub_entry->stub_sec;
8450           h->root.u.def.value = stub_entry->stub_offset;
8451           h->ref_regular = 1;
8452           h->def_regular = 1;
8453           h->ref_regular_nonweak = 1;
8454           h->forced_local = 1;
8455           h->non_elf = 0;
8456         }
8457     }
8458
8459   return TRUE;
8460 }
8461
8462 /* As above, but don't actually build the stub.  Just bump offset so
8463    we know stub section sizes, and select plt_branch stubs where
8464    long_branch stubs won't do.  */
8465
8466 static bfd_boolean
8467 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8468 {
8469   struct ppc_stub_hash_entry *stub_entry;
8470   struct bfd_link_info *info;
8471   struct ppc_link_hash_table *htab;
8472   bfd_vma off;
8473   int size;
8474
8475   /* Massage our args to the form they really have.  */
8476   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8477   info = in_arg;
8478
8479   htab = ppc_hash_table (info);
8480
8481   if (stub_entry->stub_type == ppc_stub_plt_call)
8482     {
8483       struct plt_entry *ent;
8484       off = (bfd_vma) -1;
8485       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8486         if (ent->addend == stub_entry->addend)
8487           {
8488             off = ent->plt.offset & ~(bfd_vma) 1;
8489             break;
8490           }
8491       if (off >= (bfd_vma) -2)
8492         abort ();
8493       off += (htab->plt->output_offset
8494               + htab->plt->output_section->vma
8495               - elf_gp (htab->plt->output_section->owner)
8496               - htab->stub_group[stub_entry->id_sec->id].toc_off);
8497
8498       size = PLT_CALL_STUB_SIZE;
8499       if (PPC_HA (off + 16) != PPC_HA (off))
8500         size += 4;
8501     }
8502   else
8503     {
8504       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
8505          variants.  */
8506       off = (stub_entry->target_value
8507              + stub_entry->target_section->output_offset
8508              + stub_entry->target_section->output_section->vma);
8509       off -= (stub_entry->stub_sec->size
8510               + stub_entry->stub_sec->output_offset
8511               + stub_entry->stub_sec->output_section->vma);
8512
8513       /* Reset the stub type from the plt variant in case we now
8514          can reach with a shorter stub.  */
8515       if (stub_entry->stub_type >= ppc_stub_plt_branch)
8516         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
8517
8518       size = 4;
8519       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8520         {
8521           off -= 12;
8522           size = 16;
8523         }
8524
8525       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
8526       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8527         {
8528           struct ppc_branch_hash_entry *br_entry;
8529
8530           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8531                                              stub_entry->root.string + 9,
8532                                              TRUE, FALSE);
8533           if (br_entry == NULL)
8534             {
8535               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
8536                                      stub_entry->root.string);
8537               htab->stub_error = TRUE;
8538               return FALSE;
8539             }
8540
8541           if (br_entry->iter != htab->stub_iteration)
8542             {
8543               br_entry->iter = htab->stub_iteration;
8544               br_entry->offset = htab->brlt->size;
8545               htab->brlt->size += 8;
8546
8547               if (htab->relbrlt != NULL)
8548                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
8549             }
8550
8551           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
8552           size = 16;
8553           if (stub_entry->stub_type != ppc_stub_plt_branch)
8554             size = 28;
8555         }
8556
8557       if (info->emitrelocations
8558           && (stub_entry->stub_type == ppc_stub_long_branch
8559               || stub_entry->stub_type == ppc_stub_long_branch_r2off))
8560         stub_entry->stub_sec->reloc_count += 1;
8561     }
8562
8563   stub_entry->stub_sec->size += size;
8564   return TRUE;
8565 }
8566
8567 /* Set up various things so that we can make a list of input sections
8568    for each output section included in the link.  Returns -1 on error,
8569    0 when no stubs will be needed, and 1 on success.  */
8570
8571 int
8572 ppc64_elf_setup_section_lists (bfd *output_bfd,
8573                                struct bfd_link_info *info,
8574                                int no_multi_toc)
8575 {
8576   bfd *input_bfd;
8577   int top_id, top_index, id;
8578   asection *section;
8579   asection **input_list;
8580   bfd_size_type amt;
8581   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8582
8583   htab->no_multi_toc = no_multi_toc;
8584
8585   if (htab->brlt == NULL)
8586     return 0;
8587
8588   /* Find the top input section id.  */
8589   for (input_bfd = info->input_bfds, top_id = 3;
8590        input_bfd != NULL;
8591        input_bfd = input_bfd->link_next)
8592     {
8593       for (section = input_bfd->sections;
8594            section != NULL;
8595            section = section->next)
8596         {
8597           if (top_id < section->id)
8598             top_id = section->id;
8599         }
8600     }
8601
8602   htab->top_id = top_id;
8603   amt = sizeof (struct map_stub) * (top_id + 1);
8604   htab->stub_group = bfd_zmalloc (amt);
8605   if (htab->stub_group == NULL)
8606     return -1;
8607
8608   /* Set toc_off for com, und, abs and ind sections.  */
8609   for (id = 0; id < 3; id++)
8610     htab->stub_group[id].toc_off = TOC_BASE_OFF;
8611
8612   elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
8613
8614   /* We can't use output_bfd->section_count here to find the top output
8615      section index as some sections may have been removed, and
8616      strip_excluded_output_sections doesn't renumber the indices.  */
8617   for (section = output_bfd->sections, top_index = 0;
8618        section != NULL;
8619        section = section->next)
8620     {
8621       if (top_index < section->index)
8622         top_index = section->index;
8623     }
8624
8625   htab->top_index = top_index;
8626   amt = sizeof (asection *) * (top_index + 1);
8627   input_list = bfd_zmalloc (amt);
8628   htab->input_list = input_list;
8629   if (input_list == NULL)
8630     return -1;
8631
8632   return 1;
8633 }
8634
8635 /* The linker repeatedly calls this function for each TOC input section
8636    and linker generated GOT section.  Group input bfds such that the toc
8637    within a group is less than 64k in size.  Will break with cute linker
8638    scripts that play games with dot in the output toc section.  */
8639
8640 void
8641 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
8642 {
8643   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8644
8645   if (!htab->no_multi_toc)
8646     {
8647       bfd_vma addr = isec->output_offset + isec->output_section->vma;
8648       bfd_vma off = addr - htab->toc_curr;
8649
8650       if (off + isec->size > 0x10000)
8651         htab->toc_curr = addr;
8652
8653       elf_gp (isec->owner) = (htab->toc_curr
8654                               - elf_gp (isec->output_section->owner)
8655                               + TOC_BASE_OFF);
8656     }
8657 }
8658
8659 /* Called after the last call to the above function.  */
8660
8661 void
8662 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
8663 {
8664   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8665
8666   htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
8667
8668   /* toc_curr tracks the TOC offset used for code sections below in
8669      ppc64_elf_next_input_section.  Start off at 0x8000.  */
8670   htab->toc_curr = TOC_BASE_OFF;
8671 }
8672
8673 /* No toc references were found in ISEC.  If the code in ISEC makes no
8674    calls, then there's no need to use toc adjusting stubs when branching
8675    into ISEC.  Actually, indirect calls from ISEC are OK as they will
8676    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
8677    needed, and 2 if a cyclical call-graph was found but no other reason
8678    for a stub was detected.  If called from the top level, a return of
8679    2 means the same as a return of 0.  */
8680
8681 static int
8682 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
8683 {
8684   Elf_Internal_Rela *relstart, *rel;
8685   Elf_Internal_Sym *local_syms;
8686   int ret;
8687   struct ppc_link_hash_table *htab;
8688
8689   /* We know none of our code bearing sections will need toc stubs.  */
8690   if ((isec->flags & SEC_LINKER_CREATED) != 0)
8691     return 0;
8692
8693   if (isec->size == 0)
8694     return 0;
8695
8696   if (isec->output_section == NULL)
8697     return 0;
8698
8699   /* Hack for linux kernel.  .fixup contains branches, but only back to
8700      the function that hit an exception.  */
8701   if (strcmp (isec->name, ".fixup") == 0)
8702     return 0;
8703
8704   if (isec->reloc_count == 0)
8705     return 0;
8706
8707   relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
8708                                         info->keep_memory);
8709   if (relstart == NULL)
8710     return -1;
8711
8712   /* Look for branches to outside of this section.  */
8713   local_syms = NULL;
8714   ret = 0;
8715   htab = ppc_hash_table (info);
8716   for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
8717     {
8718       enum elf_ppc64_reloc_type r_type;
8719       unsigned long r_symndx;
8720       struct elf_link_hash_entry *h;
8721       Elf_Internal_Sym *sym;
8722       asection *sym_sec;
8723       long *opd_adjust;
8724       bfd_vma sym_value;
8725       bfd_vma dest;
8726
8727       r_type = ELF64_R_TYPE (rel->r_info);
8728       if (r_type != R_PPC64_REL24
8729           && r_type != R_PPC64_REL14
8730           && r_type != R_PPC64_REL14_BRTAKEN
8731           && r_type != R_PPC64_REL14_BRNTAKEN)
8732         continue;
8733
8734       r_symndx = ELF64_R_SYM (rel->r_info);
8735       if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
8736                       isec->owner))
8737         {
8738           ret = -1;
8739           break;
8740         }
8741
8742       /* Calls to dynamic lib functions go through a plt call stub
8743          that uses r2.  Branches to undefined symbols might be a call
8744          using old-style dot symbols that can be satisfied by a plt
8745          call into a new-style dynamic library.  */
8746       if (sym_sec == NULL)
8747         {
8748           struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8749           if (eh != NULL
8750               && eh->oh != NULL
8751               && eh->oh->elf.plt.plist != NULL)
8752             {
8753               ret = 1;
8754               break;
8755             }
8756
8757           /* Ignore other undefined symbols.  */
8758           continue;
8759         }
8760
8761       /* Assume branches to other sections not included in the link need
8762          stubs too, to cover -R and absolute syms.  */
8763       if (sym_sec->output_section == NULL)
8764         {
8765           ret = 1;
8766           break;
8767         }
8768
8769       if (h == NULL)
8770         sym_value = sym->st_value;
8771       else
8772         {
8773           if (h->root.type != bfd_link_hash_defined
8774               && h->root.type != bfd_link_hash_defweak)
8775             abort ();
8776           sym_value = h->root.u.def.value;
8777         }
8778       sym_value += rel->r_addend;
8779
8780       /* If this branch reloc uses an opd sym, find the code section.  */
8781       opd_adjust = get_opd_info (sym_sec);
8782       if (opd_adjust != NULL)
8783         {
8784           if (h == NULL)
8785             {
8786               long adjust;
8787
8788               adjust = opd_adjust[sym->st_value / 8];
8789               if (adjust == -1)
8790                 /* Assume deleted functions won't ever be called.  */
8791                 continue;
8792               sym_value += adjust;
8793             }
8794
8795           dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
8796           if (dest == (bfd_vma) -1)
8797             continue;
8798         }
8799       else
8800         dest = (sym_value
8801                 + sym_sec->output_offset
8802                 + sym_sec->output_section->vma);
8803
8804       /* Ignore branch to self.  */
8805       if (sym_sec == isec)
8806         continue;
8807
8808       /* If the called function uses the toc, we need a stub.  */
8809       if (sym_sec->has_toc_reloc
8810           || sym_sec->makes_toc_func_call)
8811         {
8812           ret = 1;
8813           break;
8814         }
8815
8816       /* Assume any branch that needs a long branch stub might in fact
8817          need a plt_branch stub.  A plt_branch stub uses r2.  */
8818       else if (dest - (isec->output_offset
8819                        + isec->output_section->vma
8820                        + rel->r_offset) + (1 << 25) >= (2 << 25))
8821         {
8822           ret = 1;
8823           break;
8824         }
8825
8826       /* If calling back to a section in the process of being tested, we
8827          can't say for sure that no toc adjusting stubs are needed, so
8828          don't return zero.  */
8829       else if (sym_sec->call_check_in_progress)
8830         ret = 2;
8831
8832       /* Branches to another section that itself doesn't have any TOC
8833          references are OK.  Recursively call ourselves to check.  */
8834       else if (sym_sec->id <= htab->top_id
8835                && htab->stub_group[sym_sec->id].toc_off == 0)
8836         {
8837           int recur;
8838
8839           /* Mark current section as indeterminate, so that other
8840              sections that call back to current won't be marked as
8841              known.  */
8842           isec->call_check_in_progress = 1;
8843           recur = toc_adjusting_stub_needed (info, sym_sec);
8844           isec->call_check_in_progress = 0;
8845
8846           if (recur < 0)
8847             {
8848               /* An error.  Exit.  */
8849               ret = -1;
8850               break;
8851             }
8852           else if (recur <= 1)
8853             {
8854               /* Known result.  Mark as checked and set section flag.  */
8855               htab->stub_group[sym_sec->id].toc_off = 1;
8856               if (recur != 0)
8857                 {
8858                   sym_sec->makes_toc_func_call = 1;
8859                   ret = 1;
8860                   break;
8861                 }
8862             }
8863           else
8864             {
8865               /* Unknown result.  Continue checking.  */
8866               ret = 2;
8867             }
8868         }
8869     }
8870
8871   if (local_syms != NULL
8872       && (elf_tdata (isec->owner)->symtab_hdr.contents
8873           != (unsigned char *) local_syms))
8874     free (local_syms);
8875   if (elf_section_data (isec)->relocs != relstart)
8876     free (relstart);
8877
8878   return ret;
8879 }
8880
8881 /* The linker repeatedly calls this function for each input section,
8882    in the order that input sections are linked into output sections.
8883    Build lists of input sections to determine groupings between which
8884    we may insert linker stubs.  */
8885
8886 bfd_boolean
8887 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
8888 {
8889   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8890
8891   if ((isec->output_section->flags & SEC_CODE) != 0
8892       && isec->output_section->index <= htab->top_index)
8893     {
8894       asection **list = htab->input_list + isec->output_section->index;
8895       /* Steal the link_sec pointer for our list.  */
8896 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
8897       /* This happens to make the list in reverse order,
8898          which is what we want.  */
8899       PREV_SEC (isec) = *list;
8900       *list = isec;
8901     }
8902
8903   if (htab->multi_toc_needed)
8904     {
8905       /* If a code section has a function that uses the TOC then we need
8906          to use the right TOC (obviously).  Also, make sure that .opd gets
8907          the correct TOC value for R_PPC64_TOC relocs that don't have or
8908          can't find their function symbol (shouldn't ever happen now).  */
8909       if (isec->has_toc_reloc || (isec->flags & SEC_CODE) == 0)
8910         {
8911           if (elf_gp (isec->owner) != 0)
8912             htab->toc_curr = elf_gp (isec->owner);
8913         }
8914       else if (htab->stub_group[isec->id].toc_off == 0)
8915         {
8916           int ret = toc_adjusting_stub_needed (info, isec);
8917           if (ret < 0)
8918             return FALSE;
8919           else
8920             isec->makes_toc_func_call = ret & 1;
8921         }
8922     }
8923
8924   /* Functions that don't use the TOC can belong in any TOC group.
8925      Use the last TOC base.  This happens to make _init and _fini
8926      pasting work.  */
8927   htab->stub_group[isec->id].toc_off = htab->toc_curr;
8928   return TRUE;
8929 }
8930
8931 /* See whether we can group stub sections together.  Grouping stub
8932    sections may result in fewer stubs.  More importantly, we need to
8933    put all .init* and .fini* stubs at the beginning of the .init or
8934    .fini output sections respectively, because glibc splits the
8935    _init and _fini functions into multiple parts.  Putting a stub in
8936    the middle of a function is not a good idea.  */
8937
8938 static void
8939 group_sections (struct ppc_link_hash_table *htab,
8940                 bfd_size_type stub_group_size,
8941                 bfd_boolean stubs_always_before_branch)
8942 {
8943   asection **list = htab->input_list + htab->top_index;
8944   do
8945     {
8946       asection *tail = *list;
8947       while (tail != NULL)
8948         {
8949           asection *curr;
8950           asection *prev;
8951           bfd_size_type total;
8952           bfd_boolean big_sec;
8953           bfd_vma curr_toc;
8954
8955           curr = tail;
8956           total = tail->size;
8957           big_sec = total > stub_group_size;
8958           if (big_sec)
8959             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
8960                                      tail->owner, tail);
8961           curr_toc = htab->stub_group[tail->id].toc_off;
8962
8963           while ((prev = PREV_SEC (curr)) != NULL
8964                  && ((total += curr->output_offset - prev->output_offset)
8965                      < stub_group_size)
8966                  && htab->stub_group[prev->id].toc_off == curr_toc)
8967             curr = prev;
8968
8969           /* OK, the size from the start of CURR to the end is less
8970              than stub_group_size and thus can be handled by one stub
8971              section.  (or the tail section is itself larger than
8972              stub_group_size, in which case we may be toast.)  We
8973              should really be keeping track of the total size of stubs
8974              added here, as stubs contribute to the final output
8975              section size.  That's a little tricky, and this way will
8976              only break if stubs added make the total size more than
8977              2^25, ie. for the default stub_group_size, if stubs total
8978              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
8979           do
8980             {
8981               prev = PREV_SEC (tail);
8982               /* Set up this stub group.  */
8983               htab->stub_group[tail->id].link_sec = curr;
8984             }
8985           while (tail != curr && (tail = prev) != NULL);
8986
8987           /* But wait, there's more!  Input sections up to stub_group_size
8988              bytes before the stub section can be handled by it too.
8989              Don't do this if we have a really large section after the
8990              stubs, as adding more stubs increases the chance that
8991              branches may not reach into the stub section.  */
8992           if (!stubs_always_before_branch && !big_sec)
8993             {
8994               total = 0;
8995               while (prev != NULL
8996                      && ((total += tail->output_offset - prev->output_offset)
8997                          < stub_group_size)
8998                      && htab->stub_group[prev->id].toc_off == curr_toc)
8999                 {
9000                   tail = prev;
9001                   prev = PREV_SEC (tail);
9002                   htab->stub_group[tail->id].link_sec = curr;
9003                 }
9004             }
9005           tail = prev;
9006         }
9007     }
9008   while (list-- != htab->input_list);
9009   free (htab->input_list);
9010 #undef PREV_SEC
9011 }
9012
9013 /* Determine and set the size of the stub section for a final link.
9014
9015    The basic idea here is to examine all the relocations looking for
9016    PC-relative calls to a target that is unreachable with a "bl"
9017    instruction.  */
9018
9019 bfd_boolean
9020 ppc64_elf_size_stubs (bfd *output_bfd,
9021                       struct bfd_link_info *info,
9022                       bfd_signed_vma group_size,
9023                       asection *(*add_stub_section) (const char *, asection *),
9024                       void (*layout_sections_again) (void))
9025 {
9026   bfd_size_type stub_group_size;
9027   bfd_boolean stubs_always_before_branch;
9028   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9029
9030   /* Stash our params away.  */
9031   htab->add_stub_section = add_stub_section;
9032   htab->layout_sections_again = layout_sections_again;
9033   stubs_always_before_branch = group_size < 0;
9034   if (group_size < 0)
9035     stub_group_size = -group_size;
9036   else
9037     stub_group_size = group_size;
9038   if (stub_group_size == 1)
9039     {
9040       /* Default values.  */
9041       if (stubs_always_before_branch)
9042         {
9043           stub_group_size = 0x1e00000;
9044           if (htab->has_14bit_branch)
9045             stub_group_size = 0x7800;
9046         }
9047       else
9048         {
9049           stub_group_size = 0x1c00000;
9050           if (htab->has_14bit_branch)
9051             stub_group_size = 0x7000;
9052         }
9053     }
9054
9055   group_sections (htab, stub_group_size, stubs_always_before_branch);
9056
9057   while (1)
9058     {
9059       bfd *input_bfd;
9060       unsigned int bfd_indx;
9061       asection *stub_sec;
9062
9063       htab->stub_iteration += 1;
9064
9065       for (input_bfd = info->input_bfds, bfd_indx = 0;
9066            input_bfd != NULL;
9067            input_bfd = input_bfd->link_next, bfd_indx++)
9068         {
9069           Elf_Internal_Shdr *symtab_hdr;
9070           asection *section;
9071           Elf_Internal_Sym *local_syms = NULL;
9072
9073           if (!is_ppc64_elf_target (input_bfd->xvec))
9074             continue;
9075
9076           /* We'll need the symbol table in a second.  */
9077           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9078           if (symtab_hdr->sh_info == 0)
9079             continue;
9080
9081           /* Walk over each section attached to the input bfd.  */
9082           for (section = input_bfd->sections;
9083                section != NULL;
9084                section = section->next)
9085             {
9086               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
9087
9088               /* If there aren't any relocs, then there's nothing more
9089                  to do.  */
9090               if ((section->flags & SEC_RELOC) == 0
9091                   || (section->flags & SEC_ALLOC) == 0
9092                   || (section->flags & SEC_LOAD) == 0
9093                   || (section->flags & SEC_CODE) == 0
9094                   || section->reloc_count == 0)
9095                 continue;
9096
9097               /* If this section is a link-once section that will be
9098                  discarded, then don't create any stubs.  */
9099               if (section->output_section == NULL
9100                   || section->output_section->owner != output_bfd)
9101                 continue;
9102
9103               /* Get the relocs.  */
9104               internal_relocs
9105                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
9106                                              info->keep_memory);
9107               if (internal_relocs == NULL)
9108                 goto error_ret_free_local;
9109
9110               /* Now examine each relocation.  */
9111               irela = internal_relocs;
9112               irelaend = irela + section->reloc_count;
9113               for (; irela < irelaend; irela++)
9114                 {
9115                   enum elf_ppc64_reloc_type r_type;
9116                   unsigned int r_indx;
9117                   enum ppc_stub_type stub_type;
9118                   struct ppc_stub_hash_entry *stub_entry;
9119                   asection *sym_sec, *code_sec;
9120                   bfd_vma sym_value;
9121                   bfd_vma destination;
9122                   bfd_boolean ok_dest;
9123                   struct ppc_link_hash_entry *hash;
9124                   struct ppc_link_hash_entry *fdh;
9125                   struct elf_link_hash_entry *h;
9126                   Elf_Internal_Sym *sym;
9127                   char *stub_name;
9128                   const asection *id_sec;
9129                   long *opd_adjust;
9130
9131                   r_type = ELF64_R_TYPE (irela->r_info);
9132                   r_indx = ELF64_R_SYM (irela->r_info);
9133
9134                   if (r_type >= R_PPC64_max)
9135                     {
9136                       bfd_set_error (bfd_error_bad_value);
9137                       goto error_ret_free_internal;
9138                     }
9139
9140                   /* Only look for stubs on branch instructions.  */
9141                   if (r_type != R_PPC64_REL24
9142                       && r_type != R_PPC64_REL14
9143                       && r_type != R_PPC64_REL14_BRTAKEN
9144                       && r_type != R_PPC64_REL14_BRNTAKEN)
9145                     continue;
9146
9147                   /* Now determine the call target, its name, value,
9148                      section.  */
9149                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9150                                   r_indx, input_bfd))
9151                     goto error_ret_free_internal;
9152                   hash = (struct ppc_link_hash_entry *) h;
9153
9154                   ok_dest = FALSE;
9155                   fdh = NULL;
9156                   sym_value = 0;
9157                   if (hash == NULL)
9158                     {
9159                       sym_value = sym->st_value;
9160                       ok_dest = TRUE;
9161                     }
9162                   else if (hash->elf.root.type == bfd_link_hash_defined
9163                            || hash->elf.root.type == bfd_link_hash_defweak)
9164                     {
9165                       sym_value = hash->elf.root.u.def.value;
9166                       if (sym_sec->output_section != NULL)
9167                         ok_dest = TRUE;
9168                     }
9169                   else if (hash->elf.root.type == bfd_link_hash_undefweak
9170                            || hash->elf.root.type == bfd_link_hash_undefined)
9171                     {
9172                       /* Recognise an old ABI func code entry sym, and
9173                          use the func descriptor sym instead if it is
9174                          defined.  */
9175                       if (hash->elf.root.root.string[0] == '.'
9176                           && (fdh = get_fdh (hash, htab)) != NULL)
9177                         {
9178                           if (fdh->elf.root.type == bfd_link_hash_defined
9179                               || fdh->elf.root.type == bfd_link_hash_defweak)
9180                             {
9181                               sym_sec = fdh->elf.root.u.def.section;
9182                               sym_value = fdh->elf.root.u.def.value;
9183                               if (sym_sec->output_section != NULL)
9184                                 ok_dest = TRUE;
9185                             }
9186                           else
9187                             fdh = NULL;
9188                         }
9189                     }
9190                   else
9191                     {
9192                       bfd_set_error (bfd_error_bad_value);
9193                       goto error_ret_free_internal;
9194                     }
9195
9196                   destination = 0;
9197                   if (ok_dest)
9198                     {
9199                       sym_value += irela->r_addend;
9200                       destination = (sym_value
9201                                      + sym_sec->output_offset
9202                                      + sym_sec->output_section->vma);
9203                     }
9204
9205                   code_sec = sym_sec;
9206                   opd_adjust = get_opd_info (sym_sec);
9207                   if (opd_adjust != NULL)
9208                     {
9209                       bfd_vma dest;
9210
9211                       if (hash == NULL)
9212                         {
9213                           long adjust = opd_adjust[sym_value / 8];
9214                           if (adjust == -1)
9215                             continue;
9216                           sym_value += adjust;
9217                         }
9218                       dest = opd_entry_value (sym_sec, sym_value,
9219                                               &code_sec, &sym_value);
9220                       if (dest != (bfd_vma) -1)
9221                         {
9222                           destination = dest;
9223                           if (fdh != NULL)
9224                             {
9225                               /* Fixup old ABI sym to point at code
9226                                  entry.  */
9227                               hash->elf.root.type = bfd_link_hash_defweak;
9228                               hash->elf.root.u.def.section = code_sec;
9229                               hash->elf.root.u.def.value = sym_value;
9230                             }
9231                         }
9232                     }
9233
9234                   /* Determine what (if any) linker stub is needed.  */
9235                   stub_type = ppc_type_of_stub (section, irela, &hash,
9236                                                 destination);
9237
9238                   if (stub_type != ppc_stub_plt_call)
9239                     {
9240                       /* Check whether we need a TOC adjusting stub.
9241                          Since the linker pastes together pieces from
9242                          different object files when creating the
9243                          _init and _fini functions, it may be that a
9244                          call to what looks like a local sym is in
9245                          fact a call needing a TOC adjustment.  */
9246                       if (code_sec != NULL
9247                           && code_sec->output_section != NULL
9248                           && (htab->stub_group[code_sec->id].toc_off
9249                               != htab->stub_group[section->id].toc_off)
9250                           && (code_sec->has_toc_reloc
9251                               || code_sec->makes_toc_func_call))
9252                         stub_type = ppc_stub_long_branch_r2off;
9253                     }
9254
9255                   if (stub_type == ppc_stub_none)
9256                     continue;
9257
9258                   /* __tls_get_addr calls might be eliminated.  */
9259                   if (stub_type != ppc_stub_plt_call
9260                       && hash != NULL
9261                       && (hash == htab->tls_get_addr
9262                           || hash == htab->tls_get_addr_fd)
9263                       && section->has_tls_reloc
9264                       && irela != internal_relocs)
9265                     {
9266                       /* Get tls info.  */
9267                       char *tls_mask;
9268
9269                       if (!get_tls_mask (&tls_mask, NULL, &local_syms,
9270                                          irela - 1, input_bfd))
9271                         goto error_ret_free_internal;
9272                       if (*tls_mask != 0)
9273                         continue;
9274                     }
9275
9276                   /* Support for grouping stub sections.  */
9277                   id_sec = htab->stub_group[section->id].link_sec;
9278
9279                   /* Get the name of this stub.  */
9280                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
9281                   if (!stub_name)
9282                     goto error_ret_free_internal;
9283
9284                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
9285                                                      stub_name, FALSE, FALSE);
9286                   if (stub_entry != NULL)
9287                     {
9288                       /* The proper stub has already been created.  */
9289                       free (stub_name);
9290                       continue;
9291                     }
9292
9293                   stub_entry = ppc_add_stub (stub_name, section, htab);
9294                   if (stub_entry == NULL)
9295                     {
9296                       free (stub_name);
9297                     error_ret_free_internal:
9298                       if (elf_section_data (section)->relocs == NULL)
9299                         free (internal_relocs);
9300                     error_ret_free_local:
9301                       if (local_syms != NULL
9302                           && (symtab_hdr->contents
9303                               != (unsigned char *) local_syms))
9304                         free (local_syms);
9305                       return FALSE;
9306                     }
9307
9308                   stub_entry->stub_type = stub_type;
9309                   stub_entry->target_value = sym_value;
9310                   stub_entry->target_section = code_sec;
9311                   stub_entry->h = hash;
9312                   stub_entry->addend = irela->r_addend;
9313
9314                   if (stub_entry->h != NULL)
9315                     htab->stub_globals += 1;
9316                 }
9317
9318               /* We're done with the internal relocs, free them.  */
9319               if (elf_section_data (section)->relocs != internal_relocs)
9320                 free (internal_relocs);
9321             }
9322
9323           if (local_syms != NULL
9324               && symtab_hdr->contents != (unsigned char *) local_syms)
9325             {
9326               if (!info->keep_memory)
9327                 free (local_syms);
9328               else
9329                 symtab_hdr->contents = (unsigned char *) local_syms;
9330             }
9331         }
9332
9333       /* We may have added some stubs.  Find out the new size of the
9334          stub sections.  */
9335       for (stub_sec = htab->stub_bfd->sections;
9336            stub_sec != NULL;
9337            stub_sec = stub_sec->next)
9338         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9339           {
9340             stub_sec->rawsize = stub_sec->size;
9341             stub_sec->size = 0;
9342             stub_sec->reloc_count = 0;
9343           }
9344
9345       htab->brlt->size = 0;
9346       if (htab->relbrlt != NULL)
9347         htab->relbrlt->size = 0;
9348
9349       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
9350
9351       for (stub_sec = htab->stub_bfd->sections;
9352            stub_sec != NULL;
9353            stub_sec = stub_sec->next)
9354         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9355             && stub_sec->rawsize != stub_sec->size)
9356           break;
9357
9358       /* Exit from this loop when no stubs have been added, and no stubs
9359          have changed size.  */
9360       if (stub_sec == NULL)
9361         break;
9362
9363       /* Ask the linker to do its stuff.  */
9364       (*htab->layout_sections_again) ();
9365     }
9366
9367   /* It would be nice to strip htab->brlt from the output if the
9368      section is empty, but it's too late.  If we strip sections here,
9369      the dynamic symbol table is corrupted since the section symbol
9370      for the stripped section isn't written.  */
9371
9372   return TRUE;
9373 }
9374
9375 /* Called after we have determined section placement.  If sections
9376    move, we'll be called again.  Provide a value for TOCstart.  */
9377
9378 bfd_vma
9379 ppc64_elf_toc (bfd *obfd)
9380 {
9381   asection *s;
9382   bfd_vma TOCstart;
9383
9384   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
9385      order.  The TOC starts where the first of these sections starts.  */
9386   s = bfd_get_section_by_name (obfd, ".got");
9387   if (s == NULL)
9388     s = bfd_get_section_by_name (obfd, ".toc");
9389   if (s == NULL)
9390     s = bfd_get_section_by_name (obfd, ".tocbss");
9391   if (s == NULL)
9392     s = bfd_get_section_by_name (obfd, ".plt");
9393   if (s == NULL)
9394     {
9395       /* This may happen for
9396          o  references to TOC base (SYM@toc / TOC[tc0]) without a
9397          .toc directive
9398          o  bad linker script
9399          o --gc-sections and empty TOC sections
9400
9401          FIXME: Warn user?  */
9402
9403       /* Look for a likely section.  We probably won't even be
9404          using TOCstart.  */
9405       for (s = obfd->sections; s != NULL; s = s->next)
9406         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
9407             == (SEC_ALLOC | SEC_SMALL_DATA))
9408           break;
9409       if (s == NULL)
9410         for (s = obfd->sections; s != NULL; s = s->next)
9411           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
9412               == (SEC_ALLOC | SEC_SMALL_DATA))
9413             break;
9414       if (s == NULL)
9415         for (s = obfd->sections; s != NULL; s = s->next)
9416           if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
9417             break;
9418       if (s == NULL)
9419         for (s = obfd->sections; s != NULL; s = s->next)
9420           if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
9421             break;
9422     }
9423
9424   TOCstart = 0;
9425   if (s != NULL)
9426     TOCstart = s->output_section->vma + s->output_offset;
9427
9428   return TOCstart;
9429 }
9430
9431 /* Build all the stubs associated with the current output file.
9432    The stubs are kept in a hash table attached to the main linker
9433    hash table.  This function is called via gldelf64ppc_finish.  */
9434
9435 bfd_boolean
9436 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
9437                        struct bfd_link_info *info,
9438                        char **stats)
9439 {
9440   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9441   asection *stub_sec;
9442   bfd_byte *p;
9443   int stub_sec_count = 0;
9444
9445   htab->emit_stub_syms = emit_stub_syms;
9446
9447   /* Allocate memory to hold the linker stubs.  */
9448   for (stub_sec = htab->stub_bfd->sections;
9449        stub_sec != NULL;
9450        stub_sec = stub_sec->next)
9451     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9452         && stub_sec->size != 0)
9453       {
9454         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
9455         if (stub_sec->contents == NULL)
9456           return FALSE;
9457         /* We want to check that built size is the same as calculated
9458            size.  rawsize is a convenient location to use.  */
9459         stub_sec->rawsize = stub_sec->size;
9460         stub_sec->size = 0;
9461       }
9462
9463   if (htab->glink != NULL && htab->glink->size != 0)
9464     {
9465       unsigned int indx;
9466       bfd_vma plt0;
9467
9468       /* Build the .glink plt call stub.  */
9469       if (htab->emit_stub_syms)
9470         {
9471           struct elf_link_hash_entry *h;
9472           h = elf_link_hash_lookup (&htab->elf, "__glink", TRUE, FALSE, FALSE);
9473           if (h == NULL)
9474             return FALSE;
9475           if (h->root.type == bfd_link_hash_new)
9476             {
9477               h->root.type = bfd_link_hash_defined;
9478               h->root.u.def.section = htab->glink;
9479               h->root.u.def.value = 8;
9480               h->ref_regular = 1;
9481               h->def_regular = 1;
9482               h->ref_regular_nonweak = 1;
9483               h->forced_local = 1;
9484               h->non_elf = 0;
9485             }
9486         }
9487       p = htab->glink->contents;
9488       plt0 = (htab->plt->output_section->vma
9489               + htab->plt->output_offset
9490               - (htab->glink->output_section->vma
9491                  + htab->glink->output_offset
9492                  + 16));
9493       bfd_put_64 (htab->glink->owner, plt0, p);
9494       p += 8;
9495       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
9496       p += 4;
9497       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
9498       p += 4;
9499       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
9500       p += 4;
9501       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
9502       p += 4;
9503       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
9504       p += 4;
9505       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
9506       p += 4;
9507       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
9508       p += 4;
9509       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
9510       p += 4;
9511       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
9512       p += 4;
9513       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
9514       p += 4;
9515       bfd_put_32 (htab->glink->owner, BCTR, p);
9516       p += 4;
9517       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
9518         {
9519           bfd_put_32 (htab->glink->owner, NOP, p);
9520           p += 4;
9521         }
9522
9523       /* Build the .glink lazy link call stubs.  */
9524       indx = 0;
9525       while (p < htab->glink->contents + htab->glink->size)
9526         {
9527           if (indx < 0x8000)
9528             {
9529               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
9530               p += 4;
9531             }
9532           else
9533             {
9534               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
9535               p += 4;
9536               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
9537               p += 4;
9538             }
9539           bfd_put_32 (htab->glink->owner,
9540                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
9541           indx++;
9542           p += 4;
9543         }
9544       htab->glink->rawsize = p - htab->glink->contents;
9545     }
9546
9547   if (htab->brlt->size != 0)
9548     {
9549       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
9550                                          htab->brlt->size);
9551       if (htab->brlt->contents == NULL)
9552         return FALSE;
9553     }
9554   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
9555     {
9556       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
9557                                             htab->relbrlt->size);
9558       if (htab->relbrlt->contents == NULL)
9559         return FALSE;
9560     }
9561
9562   /* Build the stubs as directed by the stub hash table.  */
9563   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
9564
9565   if (htab->relbrlt != NULL)
9566     htab->relbrlt->reloc_count = 0;
9567
9568   for (stub_sec = htab->stub_bfd->sections;
9569        stub_sec != NULL;
9570        stub_sec = stub_sec->next)
9571     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9572       {
9573         stub_sec_count += 1;
9574         if (stub_sec->rawsize != stub_sec->size)
9575           break;
9576       }
9577
9578   if (stub_sec != NULL
9579       || htab->glink->rawsize != htab->glink->size)
9580     {
9581       htab->stub_error = TRUE;
9582       (*_bfd_error_handler) (_("stubs don't match calculated size"));
9583     }
9584
9585   if (htab->stub_error)
9586     return FALSE;
9587
9588   if (stats != NULL)
9589     {
9590       *stats = bfd_malloc (500);
9591       if (*stats == NULL)
9592         return FALSE;
9593
9594       sprintf (*stats, _("linker stubs in %u group%s\n"
9595                          "  branch       %lu\n"
9596                          "  toc adjust   %lu\n"
9597                          "  long branch  %lu\n"
9598                          "  long toc adj %lu\n"
9599                          "  plt call     %lu"),
9600                stub_sec_count,
9601                stub_sec_count == 1 ? "" : "s",
9602                htab->stub_count[ppc_stub_long_branch - 1],
9603                htab->stub_count[ppc_stub_long_branch_r2off - 1],
9604                htab->stub_count[ppc_stub_plt_branch - 1],
9605                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
9606                htab->stub_count[ppc_stub_plt_call - 1]);
9607     }
9608   return TRUE;
9609 }
9610
9611 /* This function undoes the changes made by add_symbol_adjust.  */
9612
9613 static bfd_boolean
9614 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9615 {
9616   struct ppc_link_hash_entry *eh;
9617
9618   if (h->root.type == bfd_link_hash_indirect)
9619     return TRUE;
9620
9621   if (h->root.type == bfd_link_hash_warning)
9622     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9623
9624   eh = (struct ppc_link_hash_entry *) h;
9625   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
9626     return TRUE;
9627
9628   eh->elf.root.type = bfd_link_hash_undefined;
9629   return TRUE;
9630 }
9631
9632 void
9633 ppc64_elf_restore_symbols (struct bfd_link_info *info)
9634 {
9635   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9636   elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
9637 }
9638
9639 /* What to do when ld finds relocations against symbols defined in
9640    discarded sections.  */
9641
9642 static unsigned int
9643 ppc64_elf_action_discarded (asection *sec)
9644 {
9645   if (strcmp (".opd", sec->name) == 0)
9646     return 0;
9647
9648   if (strcmp (".toc", sec->name) == 0)
9649     return 0;
9650
9651   if (strcmp (".toc1", sec->name) == 0)
9652     return 0;
9653
9654   return _bfd_elf_default_action_discarded (sec);
9655 }
9656
9657 /* The RELOCATE_SECTION function is called by the ELF backend linker
9658    to handle the relocations for a section.
9659
9660    The relocs are always passed as Rela structures; if the section
9661    actually uses Rel structures, the r_addend field will always be
9662    zero.
9663
9664    This function is responsible for adjust the section contents as
9665    necessary, and (if using Rela relocs and generating a
9666    relocatable output file) adjusting the reloc addend as
9667    necessary.
9668
9669    This function does not have to worry about setting the reloc
9670    address or the reloc symbol index.
9671
9672    LOCAL_SYMS is a pointer to the swapped in local symbols.
9673
9674    LOCAL_SECTIONS is an array giving the section in the input file
9675    corresponding to the st_shndx field of each local symbol.
9676
9677    The global hash table entry for the global symbols can be found
9678    via elf_sym_hashes (input_bfd).
9679
9680    When generating relocatable output, this function must handle
9681    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
9682    going to be the section symbol corresponding to the output
9683    section, which means that the addend must be adjusted
9684    accordingly.  */
9685
9686 static bfd_boolean
9687 ppc64_elf_relocate_section (bfd *output_bfd,
9688                             struct bfd_link_info *info,
9689                             bfd *input_bfd,
9690                             asection *input_section,
9691                             bfd_byte *contents,
9692                             Elf_Internal_Rela *relocs,
9693                             Elf_Internal_Sym *local_syms,
9694                             asection **local_sections)
9695 {
9696   struct ppc_link_hash_table *htab;
9697   Elf_Internal_Shdr *symtab_hdr;
9698   struct elf_link_hash_entry **sym_hashes;
9699   Elf_Internal_Rela *rel;
9700   Elf_Internal_Rela *relend;
9701   Elf_Internal_Rela outrel;
9702   bfd_byte *loc;
9703   struct got_entry **local_got_ents;
9704   bfd_vma TOCstart;
9705   bfd_boolean ret = TRUE;
9706   bfd_boolean is_opd;
9707   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
9708   bfd_boolean is_power4 = FALSE;
9709
9710   /* Initialize howto table if needed.  */
9711   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9712     ppc_howto_init ();
9713
9714   htab = ppc_hash_table (info);
9715
9716   /* Don't relocate stub sections.  */
9717   if (input_section->owner == htab->stub_bfd)
9718     return TRUE;
9719
9720   local_got_ents = elf_local_got_ents (input_bfd);
9721   TOCstart = elf_gp (output_bfd);
9722   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9723   sym_hashes = elf_sym_hashes (input_bfd);
9724   is_opd = ppc64_elf_section_data (input_section)->opd.adjust != NULL;
9725
9726   rel = relocs;
9727   relend = relocs + input_section->reloc_count;
9728   for (; rel < relend; rel++)
9729     {
9730       enum elf_ppc64_reloc_type r_type;
9731       bfd_vma addend, orig_addend;
9732       bfd_reloc_status_type r;
9733       Elf_Internal_Sym *sym;
9734       asection *sec;
9735       struct elf_link_hash_entry *h_elf;
9736       struct ppc_link_hash_entry *h;
9737       struct ppc_link_hash_entry *fdh;
9738       const char *sym_name;
9739       unsigned long r_symndx, toc_symndx;
9740       char tls_mask, tls_gd, tls_type;
9741       char sym_type;
9742       bfd_vma relocation;
9743       bfd_boolean unresolved_reloc;
9744       bfd_boolean warned;
9745       unsigned long insn, mask;
9746       struct ppc_stub_hash_entry *stub_entry;
9747       bfd_vma max_br_offset;
9748       bfd_vma from;
9749
9750       r_type = ELF64_R_TYPE (rel->r_info);
9751       r_symndx = ELF64_R_SYM (rel->r_info);
9752
9753       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
9754          symbol of the previous ADDR64 reloc.  The symbol gives us the
9755          proper TOC base to use.  */
9756       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
9757           && rel != relocs
9758           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
9759           && is_opd)
9760         r_symndx = ELF64_R_SYM (rel[-1].r_info);
9761
9762       sym = NULL;
9763       sec = NULL;
9764       h_elf = NULL;
9765       sym_name = NULL;
9766       unresolved_reloc = FALSE;
9767       warned = FALSE;
9768       orig_addend = rel->r_addend;
9769
9770       if (r_symndx < symtab_hdr->sh_info)
9771         {
9772           /* It's a local symbol.  */
9773           long *opd_adjust;
9774
9775           sym = local_syms + r_symndx;
9776           sec = local_sections[r_symndx];
9777           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
9778           sym_type = ELF64_ST_TYPE (sym->st_info);
9779           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9780           opd_adjust = get_opd_info (sec);
9781           if (opd_adjust != NULL)
9782             {
9783               long adjust = opd_adjust[(sym->st_value + rel->r_addend) / 8];
9784               if (adjust == -1)
9785                 relocation = 0;
9786               else
9787                 {
9788                   /* If this is a relocation against the opd section sym
9789                      and we have edited .opd, adjust the reloc addend so
9790                      that ld -r and ld --emit-relocs output is correct.
9791                      If it is a reloc against some other .opd symbol,
9792                      then the symbol value will be adjusted later.  */
9793                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9794                     rel->r_addend += adjust;
9795                   else
9796                     relocation += adjust;
9797                 }
9798             }
9799           if (info->relocatable)
9800             continue;
9801         }
9802       else
9803         {
9804           if (info->relocatable)
9805             continue;
9806           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
9807                                    r_symndx, symtab_hdr, sym_hashes,
9808                                    h_elf, sec, relocation,
9809                                    unresolved_reloc, warned);
9810           sym_name = h_elf->root.root.string;
9811           sym_type = h_elf->type;
9812         }
9813       h = (struct ppc_link_hash_entry *) h_elf;
9814
9815       /* TLS optimizations.  Replace instruction sequences and relocs
9816          based on information we collected in tls_optimize.  We edit
9817          RELOCS so that --emit-relocs will output something sensible
9818          for the final instruction stream.  */
9819       tls_mask = 0;
9820       tls_gd = 0;
9821       toc_symndx = 0;
9822       if (IS_PPC64_TLS_RELOC (r_type))
9823         {
9824           if (h != NULL)
9825             tls_mask = h->tls_mask;
9826           else if (local_got_ents != NULL)
9827             {
9828               char *lgot_masks;
9829               lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
9830               tls_mask = lgot_masks[r_symndx];
9831             }
9832           if (tls_mask == 0 && r_type == R_PPC64_TLS)
9833             {
9834               /* Check for toc tls entries.  */
9835               char *toc_tls;
9836
9837               if (!get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9838                                  rel, input_bfd))
9839                 return FALSE;
9840
9841               if (toc_tls)
9842                 tls_mask = *toc_tls;
9843             }
9844         }
9845
9846       /* Check that tls relocs are used with tls syms, and non-tls
9847          relocs are used with non-tls syms.  */
9848       if (r_symndx != 0
9849           && r_type != R_PPC64_NONE
9850           && (h == NULL
9851               || h->elf.root.type == bfd_link_hash_defined
9852               || h->elf.root.type == bfd_link_hash_defweak)
9853           && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
9854         {
9855           if (r_type == R_PPC64_TLS && tls_mask != 0)
9856             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
9857             ;
9858           else
9859             (*_bfd_error_handler)
9860               (sym_type == STT_TLS
9861                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
9862                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
9863                input_bfd,
9864                input_section,
9865                (long) rel->r_offset,
9866                ppc64_elf_howto_table[r_type]->name,
9867                sym_name);
9868         }
9869
9870       /* Ensure reloc mapping code below stays sane.  */
9871       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
9872           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
9873           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
9874           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
9875           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
9876           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
9877           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
9878           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
9879           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
9880           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
9881         abort ();
9882
9883       switch (r_type)
9884         {
9885         default:
9886           break;
9887
9888         case R_PPC64_TOC16:
9889         case R_PPC64_TOC16_LO:
9890         case R_PPC64_TOC16_DS:
9891         case R_PPC64_TOC16_LO_DS:
9892           {
9893             /* Check for toc tls entries.  */
9894             char *toc_tls;
9895             int retval;
9896
9897             retval = get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9898                                    rel, input_bfd);
9899             if (retval == 0)
9900               return FALSE;
9901
9902             if (toc_tls)
9903               {
9904                 tls_mask = *toc_tls;
9905                 if (r_type == R_PPC64_TOC16_DS
9906                     || r_type == R_PPC64_TOC16_LO_DS)
9907                   {
9908                     if (tls_mask != 0
9909                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
9910                       goto toctprel;
9911                   }
9912                 else
9913                   {
9914                     /* If we found a GD reloc pair, then we might be
9915                        doing a GD->IE transition.  */
9916                     if (retval == 2)
9917                       {
9918                         tls_gd = TLS_TPRELGD;
9919                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9920                           goto tls_get_addr_check;
9921                       }
9922                     else if (retval == 3)
9923                       {
9924                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9925                           goto tls_get_addr_check;
9926                       }
9927                   }
9928               }
9929           }
9930           break;
9931
9932         case R_PPC64_GOT_TPREL16_DS:
9933         case R_PPC64_GOT_TPREL16_LO_DS:
9934           if (tls_mask != 0
9935               && (tls_mask & TLS_TPREL) == 0)
9936             {
9937             toctprel:
9938               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
9939               insn &= 31 << 21;
9940               insn |= 0x3c0d0000;       /* addis 0,13,0 */
9941               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
9942               r_type = R_PPC64_TPREL16_HA;
9943               if (toc_symndx != 0)
9944                 {
9945                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9946                   /* We changed the symbol.  Start over in order to
9947                      get h, sym, sec etc. right.  */
9948                   rel--;
9949                   continue;
9950                 }
9951               else
9952                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9953             }
9954           break;
9955
9956         case R_PPC64_TLS:
9957           if (tls_mask != 0
9958               && (tls_mask & TLS_TPREL) == 0)
9959             {
9960               bfd_vma rtra;
9961               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
9962               if ((insn & ((0x3f << 26) | (31 << 11)))
9963                   == ((31 << 26) | (13 << 11)))
9964                 rtra = insn & ((1 << 26) - (1 << 16));
9965               else if ((insn & ((0x3f << 26) | (31 << 16)))
9966                        == ((31 << 26) | (13 << 16)))
9967                 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
9968               else
9969                 abort ();
9970               if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
9971                 /* add -> addi.  */
9972                 insn = 14 << 26;
9973               else if ((insn & (31 << 1)) == 23 << 1
9974                        && ((insn & (31 << 6)) < 14 << 6
9975                            || ((insn & (31 << 6)) >= 16 << 6
9976                                && (insn & (31 << 6)) < 24 << 6)))
9977                 /* load and store indexed -> dform.  */
9978                 insn = (32 | ((insn >> 6) & 31)) << 26;
9979               else if ((insn & (31 << 1)) == 21 << 1
9980                        && (insn & (0x1a << 6)) == 0)
9981                 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
9982                 insn = (((58 | ((insn >> 6) & 4)) << 26)
9983                         | ((insn >> 6) & 1));
9984               else if ((insn & (31 << 1)) == 21 << 1
9985                        && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
9986                 /* lwax -> lwa.  */
9987                 insn = (58 << 26) | 2;
9988               else
9989                 abort ();
9990               insn |= rtra;
9991               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9992               /* Was PPC64_TLS which sits on insn boundary, now
9993                  PPC64_TPREL16_LO which is at insn+2.  */
9994               rel->r_offset += 2;
9995               r_type = R_PPC64_TPREL16_LO;
9996               if (toc_symndx != 0)
9997                 {
9998                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9999                   /* We changed the symbol.  Start over in order to
10000                      get h, sym, sec etc. right.  */
10001                   rel--;
10002                   continue;
10003                 }
10004               else
10005                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10006             }
10007           break;
10008
10009         case R_PPC64_GOT_TLSGD16_HI:
10010         case R_PPC64_GOT_TLSGD16_HA:
10011           tls_gd = TLS_TPRELGD;
10012           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10013             goto tls_gdld_hi;
10014           break;
10015
10016         case R_PPC64_GOT_TLSLD16_HI:
10017         case R_PPC64_GOT_TLSLD16_HA:
10018           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10019             {
10020             tls_gdld_hi:
10021               if ((tls_mask & tls_gd) != 0)
10022                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10023                           + R_PPC64_GOT_TPREL16_DS);
10024               else
10025                 {
10026                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10027                   rel->r_offset -= 2;
10028                   r_type = R_PPC64_NONE;
10029                 }
10030               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10031             }
10032           break;
10033
10034         case R_PPC64_GOT_TLSGD16:
10035         case R_PPC64_GOT_TLSGD16_LO:
10036           tls_gd = TLS_TPRELGD;
10037           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10038             goto tls_get_addr_check;
10039           break;
10040
10041         case R_PPC64_GOT_TLSLD16:
10042         case R_PPC64_GOT_TLSLD16_LO:
10043           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10044             {
10045             tls_get_addr_check:
10046               if (rel + 1 < relend)
10047                 {
10048                   enum elf_ppc64_reloc_type r_type2;
10049                   unsigned long r_symndx2;
10050                   struct elf_link_hash_entry *h2;
10051                   bfd_vma insn1, insn2, insn3;
10052                   bfd_vma offset;
10053
10054                   /* The next instruction should be a call to
10055                      __tls_get_addr.  Peek at the reloc to be sure.  */
10056                   r_type2 = ELF64_R_TYPE (rel[1].r_info);
10057                   r_symndx2 = ELF64_R_SYM (rel[1].r_info);
10058                   if (r_symndx2 < symtab_hdr->sh_info
10059                       || (r_type2 != R_PPC64_REL14
10060                           && r_type2 != R_PPC64_REL14_BRTAKEN
10061                           && r_type2 != R_PPC64_REL14_BRNTAKEN
10062                           && r_type2 != R_PPC64_REL24))
10063                     break;
10064
10065                   h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
10066                   while (h2->root.type == bfd_link_hash_indirect
10067                          || h2->root.type == bfd_link_hash_warning)
10068                     h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
10069                   if (h2 == NULL || (h2 != &htab->tls_get_addr->elf
10070                                      && h2 != &htab->tls_get_addr_fd->elf))
10071                     break;
10072
10073                   /* OK, it checks out.  Replace the call.  */
10074                   offset = rel[1].r_offset;
10075                   insn1 = bfd_get_32 (output_bfd,
10076                                       contents + rel->r_offset - 2);
10077                   insn3 = bfd_get_32 (output_bfd,
10078                                       contents + offset + 4);
10079                   if ((tls_mask & tls_gd) != 0)
10080                     {
10081                       /* IE */
10082                       insn1 &= (1 << 26) - (1 << 2);
10083                       insn1 |= 58 << 26;        /* ld */
10084                       insn2 = 0x7c636a14;       /* add 3,3,13 */
10085                       rel[1].r_info = ELF64_R_INFO (r_symndx2, R_PPC64_NONE);
10086                       if ((tls_mask & TLS_EXPLICIT) == 0)
10087                         r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10088                                   + R_PPC64_GOT_TPREL16_DS);
10089                       else
10090                         r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10091                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10092                     }
10093                   else
10094                     {
10095                       /* LE */
10096                       insn1 = 0x3c6d0000;       /* addis 3,13,0 */
10097                       insn2 = 0x38630000;       /* addi 3,3,0 */
10098                       if (tls_gd == 0)
10099                         {
10100                           /* Was an LD reloc.  */
10101                           r_symndx = 0;
10102                           rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10103                           rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10104                         }
10105                       else if (toc_symndx != 0)
10106                         r_symndx = toc_symndx;
10107                       r_type = R_PPC64_TPREL16_HA;
10108                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10109                       rel[1].r_info = ELF64_R_INFO (r_symndx,
10110                                                     R_PPC64_TPREL16_LO);
10111                       rel[1].r_offset += 2;
10112                     }
10113                   if (insn3 == NOP
10114                       || insn3 == CROR_151515 || insn3 == CROR_313131)
10115                     {
10116                       insn3 = insn2;
10117                       insn2 = NOP;
10118                       rel[1].r_offset += 4;
10119                     }
10120                   bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
10121                   bfd_put_32 (output_bfd, insn2, contents + offset);
10122                   bfd_put_32 (output_bfd, insn3, contents + offset + 4);
10123                   if (tls_gd == 0 || toc_symndx != 0)
10124                     {
10125                       /* We changed the symbol.  Start over in order
10126                          to get h, sym, sec etc. right.  */
10127                       rel--;
10128                       continue;
10129                     }
10130                 }
10131             }
10132           break;
10133
10134         case R_PPC64_DTPMOD64:
10135           if (rel + 1 < relend
10136               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
10137               && rel[1].r_offset == rel->r_offset + 8)
10138             {
10139               if ((tls_mask & TLS_GD) == 0)
10140                 {
10141                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
10142                   if ((tls_mask & TLS_TPRELGD) != 0)
10143                     r_type = R_PPC64_TPREL64;
10144                   else
10145                     {
10146                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10147                       r_type = R_PPC64_NONE;
10148                     }
10149                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10150                 }
10151             }
10152           else
10153             {
10154               if ((tls_mask & TLS_LD) == 0)
10155                 {
10156                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10157                   r_type = R_PPC64_NONE;
10158                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10159                 }
10160             }
10161           break;
10162
10163         case R_PPC64_TPREL64:
10164           if ((tls_mask & TLS_TPREL) == 0)
10165             {
10166               r_type = R_PPC64_NONE;
10167               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10168             }
10169           break;
10170         }
10171
10172       /* Handle other relocations that tweak non-addend part of insn.  */
10173       insn = 0;
10174       max_br_offset = 1 << 25;
10175       addend = rel->r_addend;
10176       switch (r_type)
10177         {
10178         default:
10179           break;
10180
10181           /* Branch taken prediction relocations.  */
10182         case R_PPC64_ADDR14_BRTAKEN:
10183         case R_PPC64_REL14_BRTAKEN:
10184           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
10185           /* Fall thru.  */
10186
10187           /* Branch not taken prediction relocations.  */
10188         case R_PPC64_ADDR14_BRNTAKEN:
10189         case R_PPC64_REL14_BRNTAKEN:
10190           insn |= bfd_get_32 (output_bfd,
10191                               contents + rel->r_offset) & ~(0x01 << 21);
10192           /* Fall thru.  */
10193
10194         case R_PPC64_REL14:
10195           max_br_offset = 1 << 15;
10196           /* Fall thru.  */
10197
10198         case R_PPC64_REL24:
10199           /* Calls to functions with a different TOC, such as calls to
10200              shared objects, need to alter the TOC pointer.  This is
10201              done using a linkage stub.  A REL24 branching to these
10202              linkage stubs needs to be followed by a nop, as the nop
10203              will be replaced with an instruction to restore the TOC
10204              base pointer.  */
10205           stub_entry = NULL;
10206           fdh = h;
10207           if (((h != NULL
10208                 && (((fdh = h->oh) != NULL
10209                      && fdh->elf.plt.plist != NULL)
10210                     || (fdh = h)->elf.plt.plist != NULL))
10211                || (sec != NULL
10212                    && sec->output_section != NULL
10213                    && sec->id <= htab->top_id
10214                    && (htab->stub_group[sec->id].toc_off
10215                        != htab->stub_group[input_section->id].toc_off)))
10216               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
10217                                                    rel, htab)) != NULL
10218               && (stub_entry->stub_type == ppc_stub_plt_call
10219                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
10220                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
10221             {
10222               bfd_boolean can_plt_call = FALSE;
10223
10224               if (rel->r_offset + 8 <= input_section->size)
10225                 {
10226                   unsigned long nop;
10227                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
10228                   if (nop == NOP
10229                       || nop == CROR_151515 || nop == CROR_313131)
10230                     {
10231                       bfd_put_32 (input_bfd, LD_R2_40R1,
10232                                   contents + rel->r_offset + 4);
10233                       can_plt_call = TRUE;
10234                     }
10235                 }
10236
10237               if (!can_plt_call)
10238                 {
10239                   if (stub_entry->stub_type == ppc_stub_plt_call)
10240                     {
10241                       /* If this is a plain branch rather than a branch
10242                          and link, don't require a nop.  However, don't
10243                          allow tail calls in a shared library as they
10244                          will result in r2 being corrupted.  */
10245                       unsigned long br;
10246                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
10247                       if (info->executable && (br & 1) == 0)
10248                         can_plt_call = TRUE;
10249                       else
10250                         stub_entry = NULL;
10251                     }
10252                   else if (h != NULL
10253                            && strcmp (h->elf.root.root.string,
10254                                       ".__libc_start_main") == 0)
10255                     {
10256                       /* Allow crt1 branch to go via a toc adjusting stub.  */
10257                       can_plt_call = TRUE;
10258                     }
10259                   else
10260                     {
10261                       if (strcmp (input_section->output_section->name,
10262                                   ".init") == 0
10263                           || strcmp (input_section->output_section->name,
10264                                      ".fini") == 0)
10265                         (*_bfd_error_handler)
10266                           (_("%B(%A+0x%lx): automatic multiple TOCs "
10267                              "not supported using your crt files; "
10268                              "recompile with -mminimal-toc or upgrade gcc"),
10269                            input_bfd,
10270                            input_section,
10271                            (long) rel->r_offset);
10272                       else
10273                         (*_bfd_error_handler)
10274                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
10275                              "does not allow automatic multiple TOCs; "
10276                              "recompile with -mminimal-toc or "
10277                              "-fno-optimize-sibling-calls, "
10278                              "or make `%s' extern"),
10279                            input_bfd,
10280                            input_section,
10281                            (long) rel->r_offset,
10282                            sym_name,
10283                            sym_name);
10284                       bfd_set_error (bfd_error_bad_value);
10285                       ret = FALSE;
10286                     }
10287                 }
10288
10289               if (can_plt_call
10290                   && stub_entry->stub_type == ppc_stub_plt_call)
10291                 unresolved_reloc = FALSE;
10292             }
10293
10294           if (stub_entry == NULL
10295               && get_opd_info (sec) != NULL)
10296             {
10297               /* The branch destination is the value of the opd entry. */
10298               bfd_vma off = (relocation + addend
10299                              - sec->output_section->vma
10300                              - sec->output_offset);
10301               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
10302               if (dest != (bfd_vma) -1)
10303                 {
10304                   relocation = dest;
10305                   addend = 0;
10306                 }
10307             }
10308
10309           /* If the branch is out of reach we ought to have a long
10310              branch stub.  */
10311           from = (rel->r_offset
10312                   + input_section->output_offset
10313                   + input_section->output_section->vma);
10314
10315           if (stub_entry == NULL
10316               && (relocation + addend - from + max_br_offset
10317                   >= 2 * max_br_offset)
10318               && r_type != R_PPC64_ADDR14_BRTAKEN
10319               && r_type != R_PPC64_ADDR14_BRNTAKEN)
10320             stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
10321                                              htab);
10322
10323           if (stub_entry != NULL)
10324             {
10325               /* Munge up the value and addend so that we call the stub
10326                  rather than the procedure directly.  */
10327               relocation = (stub_entry->stub_offset
10328                             + stub_entry->stub_sec->output_offset
10329                             + stub_entry->stub_sec->output_section->vma);
10330               addend = 0;
10331             }
10332
10333           if (insn != 0)
10334             {
10335               if (is_power4)
10336                 {
10337                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
10338                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
10339                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
10340                   if ((insn & (0x14 << 21)) == (0x04 << 21))
10341                     insn |= 0x02 << 21;
10342                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
10343                     insn |= 0x08 << 21;
10344                   else
10345                     break;
10346                 }
10347               else
10348                 {
10349                   /* Invert 'y' bit if not the default.  */
10350                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
10351                     insn ^= 0x01 << 21;
10352                 }
10353
10354               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10355             }
10356
10357           /* NOP out calls to undefined weak functions.
10358              We can thus call a weak function without first
10359              checking whether the function is defined.  */
10360           else if (h != NULL
10361                    && h->elf.root.type == bfd_link_hash_undefweak
10362                    && r_type == R_PPC64_REL24
10363                    && relocation == 0
10364                    && addend == 0)
10365             {
10366               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10367               continue;
10368             }
10369           break;
10370         }
10371
10372       /* Set `addend'.  */
10373       tls_type = 0;
10374       switch (r_type)
10375         {
10376         default:
10377           (*_bfd_error_handler)
10378             (_("%B: unknown relocation type %d for symbol %s"),
10379              input_bfd, (int) r_type, sym_name);
10380
10381           bfd_set_error (bfd_error_bad_value);
10382           ret = FALSE;
10383           continue;
10384
10385         case R_PPC64_NONE:
10386         case R_PPC64_TLS:
10387         case R_PPC64_GNU_VTINHERIT:
10388         case R_PPC64_GNU_VTENTRY:
10389           continue;
10390
10391           /* GOT16 relocations.  Like an ADDR16 using the symbol's
10392              address in the GOT as relocation value instead of the
10393              symbol's value itself.  Also, create a GOT entry for the
10394              symbol and put the symbol value there.  */
10395         case R_PPC64_GOT_TLSGD16:
10396         case R_PPC64_GOT_TLSGD16_LO:
10397         case R_PPC64_GOT_TLSGD16_HI:
10398         case R_PPC64_GOT_TLSGD16_HA:
10399           tls_type = TLS_TLS | TLS_GD;
10400           goto dogot;
10401
10402         case R_PPC64_GOT_TLSLD16:
10403         case R_PPC64_GOT_TLSLD16_LO:
10404         case R_PPC64_GOT_TLSLD16_HI:
10405         case R_PPC64_GOT_TLSLD16_HA:
10406           tls_type = TLS_TLS | TLS_LD;
10407           goto dogot;
10408
10409         case R_PPC64_GOT_TPREL16_DS:
10410         case R_PPC64_GOT_TPREL16_LO_DS:
10411         case R_PPC64_GOT_TPREL16_HI:
10412         case R_PPC64_GOT_TPREL16_HA:
10413           tls_type = TLS_TLS | TLS_TPREL;
10414           goto dogot;
10415
10416         case R_PPC64_GOT_DTPREL16_DS:
10417         case R_PPC64_GOT_DTPREL16_LO_DS:
10418         case R_PPC64_GOT_DTPREL16_HI:
10419         case R_PPC64_GOT_DTPREL16_HA:
10420           tls_type = TLS_TLS | TLS_DTPREL;
10421           goto dogot;
10422
10423         case R_PPC64_GOT16:
10424         case R_PPC64_GOT16_LO:
10425         case R_PPC64_GOT16_HI:
10426         case R_PPC64_GOT16_HA:
10427         case R_PPC64_GOT16_DS:
10428         case R_PPC64_GOT16_LO_DS:
10429         dogot:
10430           {
10431             /* Relocation is to the entry for this symbol in the global
10432                offset table.  */
10433             asection *got;
10434             bfd_vma *offp;
10435             bfd_vma off;
10436             unsigned long indx = 0;
10437
10438             if (tls_type == (TLS_TLS | TLS_LD)
10439                 && (h == NULL
10440                     || !h->elf.def_dynamic))
10441               offp = &ppc64_tlsld_got (input_bfd)->offset;
10442             else
10443               {
10444                 struct got_entry *ent;
10445
10446                 if (h != NULL)
10447                   {
10448                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
10449                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
10450                                                           &h->elf)
10451                         || (info->shared
10452                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
10453                       /* This is actually a static link, or it is a
10454                          -Bsymbolic link and the symbol is defined
10455                          locally, or the symbol was forced to be local
10456                          because of a version file.  */
10457                       ;
10458                     else
10459                       {
10460                         indx = h->elf.dynindx;
10461                         unresolved_reloc = FALSE;
10462                       }
10463                     ent = h->elf.got.glist;
10464                   }
10465                 else
10466                   {
10467                     if (local_got_ents == NULL)
10468                       abort ();
10469                     ent = local_got_ents[r_symndx];
10470                   }
10471
10472                 for (; ent != NULL; ent = ent->next)
10473                   if (ent->addend == orig_addend
10474                       && ent->owner == input_bfd
10475                       && ent->tls_type == tls_type)
10476                     break;
10477                 if (ent == NULL)
10478                   abort ();
10479                 offp = &ent->got.offset;
10480               }
10481
10482             got = ppc64_elf_tdata (input_bfd)->got;
10483             if (got == NULL)
10484               abort ();
10485
10486             /* The offset must always be a multiple of 8.  We use the
10487                least significant bit to record whether we have already
10488                processed this entry.  */
10489             off = *offp;
10490             if ((off & 1) != 0)
10491               off &= ~1;
10492             else
10493               {
10494                 /* Generate relocs for the dynamic linker, except in
10495                    the case of TLSLD where we'll use one entry per
10496                    module.  */
10497                 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
10498
10499                 *offp = off | 1;
10500                 if ((info->shared || indx != 0)
10501                     && (h == NULL
10502                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10503                         || h->elf.root.type != bfd_link_hash_undefweak))
10504                   {
10505                     outrel.r_offset = (got->output_section->vma
10506                                        + got->output_offset
10507                                        + off);
10508                     outrel.r_addend = addend;
10509                     if (tls_type & (TLS_LD | TLS_GD))
10510                       {
10511                         outrel.r_addend = 0;
10512                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
10513                         if (tls_type == (TLS_TLS | TLS_GD))
10514                           {
10515                             loc = relgot->contents;
10516                             loc += (relgot->reloc_count++
10517                                     * sizeof (Elf64_External_Rela));
10518                             bfd_elf64_swap_reloca_out (output_bfd,
10519                                                        &outrel, loc);
10520                             outrel.r_offset += 8;
10521                             outrel.r_addend = addend;
10522                             outrel.r_info
10523                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10524                           }
10525                       }
10526                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
10527                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10528                     else if (tls_type == (TLS_TLS | TLS_TPREL))
10529                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
10530                     else if (indx == 0)
10531                       {
10532                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
10533
10534                         /* Write the .got section contents for the sake
10535                            of prelink.  */
10536                         loc = got->contents + off;
10537                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
10538                                     loc);
10539                       }
10540                     else
10541                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
10542
10543                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
10544                       {
10545                         outrel.r_addend += relocation;
10546                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
10547                           outrel.r_addend -= htab->elf.tls_sec->vma;
10548                       }
10549                     loc = relgot->contents;
10550                     loc += (relgot->reloc_count++
10551                             * sizeof (Elf64_External_Rela));
10552                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10553                   }
10554
10555                 /* Init the .got section contents here if we're not
10556                    emitting a reloc.  */
10557                 else
10558                   {
10559                     relocation += addend;
10560                     if (tls_type == (TLS_TLS | TLS_LD))
10561                       relocation = 1;
10562                     else if (tls_type != 0)
10563                       {
10564                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
10565                         if (tls_type == (TLS_TLS | TLS_TPREL))
10566                           relocation += DTP_OFFSET - TP_OFFSET;
10567
10568                         if (tls_type == (TLS_TLS | TLS_GD))
10569                           {
10570                             bfd_put_64 (output_bfd, relocation,
10571                                         got->contents + off + 8);
10572                             relocation = 1;
10573                           }
10574                       }
10575
10576                     bfd_put_64 (output_bfd, relocation,
10577                                 got->contents + off);
10578                   }
10579               }
10580
10581             if (off >= (bfd_vma) -2)
10582               abort ();
10583
10584             relocation = got->output_offset + off;
10585
10586             /* TOC base (r2) is TOC start plus 0x8000.  */
10587             addend = -TOC_BASE_OFF;
10588           }
10589           break;
10590
10591         case R_PPC64_PLT16_HA:
10592         case R_PPC64_PLT16_HI:
10593         case R_PPC64_PLT16_LO:
10594         case R_PPC64_PLT32:
10595         case R_PPC64_PLT64:
10596           /* Relocation is to the entry for this symbol in the
10597              procedure linkage table.  */
10598
10599           /* Resolve a PLT reloc against a local symbol directly,
10600              without using the procedure linkage table.  */
10601           if (h == NULL)
10602             break;
10603
10604           /* It's possible that we didn't make a PLT entry for this
10605              symbol.  This happens when statically linking PIC code,
10606              or when using -Bsymbolic.  Go find a match if there is a
10607              PLT entry.  */
10608           if (htab->plt != NULL)
10609             {
10610               struct plt_entry *ent;
10611               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
10612                 if (ent->addend == orig_addend
10613                     && ent->plt.offset != (bfd_vma) -1)
10614                   {
10615                     relocation = (htab->plt->output_section->vma
10616                                   + htab->plt->output_offset
10617                                   + ent->plt.offset);
10618                     unresolved_reloc = FALSE;
10619                   }
10620             }
10621           break;
10622
10623         case R_PPC64_TOC:
10624           /* Relocation value is TOC base.  */
10625           relocation = TOCstart;
10626           if (r_symndx == 0)
10627             relocation += htab->stub_group[input_section->id].toc_off;
10628           else if (unresolved_reloc)
10629             ;
10630           else if (sec != NULL && sec->id <= htab->top_id)
10631             relocation += htab->stub_group[sec->id].toc_off;
10632           else
10633             unresolved_reloc = TRUE;
10634           goto dodyn2;
10635
10636           /* TOC16 relocs.  We want the offset relative to the TOC base,
10637              which is the address of the start of the TOC plus 0x8000.
10638              The TOC consists of sections .got, .toc, .tocbss, and .plt,
10639              in this order.  */
10640         case R_PPC64_TOC16:
10641         case R_PPC64_TOC16_LO:
10642         case R_PPC64_TOC16_HI:
10643         case R_PPC64_TOC16_DS:
10644         case R_PPC64_TOC16_LO_DS:
10645         case R_PPC64_TOC16_HA:
10646           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
10647           break;
10648
10649           /* Relocate against the beginning of the section.  */
10650         case R_PPC64_SECTOFF:
10651         case R_PPC64_SECTOFF_LO:
10652         case R_PPC64_SECTOFF_HI:
10653         case R_PPC64_SECTOFF_DS:
10654         case R_PPC64_SECTOFF_LO_DS:
10655         case R_PPC64_SECTOFF_HA:
10656           if (sec != NULL)
10657             addend -= sec->output_section->vma;
10658           break;
10659
10660         case R_PPC64_REL14:
10661         case R_PPC64_REL14_BRNTAKEN:
10662         case R_PPC64_REL14_BRTAKEN:
10663         case R_PPC64_REL24:
10664           break;
10665
10666         case R_PPC64_TPREL16:
10667         case R_PPC64_TPREL16_LO:
10668         case R_PPC64_TPREL16_HI:
10669         case R_PPC64_TPREL16_HA:
10670         case R_PPC64_TPREL16_DS:
10671         case R_PPC64_TPREL16_LO_DS:
10672         case R_PPC64_TPREL16_HIGHER:
10673         case R_PPC64_TPREL16_HIGHERA:
10674         case R_PPC64_TPREL16_HIGHEST:
10675         case R_PPC64_TPREL16_HIGHESTA:
10676           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10677           if (info->shared)
10678             /* The TPREL16 relocs shouldn't really be used in shared
10679                libs as they will result in DT_TEXTREL being set, but
10680                support them anyway.  */
10681             goto dodyn;
10682           break;
10683
10684         case R_PPC64_DTPREL16:
10685         case R_PPC64_DTPREL16_LO:
10686         case R_PPC64_DTPREL16_HI:
10687         case R_PPC64_DTPREL16_HA:
10688         case R_PPC64_DTPREL16_DS:
10689         case R_PPC64_DTPREL16_LO_DS:
10690         case R_PPC64_DTPREL16_HIGHER:
10691         case R_PPC64_DTPREL16_HIGHERA:
10692         case R_PPC64_DTPREL16_HIGHEST:
10693         case R_PPC64_DTPREL16_HIGHESTA:
10694           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10695           break;
10696
10697         case R_PPC64_DTPMOD64:
10698           relocation = 1;
10699           addend = 0;
10700           goto dodyn;
10701
10702         case R_PPC64_TPREL64:
10703           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10704           goto dodyn;
10705
10706         case R_PPC64_DTPREL64:
10707           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10708           /* Fall thru */
10709
10710           /* Relocations that may need to be propagated if this is a
10711              dynamic object.  */
10712         case R_PPC64_REL30:
10713         case R_PPC64_REL32:
10714         case R_PPC64_REL64:
10715         case R_PPC64_ADDR14:
10716         case R_PPC64_ADDR14_BRNTAKEN:
10717         case R_PPC64_ADDR14_BRTAKEN:
10718         case R_PPC64_ADDR16:
10719         case R_PPC64_ADDR16_DS:
10720         case R_PPC64_ADDR16_HA:
10721         case R_PPC64_ADDR16_HI:
10722         case R_PPC64_ADDR16_HIGHER:
10723         case R_PPC64_ADDR16_HIGHERA:
10724         case R_PPC64_ADDR16_HIGHEST:
10725         case R_PPC64_ADDR16_HIGHESTA:
10726         case R_PPC64_ADDR16_LO:
10727         case R_PPC64_ADDR16_LO_DS:
10728         case R_PPC64_ADDR24:
10729         case R_PPC64_ADDR32:
10730         case R_PPC64_ADDR64:
10731         case R_PPC64_UADDR16:
10732         case R_PPC64_UADDR32:
10733         case R_PPC64_UADDR64:
10734           /* r_symndx will be zero only for relocs against symbols
10735              from removed linkonce sections, or sections discarded by
10736              a linker script.  */
10737         dodyn:
10738           if (r_symndx == 0)
10739             {
10740               _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10741                                    contents + rel->r_offset);
10742               break;
10743             }
10744           /* Fall thru.  */
10745
10746         dodyn2:
10747           if ((input_section->flags & SEC_ALLOC) == 0)
10748             break;
10749
10750           if (NO_OPD_RELOCS && is_opd)
10751             break;
10752
10753           if ((info->shared
10754                && (h == NULL
10755                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10756                    || h->elf.root.type != bfd_link_hash_undefweak)
10757                && (MUST_BE_DYN_RELOC (r_type)
10758                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
10759               || (ELIMINATE_COPY_RELOCS
10760                   && !info->shared
10761                   && h != NULL
10762                   && h->elf.dynindx != -1
10763                   && !h->elf.non_got_ref
10764                   && h->elf.def_dynamic
10765                   && !h->elf.def_regular))
10766             {
10767               Elf_Internal_Rela outrel;
10768               bfd_boolean skip, relocate;
10769               asection *sreloc;
10770               bfd_byte *loc;
10771               bfd_vma out_off;
10772
10773               /* When generating a dynamic object, these relocations
10774                  are copied into the output file to be resolved at run
10775                  time.  */
10776
10777               skip = FALSE;
10778               relocate = FALSE;
10779
10780               out_off = _bfd_elf_section_offset (output_bfd, info,
10781                                                  input_section, rel->r_offset);
10782               if (out_off == (bfd_vma) -1)
10783                 skip = TRUE;
10784               else if (out_off == (bfd_vma) -2)
10785                 skip = TRUE, relocate = TRUE;
10786               out_off += (input_section->output_section->vma
10787                           + input_section->output_offset);
10788               outrel.r_offset = out_off;
10789               outrel.r_addend = rel->r_addend;
10790
10791               /* Optimize unaligned reloc use.  */
10792               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
10793                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
10794                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
10795               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
10796                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
10797                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
10798               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
10799                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
10800                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
10801
10802               if (skip)
10803                 memset (&outrel, 0, sizeof outrel);
10804               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
10805                        && !is_opd
10806                        && r_type != R_PPC64_TOC)
10807                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
10808               else
10809                 {
10810                   /* This symbol is local, or marked to become local,
10811                      or this is an opd section reloc which must point
10812                      at a local function.  */
10813                   outrel.r_addend += relocation;
10814                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
10815                     {
10816                       if (is_opd && h != NULL)
10817                         {
10818                           /* Lie about opd entries.  This case occurs
10819                              when building shared libraries and we
10820                              reference a function in another shared
10821                              lib.  The same thing happens for a weak
10822                              definition in an application that's
10823                              overridden by a strong definition in a
10824                              shared lib.  (I believe this is a generic
10825                              bug in binutils handling of weak syms.)
10826                              In these cases we won't use the opd
10827                              entry in this lib.  */
10828                           unresolved_reloc = FALSE;
10829                         }
10830                       outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10831
10832                       /* We need to relocate .opd contents for ld.so.
10833                          Prelink also wants simple and consistent rules
10834                          for relocs.  This make all RELATIVE relocs have
10835                          *r_offset equal to r_addend.  */
10836                       relocate = TRUE;
10837                     }
10838                   else
10839                     {
10840                       long indx = 0;
10841
10842                       if (bfd_is_abs_section (sec))
10843                         ;
10844                       else if (sec == NULL || sec->owner == NULL)
10845                         {
10846                           bfd_set_error (bfd_error_bad_value);
10847                           return FALSE;
10848                         }
10849                       else
10850                         {
10851                           asection *osec;
10852
10853                           osec = sec->output_section;
10854                           indx = elf_section_data (osec)->dynindx;
10855
10856                           if (indx == 0)
10857                             {
10858                               if ((osec->flags & SEC_READONLY) == 0
10859                                   && htab->elf.data_index_section != NULL)
10860                                 osec = htab->elf.data_index_section;
10861                               else
10862                                 osec = htab->elf.text_index_section;
10863                               indx = elf_section_data (osec)->dynindx;
10864                             }
10865                           BFD_ASSERT (indx != 0);
10866
10867                           /* We are turning this relocation into one
10868                              against a section symbol, so subtract out
10869                              the output section's address but not the
10870                              offset of the input section in the output
10871                              section.  */
10872                           outrel.r_addend -= osec->vma;
10873                         }
10874
10875                       outrel.r_info = ELF64_R_INFO (indx, r_type);
10876                     }
10877                 }
10878
10879               sreloc = elf_section_data (input_section)->sreloc;
10880               if (sreloc == NULL)
10881                 abort ();
10882
10883               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
10884                   >= sreloc->size)
10885                 abort ();
10886               loc = sreloc->contents;
10887               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
10888               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10889
10890               /* If this reloc is against an external symbol, it will
10891                  be computed at runtime, so there's no need to do
10892                  anything now.  However, for the sake of prelink ensure
10893                  that the section contents are a known value.  */
10894               if (! relocate)
10895                 {
10896                   unresolved_reloc = FALSE;
10897                   /* The value chosen here is quite arbitrary as ld.so
10898                      ignores section contents except for the special
10899                      case of .opd where the contents might be accessed
10900                      before relocation.  Choose zero, as that won't
10901                      cause reloc overflow.  */
10902                   relocation = 0;
10903                   addend = 0;
10904                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
10905                      to improve backward compatibility with older
10906                      versions of ld.  */
10907                   if (r_type == R_PPC64_ADDR64)
10908                     addend = outrel.r_addend;
10909                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
10910                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
10911                     addend = (input_section->output_section->vma
10912                               + input_section->output_offset
10913                               + rel->r_offset);
10914                 }
10915             }
10916           break;
10917
10918         case R_PPC64_COPY:
10919         case R_PPC64_GLOB_DAT:
10920         case R_PPC64_JMP_SLOT:
10921         case R_PPC64_RELATIVE:
10922           /* We shouldn't ever see these dynamic relocs in relocatable
10923              files.  */
10924           /* Fall through.  */
10925
10926         case R_PPC64_PLTGOT16:
10927         case R_PPC64_PLTGOT16_DS:
10928         case R_PPC64_PLTGOT16_HA:
10929         case R_PPC64_PLTGOT16_HI:
10930         case R_PPC64_PLTGOT16_LO:
10931         case R_PPC64_PLTGOT16_LO_DS:
10932         case R_PPC64_PLTREL32:
10933         case R_PPC64_PLTREL64:
10934           /* These ones haven't been implemented yet.  */
10935
10936           (*_bfd_error_handler)
10937             (_("%B: relocation %s is not supported for symbol %s."),
10938              input_bfd,
10939              ppc64_elf_howto_table[r_type]->name, sym_name);
10940
10941           bfd_set_error (bfd_error_invalid_operation);
10942           ret = FALSE;
10943           continue;
10944         }
10945
10946       /* Do any further special processing.  */
10947       switch (r_type)
10948         {
10949         default:
10950           break;
10951
10952         case R_PPC64_ADDR16_HA:
10953         case R_PPC64_ADDR16_HIGHERA:
10954         case R_PPC64_ADDR16_HIGHESTA:
10955         case R_PPC64_TOC16_HA:
10956         case R_PPC64_SECTOFF_HA:
10957         case R_PPC64_TPREL16_HA:
10958         case R_PPC64_DTPREL16_HA:
10959         case R_PPC64_TPREL16_HIGHER:
10960         case R_PPC64_TPREL16_HIGHERA:
10961         case R_PPC64_TPREL16_HIGHEST:
10962         case R_PPC64_TPREL16_HIGHESTA:
10963         case R_PPC64_DTPREL16_HIGHER:
10964         case R_PPC64_DTPREL16_HIGHERA:
10965         case R_PPC64_DTPREL16_HIGHEST:
10966         case R_PPC64_DTPREL16_HIGHESTA:
10967           /* It's just possible that this symbol is a weak symbol
10968              that's not actually defined anywhere. In that case,
10969              'sec' would be NULL, and we should leave the symbol
10970              alone (it will be set to zero elsewhere in the link).  */
10971           if (sec == NULL)
10972             break;
10973           /* Fall thru */
10974
10975         case R_PPC64_GOT16_HA:
10976         case R_PPC64_PLTGOT16_HA:
10977         case R_PPC64_PLT16_HA:
10978         case R_PPC64_GOT_TLSGD16_HA:
10979         case R_PPC64_GOT_TLSLD16_HA:
10980         case R_PPC64_GOT_TPREL16_HA:
10981         case R_PPC64_GOT_DTPREL16_HA:
10982           /* Add 0x10000 if sign bit in 0:15 is set.
10983              Bits 0:15 are not used.  */
10984           addend += 0x8000;
10985           break;
10986
10987         case R_PPC64_ADDR16_DS:
10988         case R_PPC64_ADDR16_LO_DS:
10989         case R_PPC64_GOT16_DS:
10990         case R_PPC64_GOT16_LO_DS:
10991         case R_PPC64_PLT16_LO_DS:
10992         case R_PPC64_SECTOFF_DS:
10993         case R_PPC64_SECTOFF_LO_DS:
10994         case R_PPC64_TOC16_DS:
10995         case R_PPC64_TOC16_LO_DS:
10996         case R_PPC64_PLTGOT16_DS:
10997         case R_PPC64_PLTGOT16_LO_DS:
10998         case R_PPC64_GOT_TPREL16_DS:
10999         case R_PPC64_GOT_TPREL16_LO_DS:
11000         case R_PPC64_GOT_DTPREL16_DS:
11001         case R_PPC64_GOT_DTPREL16_LO_DS:
11002         case R_PPC64_TPREL16_DS:
11003         case R_PPC64_TPREL16_LO_DS:
11004         case R_PPC64_DTPREL16_DS:
11005         case R_PPC64_DTPREL16_LO_DS:
11006           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
11007           mask = 3;
11008           /* If this reloc is against an lq insn, then the value must be
11009              a multiple of 16.  This is somewhat of a hack, but the
11010              "correct" way to do this by defining _DQ forms of all the
11011              _DS relocs bloats all reloc switches in this file.  It
11012              doesn't seem to make much sense to use any of these relocs
11013              in data, so testing the insn should be safe.  */
11014           if ((insn & (0x3f << 26)) == (56u << 26))
11015             mask = 15;
11016           if (((relocation + addend) & mask) != 0)
11017             {
11018               (*_bfd_error_handler)
11019                 (_("%B: error: relocation %s not a multiple of %d"),
11020                  input_bfd,
11021                  ppc64_elf_howto_table[r_type]->name,
11022                  mask + 1);
11023               bfd_set_error (bfd_error_bad_value);
11024               ret = FALSE;
11025               continue;
11026             }
11027           break;
11028         }
11029
11030       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11031          because such sections are not SEC_ALLOC and thus ld.so will
11032          not process them.  */
11033       if (unresolved_reloc
11034           && !((input_section->flags & SEC_DEBUGGING) != 0
11035                && h->elf.def_dynamic))
11036         {
11037           (*_bfd_error_handler)
11038             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11039              input_bfd,
11040              input_section,
11041              (long) rel->r_offset,
11042              ppc64_elf_howto_table[(int) r_type]->name,
11043              h->elf.root.root.string);
11044           ret = FALSE;
11045         }
11046
11047       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
11048                                     input_bfd,
11049                                     input_section,
11050                                     contents,
11051                                     rel->r_offset,
11052                                     relocation,
11053                                     addend);
11054
11055       if (r != bfd_reloc_ok)
11056         {
11057           if (sym_name == NULL)
11058             sym_name = "(null)";
11059           if (r == bfd_reloc_overflow)
11060             {
11061               if (warned)
11062                 continue;
11063               if (h != NULL
11064                   && h->elf.root.type == bfd_link_hash_undefweak
11065                   && ppc64_elf_howto_table[r_type]->pc_relative)
11066                 {
11067                   /* Assume this is a call protected by other code that
11068                      detects the symbol is undefined.  If this is the case,
11069                      we can safely ignore the overflow.  If not, the
11070                      program is hosed anyway, and a little warning isn't
11071                      going to help.  */
11072
11073                   continue;
11074                 }
11075
11076               if (!((*info->callbacks->reloc_overflow)
11077                     (info, (h ? &h->elf.root : NULL), sym_name,
11078                      ppc64_elf_howto_table[r_type]->name,
11079                      orig_addend, input_bfd, input_section, rel->r_offset)))
11080                 return FALSE;
11081             }
11082           else
11083             {
11084               (*_bfd_error_handler)
11085                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11086                  input_bfd,
11087                  input_section,
11088                  (long) rel->r_offset,
11089                  ppc64_elf_howto_table[r_type]->name,
11090                  sym_name,
11091                  (int) r);
11092               ret = FALSE;
11093             }
11094         }
11095     }
11096
11097   /* If we're emitting relocations, then shortly after this function
11098      returns, reloc offsets and addends for this section will be
11099      adjusted.  Worse, reloc symbol indices will be for the output
11100      file rather than the input.  Save a copy of the relocs for
11101      opd_entry_value.  */
11102   if (is_opd && (info->emitrelocations || info->relocatable))
11103     {
11104       bfd_size_type amt;
11105       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11106       rel = bfd_alloc (input_bfd, amt);
11107       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11108       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11109       if (rel == NULL)
11110         return FALSE;
11111       memcpy (rel, relocs, amt);
11112     }
11113   return ret;
11114 }
11115
11116 /* Adjust the value of any local symbols in opd sections.  */
11117
11118 static bfd_boolean
11119 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11120                               const char *name ATTRIBUTE_UNUSED,
11121                               Elf_Internal_Sym *elfsym,
11122                               asection *input_sec,
11123                               struct elf_link_hash_entry *h)
11124 {
11125   long *opd_adjust, adjust;
11126   bfd_vma value;
11127
11128   if (h != NULL)
11129     return TRUE;
11130
11131   opd_adjust = get_opd_info (input_sec);
11132   if (opd_adjust == NULL)
11133     return TRUE;
11134
11135   value = elfsym->st_value - input_sec->output_offset;
11136   if (!info->relocatable)
11137     value -= input_sec->output_section->vma;
11138
11139   adjust = opd_adjust[value / 8];
11140   if (adjust == -1)
11141     elfsym->st_value = 0;
11142   else
11143     elfsym->st_value += adjust;
11144   return TRUE;
11145 }
11146
11147 /* Finish up dynamic symbol handling.  We set the contents of various
11148    dynamic sections here.  */
11149
11150 static bfd_boolean
11151 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
11152                                  struct bfd_link_info *info,
11153                                  struct elf_link_hash_entry *h,
11154                                  Elf_Internal_Sym *sym)
11155 {
11156   struct ppc_link_hash_table *htab;
11157   struct plt_entry *ent;
11158   Elf_Internal_Rela rela;
11159   bfd_byte *loc;
11160
11161   htab = ppc_hash_table (info);
11162
11163   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
11164     if (ent->plt.offset != (bfd_vma) -1)
11165       {
11166         /* This symbol has an entry in the procedure linkage
11167            table.  Set it up.  */
11168
11169         if (htab->plt == NULL
11170             || htab->relplt == NULL
11171             || htab->glink == NULL)
11172           abort ();
11173
11174         /* Create a JMP_SLOT reloc to inform the dynamic linker to
11175            fill in the PLT entry.  */
11176         rela.r_offset = (htab->plt->output_section->vma
11177                          + htab->plt->output_offset
11178                          + ent->plt.offset);
11179         rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
11180         rela.r_addend = ent->addend;
11181
11182         loc = htab->relplt->contents;
11183         loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
11184                 * sizeof (Elf64_External_Rela));
11185         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11186       }
11187
11188   if (h->needs_copy)
11189     {
11190       Elf_Internal_Rela rela;
11191       bfd_byte *loc;
11192
11193       /* This symbol needs a copy reloc.  Set it up.  */
11194
11195       if (h->dynindx == -1
11196           || (h->root.type != bfd_link_hash_defined
11197               && h->root.type != bfd_link_hash_defweak)
11198           || htab->relbss == NULL)
11199         abort ();
11200
11201       rela.r_offset = (h->root.u.def.value
11202                        + h->root.u.def.section->output_section->vma
11203                        + h->root.u.def.section->output_offset);
11204       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
11205       rela.r_addend = 0;
11206       loc = htab->relbss->contents;
11207       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
11208       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11209     }
11210
11211   /* Mark some specially defined symbols as absolute.  */
11212   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
11213     sym->st_shndx = SHN_ABS;
11214
11215   return TRUE;
11216 }
11217
11218 /* Used to decide how to sort relocs in an optimal manner for the
11219    dynamic linker, before writing them out.  */
11220
11221 static enum elf_reloc_type_class
11222 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
11223 {
11224   enum elf_ppc64_reloc_type r_type;
11225
11226   r_type = ELF64_R_TYPE (rela->r_info);
11227   switch (r_type)
11228     {
11229     case R_PPC64_RELATIVE:
11230       return reloc_class_relative;
11231     case R_PPC64_JMP_SLOT:
11232       return reloc_class_plt;
11233     case R_PPC64_COPY:
11234       return reloc_class_copy;
11235     default:
11236       return reloc_class_normal;
11237     }
11238 }
11239
11240 /* Finish up the dynamic sections.  */
11241
11242 static bfd_boolean
11243 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
11244                                    struct bfd_link_info *info)
11245 {
11246   struct ppc_link_hash_table *htab;
11247   bfd *dynobj;
11248   asection *sdyn;
11249
11250   htab = ppc_hash_table (info);
11251   dynobj = htab->elf.dynobj;
11252   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11253
11254   if (htab->elf.dynamic_sections_created)
11255     {
11256       Elf64_External_Dyn *dyncon, *dynconend;
11257
11258       if (sdyn == NULL || htab->got == NULL)
11259         abort ();
11260
11261       dyncon = (Elf64_External_Dyn *) sdyn->contents;
11262       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
11263       for (; dyncon < dynconend; dyncon++)
11264         {
11265           Elf_Internal_Dyn dyn;
11266           asection *s;
11267
11268           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
11269
11270           switch (dyn.d_tag)
11271             {
11272             default:
11273               continue;
11274
11275             case DT_PPC64_GLINK:
11276               s = htab->glink;
11277               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11278               /* We stupidly defined DT_PPC64_GLINK to be the start
11279                  of glink rather than the first entry point, which is
11280                  what ld.so needs, and now have a bigger stub to
11281                  support automatic multiple TOCs.  */
11282               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
11283               break;
11284
11285             case DT_PPC64_OPD:
11286               s = bfd_get_section_by_name (output_bfd, ".opd");
11287               if (s == NULL)
11288                 continue;
11289               dyn.d_un.d_ptr = s->vma;
11290               break;
11291
11292             case DT_PPC64_OPDSZ:
11293               s = bfd_get_section_by_name (output_bfd, ".opd");
11294               if (s == NULL)
11295                 continue;
11296               dyn.d_un.d_val = s->size;
11297               break;
11298
11299             case DT_PLTGOT:
11300               s = htab->plt;
11301               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11302               break;
11303
11304             case DT_JMPREL:
11305               s = htab->relplt;
11306               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11307               break;
11308
11309             case DT_PLTRELSZ:
11310               dyn.d_un.d_val = htab->relplt->size;
11311               break;
11312
11313             case DT_RELASZ:
11314               /* Don't count procedure linkage table relocs in the
11315                  overall reloc count.  */
11316               s = htab->relplt;
11317               if (s == NULL)
11318                 continue;
11319               dyn.d_un.d_val -= s->size;
11320               break;
11321
11322             case DT_RELA:
11323               /* We may not be using the standard ELF linker script.
11324                  If .rela.plt is the first .rela section, we adjust
11325                  DT_RELA to not include it.  */
11326               s = htab->relplt;
11327               if (s == NULL)
11328                 continue;
11329               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
11330                 continue;
11331               dyn.d_un.d_ptr += s->size;
11332               break;
11333             }
11334
11335           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
11336         }
11337     }
11338
11339   if (htab->got != NULL && htab->got->size != 0)
11340     {
11341       /* Fill in the first entry in the global offset table.
11342          We use it to hold the link-time TOCbase.  */
11343       bfd_put_64 (output_bfd,
11344                   elf_gp (output_bfd) + TOC_BASE_OFF,
11345                   htab->got->contents);
11346
11347       /* Set .got entry size.  */
11348       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
11349     }
11350
11351   if (htab->plt != NULL && htab->plt->size != 0)
11352     {
11353       /* Set .plt entry size.  */
11354       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
11355         = PLT_ENTRY_SIZE;
11356     }
11357
11358   /* We need to handle writing out multiple GOT sections ourselves,
11359      since we didn't add them to DYNOBJ.  We know dynobj is the first
11360      bfd.  */
11361   while ((dynobj = dynobj->link_next) != NULL)
11362     {
11363       asection *s;
11364
11365       if (!is_ppc64_elf_target (dynobj->xvec))
11366         continue;
11367
11368       s = ppc64_elf_tdata (dynobj)->got;
11369       if (s != NULL
11370           && s->size != 0
11371           && s->output_section != bfd_abs_section_ptr
11372           && !bfd_set_section_contents (output_bfd, s->output_section,
11373                                         s->contents, s->output_offset,
11374                                         s->size))
11375         return FALSE;
11376       s = ppc64_elf_tdata (dynobj)->relgot;
11377       if (s != NULL
11378           && s->size != 0
11379           && s->output_section != bfd_abs_section_ptr
11380           && !bfd_set_section_contents (output_bfd, s->output_section,
11381                                         s->contents, s->output_offset,
11382                                         s->size))
11383         return FALSE;
11384     }
11385
11386   return TRUE;
11387 }
11388
11389 #include "elf64-target.h"