bfd/elf64-ppc.c

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