bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License along
  19    with this program; if not, write to the Free Software Foundation, Inc.,
  20    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /* The 64-bit PowerPC ELF ABI may be found at
  23    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  24    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  25
  26 #include "bfd.h"
  27 #include "sysdep.h"
  28 #include "bfdlink.h"
  29 #include "libbfd.h"
  30 #include "elf-bfd.h"
  31 #include "elf/ppc.h"
  32 #include "elf/ppc64.h"
  33 #include "elf64-ppc.h"
  34
  35 static bfd_reloc_status_type ppc64_elf_ha_reloc
  36   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  37 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  38   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  39 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  41 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_reloc_status_type ppc64_elf_toc_reloc
  44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  45 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  46   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  47 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  48   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  49 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  51
  52
  53 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  54 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  55 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  56 #define TARGET_BIG_NAME         "elf64-powerpc"
  57 #define ELF_ARCH                bfd_arch_powerpc
  58 #define ELF_MACHINE_CODE        EM_PPC64
  59 #define ELF_MAXPAGESIZE         0x10000
  60 #define elf_info_to_howto       ppc64_elf_info_to_howto
  61
  62 #define elf_backend_want_got_sym 0
  63 #define elf_backend_want_plt_sym 0
  64 #define elf_backend_plt_alignment 3
  65 #define elf_backend_plt_not_loaded 1
  66 #define elf_backend_got_symbol_offset 0
  67 #define elf_backend_got_header_size 8
  68 #define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
  69 #define elf_backend_can_gc_sections 1
  70 #define elf_backend_can_refcount 1
  71 #define elf_backend_rela_normal 1
  72
  73 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  74 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  75 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  76 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  77 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  78 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  79
  80 #define elf_backend_object_p                  ppc64_elf_object_p
  81 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  82 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  83 #define elf_backend_check_relocs              ppc64_elf_check_relocs
  84 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
  85 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
  86 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
  87 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
  88 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
  89 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
  90 #define elf_backend_relocate_section          ppc64_elf_relocate_section
  91 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
  92 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
  93 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
  94 #define elf_backend_special_sections          ppc64_elf_special_sections
  95
  96 /* The name of the dynamic interpreter.  This is put in the .interp
  97    section.  */
  98 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
  99
 100 /* The size in bytes of an entry in the procedure linkage table.  */
 101 #define PLT_ENTRY_SIZE 24
 102
 103 /* The initial size of the plt reserved for the dynamic linker.  */
 104 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 105
 106 /* TOC base pointers offset from start of TOC.  */
 107 #define TOC_BASE_OFF    0x8000
 108
 109 /* Offset of tp and dtp pointers from start of TLS block.  */
 110 #define TP_OFFSET       0x7000
 111 #define DTP_OFFSET      0x8000
 112
 113 /* .plt call stub instructions.  The normal stub is like this, but
 114    sometimes the .plt entry crosses a 64k boundary and we need to
 115    insert an addis to adjust r12.  */
 116 #define PLT_CALL_STUB_SIZE (7*4)
 117 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 118 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 119 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 120 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 121 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 122                                         /* ld    %r11,xxx+16@l(%r12) */
 123 #define BCTR            0x4e800420      /* bctr                      */
 124
 125
 126 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 127 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 128
 129 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 130
 131 /* glink call stub instructions.  We enter with the index in R0, and the
 132    address of glink entry in CTR.  From that, we can calculate PLT0.  */
 133 #define GLINK_CALL_STUB_SIZE (16*4)
 134 #define MFCTR_R12       0x7d8902a6      /* mfctr  %r12                  */
 135 #define SLDI_R11_R0_3   0x780b1f24      /* sldi   %r11,%r0,3            */
 136 #define ADDIC_R2_R0_32K 0x34408000      /* addic. %r2,%r0,-32768        */
 137 #define SUB_R12_R12_R11 0x7d8b6050      /* sub    %r12,%r12,%r11        */
 138 #define SRADI_R2_R2_63  0x7c42fe76      /* sradi  %r2,%r2,63            */
 139 #define SLDI_R11_R0_2   0x780b1764      /* sldi   %r11,%r0,2            */
 140 #define AND_R2_R2_R11   0x7c425838      /* and    %r2,%r2,%r11          */
 141                                         /* sub    %r12,%r12,%r11        */
 142 #define ADD_R12_R12_R2  0x7d8c1214      /* add    %r12,%r12,%r2         */
 143 #define ADDIS_R12_R12   0x3d8c0000      /* addis  %r12,%r12,xxx@ha      */
 144                                         /* ld     %r11,xxx@l(%r12)      */
 145 #define ADDI_R12_R12    0x398c0000      /* addi   %r12,%r12,xxx@l       */
 146                                         /* ld     %r2,8(%r12)           */
 147                                         /* mtctr  %r11                  */
 148                                         /* ld     %r11,16(%r12)         */
 149                                         /* bctr                         */
 150
 151 /* Pad with this.  */
 152 #define NOP             0x60000000
 153
 154 /* Some other nops.  */
 155 #define CROR_151515     0x4def7b82
 156 #define CROR_313131     0x4ffffb82
 157
 158 /* .glink entries for the first 32k functions are two instructions.  */
 159 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 160 #define B_DOT           0x48000000      /* b     .              */
 161
 162 /* After that, we need two instructions to load the index, followed by
 163    a branch.  */
 164 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 165 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 166
 167 /* Instructions to save and restore floating point regs.  */
 168 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 169 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 170 #define BLR             0x4e800020      /* blr                  */
 171
 172 /* Since .opd is an array of descriptors and each entry will end up
 173    with identical R_PPC64_RELATIVE relocs, there is really no need to
 174    propagate .opd relocs;  The dynamic linker should be taught to
 175    relocate .opd without reloc entries.  */
 176 #ifndef NO_OPD_RELOCS
 177 #define NO_OPD_RELOCS 0
 178 #endif
 179 \f
 180 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 181
 182 /* Relocation HOWTO's.  */
 183 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 184
 185 static reloc_howto_type ppc64_elf_howto_raw[] = {
 186   /* This reloc does nothing.  */
 187   HOWTO (R_PPC64_NONE,          /* type */
 188          0,                     /* rightshift */
 189          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 190          32,                    /* bitsize */
 191          FALSE,                 /* pc_relative */
 192          0,                     /* bitpos */
 193          complain_overflow_dont, /* complain_on_overflow */
 194          bfd_elf_generic_reloc, /* special_function */
 195          "R_PPC64_NONE",        /* name */
 196          FALSE,                 /* partial_inplace */
 197          0,                     /* src_mask */
 198          0,                     /* dst_mask */
 199          FALSE),                /* pcrel_offset */
 200
 201   /* A standard 32 bit relocation.  */
 202   HOWTO (R_PPC64_ADDR32,        /* type */
 203          0,                     /* rightshift */
 204          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 205          32,                    /* bitsize */
 206          FALSE,                 /* pc_relative */
 207          0,                     /* bitpos */
 208          complain_overflow_bitfield, /* complain_on_overflow */
 209          bfd_elf_generic_reloc, /* special_function */
 210          "R_PPC64_ADDR32",      /* name */
 211          FALSE,                 /* partial_inplace */
 212          0,                     /* src_mask */
 213          0xffffffff,            /* dst_mask */
 214          FALSE),                /* pcrel_offset */
 215
 216   /* An absolute 26 bit branch; the lower two bits must be zero.
 217      FIXME: we don't check that, we just clear them.  */
 218   HOWTO (R_PPC64_ADDR24,        /* type */
 219          0,                     /* rightshift */
 220          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 221          26,                    /* bitsize */
 222          FALSE,                 /* pc_relative */
 223          0,                     /* bitpos */
 224          complain_overflow_bitfield, /* complain_on_overflow */
 225          bfd_elf_generic_reloc, /* special_function */
 226          "R_PPC64_ADDR24",      /* name */
 227          FALSE,                 /* partial_inplace */
 228          0,                     /* src_mask */
 229          0x03fffffc,            /* dst_mask */
 230          FALSE),                /* pcrel_offset */
 231
 232   /* A standard 16 bit relocation.  */
 233   HOWTO (R_PPC64_ADDR16,        /* type */
 234          0,                     /* rightshift */
 235          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 236          16,                    /* bitsize */
 237          FALSE,                 /* pc_relative */
 238          0,                     /* bitpos */
 239          complain_overflow_bitfield, /* complain_on_overflow */
 240          bfd_elf_generic_reloc, /* special_function */
 241          "R_PPC64_ADDR16",      /* name */
 242          FALSE,                 /* partial_inplace */
 243          0,                     /* src_mask */
 244          0xffff,                /* dst_mask */
 245          FALSE),                /* pcrel_offset */
 246
 247   /* A 16 bit relocation without overflow.  */
 248   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 249          0,                     /* rightshift */
 250          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 251          16,                    /* bitsize */
 252          FALSE,                 /* pc_relative */
 253          0,                     /* bitpos */
 254          complain_overflow_dont,/* complain_on_overflow */
 255          bfd_elf_generic_reloc, /* special_function */
 256          "R_PPC64_ADDR16_LO",   /* name */
 257          FALSE,                 /* partial_inplace */
 258          0,                     /* src_mask */
 259          0xffff,                /* dst_mask */
 260          FALSE),                /* pcrel_offset */
 261
 262   /* Bits 16-31 of an address.  */
 263   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 264          16,                    /* rightshift */
 265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 266          16,                    /* bitsize */
 267          FALSE,                 /* pc_relative */
 268          0,                     /* bitpos */
 269          complain_overflow_dont, /* complain_on_overflow */
 270          bfd_elf_generic_reloc, /* special_function */
 271          "R_PPC64_ADDR16_HI",   /* name */
 272          FALSE,                 /* partial_inplace */
 273          0,                     /* src_mask */
 274          0xffff,                /* dst_mask */
 275          FALSE),                /* pcrel_offset */
 276
 277   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 278      bits, treated as a signed number, is negative.  */
 279   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 280          16,                    /* rightshift */
 281          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 282          16,                    /* bitsize */
 283          FALSE,                 /* pc_relative */
 284          0,                     /* bitpos */
 285          complain_overflow_dont, /* complain_on_overflow */
 286          ppc64_elf_ha_reloc,    /* special_function */
 287          "R_PPC64_ADDR16_HA",   /* name */
 288          FALSE,                 /* partial_inplace */
 289          0,                     /* src_mask */
 290          0xffff,                /* dst_mask */
 291          FALSE),                /* pcrel_offset */
 292
 293   /* An absolute 16 bit branch; the lower two bits must be zero.
 294      FIXME: we don't check that, we just clear them.  */
 295   HOWTO (R_PPC64_ADDR14,        /* type */
 296          0,                     /* rightshift */
 297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          16,                    /* bitsize */
 299          FALSE,                 /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_bitfield, /* complain_on_overflow */
 302          bfd_elf_generic_reloc, /* special_function */
 303          "R_PPC64_ADDR14",      /* name */
 304          FALSE,                 /* partial_inplace */
 305          0,                     /* src_mask */
 306          0x0000fffc,            /* dst_mask */
 307          FALSE),                /* pcrel_offset */
 308
 309   /* An absolute 16 bit branch, for which bit 10 should be set to
 310      indicate that the branch is expected to be taken.  The lower two
 311      bits must be zero.  */
 312   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 313          0,                     /* rightshift */
 314          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 315          16,                    /* bitsize */
 316          FALSE,                 /* pc_relative */
 317          0,                     /* bitpos */
 318          complain_overflow_bitfield, /* complain_on_overflow */
 319          ppc64_elf_brtaken_reloc, /* special_function */
 320          "R_PPC64_ADDR14_BRTAKEN",/* name */
 321          FALSE,                 /* partial_inplace */
 322          0,                     /* src_mask */
 323          0x0000fffc,            /* dst_mask */
 324          FALSE),                /* pcrel_offset */
 325
 326   /* An absolute 16 bit branch, for which bit 10 should be set to
 327      indicate that the branch is not expected to be taken.  The lower
 328      two bits must be zero.  */
 329   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 330          0,                     /* rightshift */
 331          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 332          16,                    /* bitsize */
 333          FALSE,                 /* pc_relative */
 334          0,                     /* bitpos */
 335          complain_overflow_bitfield, /* complain_on_overflow */
 336          ppc64_elf_brtaken_reloc, /* special_function */
 337          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 338          FALSE,                 /* partial_inplace */
 339          0,                     /* src_mask */
 340          0x0000fffc,            /* dst_mask */
 341          FALSE),                /* pcrel_offset */
 342
 343   /* A relative 26 bit branch; the lower two bits must be zero.  */
 344   HOWTO (R_PPC64_REL24,         /* type */
 345          0,                     /* rightshift */
 346          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 347          26,                    /* bitsize */
 348          TRUE,                  /* pc_relative */
 349          0,                     /* bitpos */
 350          complain_overflow_signed, /* complain_on_overflow */
 351          bfd_elf_generic_reloc, /* special_function */
 352          "R_PPC64_REL24",       /* name */
 353          FALSE,                 /* partial_inplace */
 354          0,                     /* src_mask */
 355          0x03fffffc,            /* dst_mask */
 356          TRUE),                 /* pcrel_offset */
 357
 358   /* A relative 16 bit branch; the lower two bits must be zero.  */
 359   HOWTO (R_PPC64_REL14,         /* type */
 360          0,                     /* rightshift */
 361          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 362          16,                    /* bitsize */
 363          TRUE,                  /* pc_relative */
 364          0,                     /* bitpos */
 365          complain_overflow_signed, /* complain_on_overflow */
 366          bfd_elf_generic_reloc, /* special_function */
 367          "R_PPC64_REL14",       /* name */
 368          FALSE,                 /* partial_inplace */
 369          0,                     /* src_mask */
 370          0x0000fffc,            /* dst_mask */
 371          TRUE),                 /* pcrel_offset */
 372
 373   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 374      the branch is expected to be taken.  The lower two bits must be
 375      zero.  */
 376   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 377          0,                     /* rightshift */
 378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 379          16,                    /* bitsize */
 380          TRUE,                  /* pc_relative */
 381          0,                     /* bitpos */
 382          complain_overflow_signed, /* complain_on_overflow */
 383          ppc64_elf_brtaken_reloc, /* special_function */
 384          "R_PPC64_REL14_BRTAKEN", /* name */
 385          FALSE,                 /* partial_inplace */
 386          0,                     /* src_mask */
 387          0x0000fffc,            /* dst_mask */
 388          TRUE),                 /* pcrel_offset */
 389
 390   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 391      the branch is not expected to be taken.  The lower two bits must
 392      be zero.  */
 393   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 394          0,                     /* rightshift */
 395          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 396          16,                    /* bitsize */
 397          TRUE,                  /* pc_relative */
 398          0,                     /* bitpos */
 399          complain_overflow_signed, /* complain_on_overflow */
 400          ppc64_elf_brtaken_reloc, /* special_function */
 401          "R_PPC64_REL14_BRNTAKEN",/* name */
 402          FALSE,                 /* partial_inplace */
 403          0,                     /* src_mask */
 404          0x0000fffc,            /* dst_mask */
 405          TRUE),                 /* pcrel_offset */
 406
 407   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 408      symbol.  */
 409   HOWTO (R_PPC64_GOT16,         /* type */
 410          0,                     /* rightshift */
 411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 412          16,                    /* bitsize */
 413          FALSE,                 /* pc_relative */
 414          0,                     /* bitpos */
 415          complain_overflow_signed, /* complain_on_overflow */
 416          ppc64_elf_unhandled_reloc, /* special_function */
 417          "R_PPC64_GOT16",       /* name */
 418          FALSE,                 /* partial_inplace */
 419          0,                     /* src_mask */
 420          0xffff,                /* dst_mask */
 421          FALSE),                /* pcrel_offset */
 422
 423   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 424      the symbol.  */
 425   HOWTO (R_PPC64_GOT16_LO,      /* type */
 426          0,                     /* rightshift */
 427          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 428          16,                    /* bitsize */
 429          FALSE,                 /* pc_relative */
 430          0,                     /* bitpos */
 431          complain_overflow_dont, /* complain_on_overflow */
 432          ppc64_elf_unhandled_reloc, /* special_function */
 433          "R_PPC64_GOT16_LO",    /* name */
 434          FALSE,                 /* partial_inplace */
 435          0,                     /* src_mask */
 436          0xffff,                /* dst_mask */
 437          FALSE),                /* pcrel_offset */
 438
 439   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 440      the symbol.  */
 441   HOWTO (R_PPC64_GOT16_HI,      /* type */
 442          16,                    /* rightshift */
 443          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          FALSE,                 /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_dont,/* complain_on_overflow */
 448          ppc64_elf_unhandled_reloc, /* special_function */
 449          "R_PPC64_GOT16_HI",    /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0xffff,                /* dst_mask */
 453          FALSE),                /* pcrel_offset */
 454
 455   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 456      the symbol.  */
 457   HOWTO (R_PPC64_GOT16_HA,      /* type */
 458          16,                    /* rightshift */
 459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_dont,/* complain_on_overflow */
 464          ppc64_elf_unhandled_reloc, /* special_function */
 465          "R_PPC64_GOT16_HA",    /* name */
 466          FALSE,                 /* partial_inplace */
 467          0,                     /* src_mask */
 468          0xffff,                /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   /* This is used only by the dynamic linker.  The symbol should exist
 472      both in the object being run and in some shared library.  The
 473      dynamic linker copies the data addressed by the symbol from the
 474      shared library into the object, because the object being
 475      run has to have the data at some particular address.  */
 476   HOWTO (R_PPC64_COPY,          /* type */
 477          0,                     /* rightshift */
 478          0,                     /* this one is variable size */
 479          0,                     /* bitsize */
 480          FALSE,                 /* pc_relative */
 481          0,                     /* bitpos */
 482          complain_overflow_dont, /* complain_on_overflow */
 483          ppc64_elf_unhandled_reloc, /* special_function */
 484          "R_PPC64_COPY",        /* name */
 485          FALSE,                 /* partial_inplace */
 486          0,                     /* src_mask */
 487          0,                     /* dst_mask */
 488          FALSE),                /* pcrel_offset */
 489
 490   /* Like R_PPC64_ADDR64, but used when setting global offset table
 491      entries.  */
 492   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 493          0,                     /* rightshift */
 494          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 495          64,                    /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_dont, /* complain_on_overflow */
 499          ppc64_elf_unhandled_reloc,  /* special_function */
 500          "R_PPC64_GLOB_DAT",    /* name */
 501          FALSE,                 /* partial_inplace */
 502          0,                     /* src_mask */
 503          ONES (64),             /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505
 506   /* Created by the link editor.  Marks a procedure linkage table
 507      entry for a symbol.  */
 508   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 509          0,                     /* rightshift */
 510          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 511          0,                     /* bitsize */
 512          FALSE,                 /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_dont, /* complain_on_overflow */
 515          ppc64_elf_unhandled_reloc, /* special_function */
 516          "R_PPC64_JMP_SLOT",    /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0,                     /* dst_mask */
 520          FALSE),                /* pcrel_offset */
 521
 522   /* Used only by the dynamic linker.  When the object is run, this
 523      doubleword64 is set to the load address of the object, plus the
 524      addend.  */
 525   HOWTO (R_PPC64_RELATIVE,      /* type */
 526          0,                     /* rightshift */
 527          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 528          64,                    /* bitsize */
 529          FALSE,                 /* pc_relative */
 530          0,                     /* bitpos */
 531          complain_overflow_dont, /* complain_on_overflow */
 532          bfd_elf_generic_reloc, /* special_function */
 533          "R_PPC64_RELATIVE",    /* name */
 534          FALSE,                 /* partial_inplace */
 535          0,                     /* src_mask */
 536          ONES (64),             /* dst_mask */
 537          FALSE),                /* pcrel_offset */
 538
 539   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 540   HOWTO (R_PPC64_UADDR32,       /* type */
 541          0,                     /* rightshift */
 542          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          32,                    /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_bitfield, /* complain_on_overflow */
 547          bfd_elf_generic_reloc, /* special_function */
 548          "R_PPC64_UADDR32",     /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0xffffffff,            /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 555   HOWTO (R_PPC64_UADDR16,       /* type */
 556          0,                     /* rightshift */
 557          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 558          16,                    /* bitsize */
 559          FALSE,                 /* pc_relative */
 560          0,                     /* bitpos */
 561          complain_overflow_bitfield, /* complain_on_overflow */
 562          bfd_elf_generic_reloc, /* special_function */
 563          "R_PPC64_UADDR16",     /* name */
 564          FALSE,                 /* partial_inplace */
 565          0,                     /* src_mask */
 566          0xffff,                /* dst_mask */
 567          FALSE),                /* pcrel_offset */
 568
 569   /* 32-bit PC relative.  */
 570   HOWTO (R_PPC64_REL32,         /* type */
 571          0,                     /* rightshift */
 572          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 573          32,                    /* bitsize */
 574          TRUE,                  /* pc_relative */
 575          0,                     /* bitpos */
 576          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 577          complain_overflow_signed, /* complain_on_overflow */
 578          bfd_elf_generic_reloc, /* special_function */
 579          "R_PPC64_REL32",       /* name */
 580          FALSE,                 /* partial_inplace */
 581          0,                     /* src_mask */
 582          0xffffffff,            /* dst_mask */
 583          TRUE),                 /* pcrel_offset */
 584
 585   /* 32-bit relocation to the symbol's procedure linkage table.  */
 586   HOWTO (R_PPC64_PLT32,         /* type */
 587          0,                     /* rightshift */
 588          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 589          32,                    /* bitsize */
 590          FALSE,                 /* pc_relative */
 591          0,                     /* bitpos */
 592          complain_overflow_bitfield, /* complain_on_overflow */
 593          ppc64_elf_unhandled_reloc, /* special_function */
 594          "R_PPC64_PLT32",       /* name */
 595          FALSE,                 /* partial_inplace */
 596          0,                     /* src_mask */
 597          0xffffffff,            /* dst_mask */
 598          FALSE),                /* pcrel_offset */
 599
 600   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 601      FIXME: R_PPC64_PLTREL32 not supported.  */
 602   HOWTO (R_PPC64_PLTREL32,      /* type */
 603          0,                     /* rightshift */
 604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 605          32,                    /* bitsize */
 606          TRUE,                  /* pc_relative */
 607          0,                     /* bitpos */
 608          complain_overflow_signed, /* complain_on_overflow */
 609          bfd_elf_generic_reloc, /* special_function */
 610          "R_PPC64_PLTREL32",    /* name */
 611          FALSE,                 /* partial_inplace */
 612          0,                     /* src_mask */
 613          0xffffffff,            /* dst_mask */
 614          TRUE),                 /* pcrel_offset */
 615
 616   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 617      the symbol.  */
 618   HOWTO (R_PPC64_PLT16_LO,      /* type */
 619          0,                     /* rightshift */
 620          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          16,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_dont, /* complain_on_overflow */
 625          ppc64_elf_unhandled_reloc, /* special_function */
 626          "R_PPC64_PLT16_LO",    /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0xffff,                /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 633      the symbol.  */
 634   HOWTO (R_PPC64_PLT16_HI,      /* type */
 635          16,                    /* rightshift */
 636          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          16,                    /* bitsize */
 638          FALSE,                 /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_dont, /* complain_on_overflow */
 641          ppc64_elf_unhandled_reloc, /* special_function */
 642          "R_PPC64_PLT16_HI",    /* name */
 643          FALSE,                 /* partial_inplace */
 644          0,                     /* src_mask */
 645          0xffff,                /* dst_mask */
 646          FALSE),                /* pcrel_offset */
 647
 648   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 649      the symbol.  */
 650   HOWTO (R_PPC64_PLT16_HA,      /* type */
 651          16,                    /* rightshift */
 652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          16,                    /* bitsize */
 654          FALSE,                 /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_dont, /* complain_on_overflow */
 657          ppc64_elf_unhandled_reloc, /* special_function */
 658          "R_PPC64_PLT16_HA",    /* name */
 659          FALSE,                 /* partial_inplace */
 660          0,                     /* src_mask */
 661          0xffff,                /* dst_mask */
 662          FALSE),                /* pcrel_offset */
 663
 664   /* 16-bit section relative relocation.  */
 665   HOWTO (R_PPC64_SECTOFF,       /* type */
 666          0,                     /* rightshift */
 667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 668          16,                    /* bitsize */
 669          FALSE,                 /* pc_relative */
 670          0,                     /* bitpos */
 671          complain_overflow_bitfield, /* complain_on_overflow */
 672          ppc64_elf_sectoff_reloc, /* special_function */
 673          "R_PPC64_SECTOFF",     /* name */
 674          FALSE,                 /* partial_inplace */
 675          0,                     /* src_mask */
 676          0xffff,                /* dst_mask */
 677          FALSE),                /* pcrel_offset */
 678
 679   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 680   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 681          0,                     /* rightshift */
 682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 683          16,                    /* bitsize */
 684          FALSE,                 /* pc_relative */
 685          0,                     /* bitpos */
 686          complain_overflow_dont, /* complain_on_overflow */
 687          ppc64_elf_sectoff_reloc, /* special_function */
 688          "R_PPC64_SECTOFF_LO",  /* name */
 689          FALSE,                 /* partial_inplace */
 690          0,                     /* src_mask */
 691          0xffff,                /* dst_mask */
 692          FALSE),                /* pcrel_offset */
 693
 694   /* 16-bit upper half section relative relocation.  */
 695   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 696          16,                    /* rightshift */
 697          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 698          16,                    /* bitsize */
 699          FALSE,                 /* pc_relative */
 700          0,                     /* bitpos */
 701          complain_overflow_dont, /* complain_on_overflow */
 702          ppc64_elf_sectoff_reloc, /* special_function */
 703          "R_PPC64_SECTOFF_HI",  /* name */
 704          FALSE,                 /* partial_inplace */
 705          0,                     /* src_mask */
 706          0xffff,                /* dst_mask */
 707          FALSE),                /* pcrel_offset */
 708
 709   /* 16-bit upper half adjusted section relative relocation.  */
 710   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 711          16,                    /* rightshift */
 712          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 713          16,                    /* bitsize */
 714          FALSE,                 /* pc_relative */
 715          0,                     /* bitpos */
 716          complain_overflow_dont, /* complain_on_overflow */
 717          ppc64_elf_sectoff_ha_reloc, /* special_function */
 718          "R_PPC64_SECTOFF_HA",  /* name */
 719          FALSE,                 /* partial_inplace */
 720          0,                     /* src_mask */
 721          0xffff,                /* dst_mask */
 722          FALSE),                /* pcrel_offset */
 723
 724   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 725   HOWTO (R_PPC64_REL30,         /* type */
 726          2,                     /* rightshift */
 727          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 728          30,                    /* bitsize */
 729          TRUE,                  /* pc_relative */
 730          0,                     /* bitpos */
 731          complain_overflow_dont, /* complain_on_overflow */
 732          bfd_elf_generic_reloc, /* special_function */
 733          "R_PPC64_REL30",       /* name */
 734          FALSE,                 /* partial_inplace */
 735          0,                     /* src_mask */
 736          0xfffffffc,            /* dst_mask */
 737          TRUE),                 /* pcrel_offset */
 738
 739   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 740
 741   /* A standard 64-bit relocation.  */
 742   HOWTO (R_PPC64_ADDR64,        /* type */
 743          0,                     /* rightshift */
 744          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 745          64,                    /* bitsize */
 746          FALSE,                 /* pc_relative */
 747          0,                     /* bitpos */
 748          complain_overflow_dont, /* complain_on_overflow */
 749          bfd_elf_generic_reloc, /* special_function */
 750          "R_PPC64_ADDR64",      /* name */
 751          FALSE,                 /* partial_inplace */
 752          0,                     /* src_mask */
 753          ONES (64),             /* dst_mask */
 754          FALSE),                /* pcrel_offset */
 755
 756   /* The bits 32-47 of an address.  */
 757   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 758          32,                    /* rightshift */
 759          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          16,                    /* bitsize */
 761          FALSE,                 /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_dont, /* complain_on_overflow */
 764          bfd_elf_generic_reloc, /* special_function */
 765          "R_PPC64_ADDR16_HIGHER", /* name */
 766          FALSE,                 /* partial_inplace */
 767          0,                     /* src_mask */
 768          0xffff,                /* dst_mask */
 769          FALSE),                /* pcrel_offset */
 770
 771   /* The bits 32-47 of an address, plus 1 if the contents of the low
 772      16 bits, treated as a signed number, is negative.  */
 773   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 774          32,                    /* rightshift */
 775          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 776          16,                    /* bitsize */
 777          FALSE,                 /* pc_relative */
 778          0,                     /* bitpos */
 779          complain_overflow_dont, /* complain_on_overflow */
 780          ppc64_elf_ha_reloc,    /* special_function */
 781          "R_PPC64_ADDR16_HIGHERA", /* name */
 782          FALSE,                 /* partial_inplace */
 783          0,                     /* src_mask */
 784          0xffff,                /* dst_mask */
 785          FALSE),                /* pcrel_offset */
 786
 787   /* The bits 48-63 of an address.  */
 788   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 789          48,                    /* rightshift */
 790          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 791          16,                    /* bitsize */
 792          FALSE,                 /* pc_relative */
 793          0,                     /* bitpos */
 794          complain_overflow_dont, /* complain_on_overflow */
 795          bfd_elf_generic_reloc, /* special_function */
 796          "R_PPC64_ADDR16_HIGHEST", /* name */
 797          FALSE,                 /* partial_inplace */
 798          0,                     /* src_mask */
 799          0xffff,                /* dst_mask */
 800          FALSE),                /* pcrel_offset */
 801
 802   /* The bits 48-63 of an address, plus 1 if the contents of the low
 803      16 bits, treated as a signed number, is negative.  */
 804   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 805          48,                    /* rightshift */
 806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 807          16,                    /* bitsize */
 808          FALSE,                 /* pc_relative */
 809          0,                     /* bitpos */
 810          complain_overflow_dont, /* complain_on_overflow */
 811          ppc64_elf_ha_reloc,    /* special_function */
 812          "R_PPC64_ADDR16_HIGHESTA", /* name */
 813          FALSE,                 /* partial_inplace */
 814          0,                     /* src_mask */
 815          0xffff,                /* dst_mask */
 816          FALSE),                /* pcrel_offset */
 817
 818   /* Like ADDR64, but may be unaligned.  */
 819   HOWTO (R_PPC64_UADDR64,       /* type */
 820          0,                     /* rightshift */
 821          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 822          64,                    /* bitsize */
 823          FALSE,                 /* pc_relative */
 824          0,                     /* bitpos */
 825          complain_overflow_dont, /* complain_on_overflow */
 826          bfd_elf_generic_reloc, /* special_function */
 827          "R_PPC64_UADDR64",     /* name */
 828          FALSE,                 /* partial_inplace */
 829          0,                     /* src_mask */
 830          ONES (64),             /* dst_mask */
 831          FALSE),                /* pcrel_offset */
 832
 833   /* 64-bit relative relocation.  */
 834   HOWTO (R_PPC64_REL64,         /* type */
 835          0,                     /* rightshift */
 836          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 837          64,                    /* bitsize */
 838          TRUE,                  /* pc_relative */
 839          0,                     /* bitpos */
 840          complain_overflow_dont, /* complain_on_overflow */
 841          bfd_elf_generic_reloc, /* special_function */
 842          "R_PPC64_REL64",       /* name */
 843          FALSE,                 /* partial_inplace */
 844          0,                     /* src_mask */
 845          ONES (64),             /* dst_mask */
 846          TRUE),                 /* pcrel_offset */
 847
 848   /* 64-bit relocation to the symbol's procedure linkage table.  */
 849   HOWTO (R_PPC64_PLT64,         /* type */
 850          0,                     /* rightshift */
 851          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 852          64,                    /* bitsize */
 853          FALSE,                 /* pc_relative */
 854          0,                     /* bitpos */
 855          complain_overflow_dont, /* complain_on_overflow */
 856          ppc64_elf_unhandled_reloc, /* special_function */
 857          "R_PPC64_PLT64",       /* name */
 858          FALSE,                 /* partial_inplace */
 859          0,                     /* src_mask */
 860          ONES (64),             /* dst_mask */
 861          FALSE),                /* pcrel_offset */
 862
 863   /* 64-bit PC relative relocation to the symbol's procedure linkage
 864      table.  */
 865   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 866   HOWTO (R_PPC64_PLTREL64,      /* type */
 867          0,                     /* rightshift */
 868          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 869          64,                    /* bitsize */
 870          TRUE,                  /* pc_relative */
 871          0,                     /* bitpos */
 872          complain_overflow_dont, /* complain_on_overflow */
 873          ppc64_elf_unhandled_reloc, /* special_function */
 874          "R_PPC64_PLTREL64",    /* name */
 875          FALSE,                 /* partial_inplace */
 876          0,                     /* src_mask */
 877          ONES (64),             /* dst_mask */
 878          TRUE),                 /* pcrel_offset */
 879
 880   /* 16 bit TOC-relative relocation.  */
 881
 882   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 883   HOWTO (R_PPC64_TOC16,         /* type */
 884          0,                     /* rightshift */
 885          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 886          16,                    /* bitsize */
 887          FALSE,                 /* pc_relative */
 888          0,                     /* bitpos */
 889          complain_overflow_signed, /* complain_on_overflow */
 890          ppc64_elf_toc_reloc,   /* special_function */
 891          "R_PPC64_TOC16",       /* name */
 892          FALSE,                 /* partial_inplace */
 893          0,                     /* src_mask */
 894          0xffff,                /* dst_mask */
 895          FALSE),                /* pcrel_offset */
 896
 897   /* 16 bit TOC-relative relocation without overflow.  */
 898
 899   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 900   HOWTO (R_PPC64_TOC16_LO,      /* type */
 901          0,                     /* rightshift */
 902          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 903          16,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          ppc64_elf_toc_reloc,   /* special_function */
 908          "R_PPC64_TOC16_LO",    /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          0xffff,                /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 16 bit TOC-relative relocation, high 16 bits.  */
 915
 916   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 917   HOWTO (R_PPC64_TOC16_HI,      /* type */
 918          16,                    /* rightshift */
 919          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 920          16,                    /* bitsize */
 921          FALSE,                 /* pc_relative */
 922          0,                     /* bitpos */
 923          complain_overflow_dont, /* complain_on_overflow */
 924          ppc64_elf_toc_reloc,   /* special_function */
 925          "R_PPC64_TOC16_HI",    /* name */
 926          FALSE,                 /* partial_inplace */
 927          0,                     /* src_mask */
 928          0xffff,                /* dst_mask */
 929          FALSE),                /* pcrel_offset */
 930
 931   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 932      contents of the low 16 bits, treated as a signed number, is
 933      negative.  */
 934
 935   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 936   HOWTO (R_PPC64_TOC16_HA,      /* type */
 937          16,                    /* rightshift */
 938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 939          16,                    /* bitsize */
 940          FALSE,                 /* pc_relative */
 941          0,                     /* bitpos */
 942          complain_overflow_dont, /* complain_on_overflow */
 943          ppc64_elf_toc_ha_reloc, /* special_function */
 944          "R_PPC64_TOC16_HA",    /* name */
 945          FALSE,                 /* partial_inplace */
 946          0,                     /* src_mask */
 947          0xffff,                /* dst_mask */
 948          FALSE),                /* pcrel_offset */
 949
 950   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 951
 952   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 953   HOWTO (R_PPC64_TOC,           /* type */
 954          0,                     /* rightshift */
 955          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 956          64,                    /* bitsize */
 957          FALSE,                 /* pc_relative */
 958          0,                     /* bitpos */
 959          complain_overflow_bitfield, /* complain_on_overflow */
 960          ppc64_elf_toc64_reloc, /* special_function */
 961          "R_PPC64_TOC",         /* name */
 962          FALSE,                 /* partial_inplace */
 963          0,                     /* src_mask */
 964          ONES (64),             /* dst_mask */
 965          FALSE),                /* pcrel_offset */
 966
 967   /* Like R_PPC64_GOT16, but also informs the link editor that the
 968      value to relocate may (!) refer to a PLT entry which the link
 969      editor (a) may replace with the symbol value.  If the link editor
 970      is unable to fully resolve the symbol, it may (b) create a PLT
 971      entry and store the address to the new PLT entry in the GOT.
 972      This permits lazy resolution of function symbols at run time.
 973      The link editor may also skip all of this and just (c) emit a
 974      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
 975   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
 976     HOWTO (R_PPC64_PLTGOT16,    /* type */
 977          0,                     /* rightshift */
 978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 979          16,                    /* bitsize */
 980          FALSE,                 /* pc_relative */
 981          0,                     /* bitpos */
 982          complain_overflow_signed, /* complain_on_overflow */
 983          ppc64_elf_unhandled_reloc, /* special_function */
 984          "R_PPC64_PLTGOT16",    /* name */
 985          FALSE,                 /* partial_inplace */
 986          0,                     /* src_mask */
 987          0xffff,                /* dst_mask */
 988          FALSE),                /* pcrel_offset */
 989
 990   /* Like R_PPC64_PLTGOT16, but without overflow.  */
 991   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
 992   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
 993          0,                     /* rightshift */
 994          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 995          16,                    /* bitsize */
 996          FALSE,                 /* pc_relative */
 997          0,                     /* bitpos */
 998          complain_overflow_dont, /* complain_on_overflow */
 999          ppc64_elf_unhandled_reloc, /* special_function */
1000          "R_PPC64_PLTGOT16_LO", /* name */
1001          FALSE,                 /* partial_inplace */
1002          0,                     /* src_mask */
1003          0xffff,                /* dst_mask */
1004          FALSE),                /* pcrel_offset */
1005
1006   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1007   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1008   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1009          16,                    /* rightshift */
1010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1011          16,                    /* bitsize */
1012          FALSE,                 /* pc_relative */
1013          0,                     /* bitpos */
1014          complain_overflow_dont, /* complain_on_overflow */
1015          ppc64_elf_unhandled_reloc, /* special_function */
1016          "R_PPC64_PLTGOT16_HI", /* name */
1017          FALSE,                 /* partial_inplace */
1018          0,                     /* src_mask */
1019          0xffff,                /* dst_mask */
1020          FALSE),                /* pcrel_offset */
1021
1022   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1023      1 if the contents of the low 16 bits, treated as a signed number,
1024      is negative.  */
1025   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1026   HOWTO (R_PPC64_PLTGOT16_HA,   /* 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_HA", /* name */
1035          FALSE,                 /* partial_inplace */
1036          0,                     /* src_mask */
1037          0xffff,                /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1041   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1042          0,                     /* rightshift */
1043          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1044          16,                    /* bitsize */
1045          FALSE,                 /* pc_relative */
1046          0,                     /* bitpos */
1047          complain_overflow_bitfield, /* complain_on_overflow */
1048          bfd_elf_generic_reloc, /* special_function */
1049          "R_PPC64_ADDR16_DS",   /* name */
1050          FALSE,                 /* partial_inplace */
1051          0,                     /* src_mask */
1052          0xfffc,                /* dst_mask */
1053          FALSE),                /* pcrel_offset */
1054
1055   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1056   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1057          0,                     /* rightshift */
1058          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1059          16,                    /* bitsize */
1060          FALSE,                 /* pc_relative */
1061          0,                     /* bitpos */
1062          complain_overflow_dont,/* complain_on_overflow */
1063          bfd_elf_generic_reloc, /* special_function */
1064          "R_PPC64_ADDR16_LO_DS",/* name */
1065          FALSE,                 /* partial_inplace */
1066          0,                     /* src_mask */
1067          0xfffc,                /* dst_mask */
1068          FALSE),                /* pcrel_offset */
1069
1070   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1071   HOWTO (R_PPC64_GOT16_DS,      /* type */
1072          0,                     /* rightshift */
1073          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1074          16,                    /* bitsize */
1075          FALSE,                 /* pc_relative */
1076          0,                     /* bitpos */
1077          complain_overflow_signed, /* complain_on_overflow */
1078          ppc64_elf_unhandled_reloc, /* special_function */
1079          "R_PPC64_GOT16_DS",    /* name */
1080          FALSE,                 /* partial_inplace */
1081          0,                     /* src_mask */
1082          0xfffc,                /* dst_mask */
1083          FALSE),                /* pcrel_offset */
1084
1085   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1086   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1087          0,                     /* rightshift */
1088          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1089          16,                    /* bitsize */
1090          FALSE,                 /* pc_relative */
1091          0,                     /* bitpos */
1092          complain_overflow_dont, /* complain_on_overflow */
1093          ppc64_elf_unhandled_reloc, /* special_function */
1094          "R_PPC64_GOT16_LO_DS", /* name */
1095          FALSE,                 /* partial_inplace */
1096          0,                     /* src_mask */
1097          0xfffc,                /* dst_mask */
1098          FALSE),                /* pcrel_offset */
1099
1100   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1101   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1102          0,                     /* rightshift */
1103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1104          16,                    /* bitsize */
1105          FALSE,                 /* pc_relative */
1106          0,                     /* bitpos */
1107          complain_overflow_dont, /* complain_on_overflow */
1108          ppc64_elf_unhandled_reloc, /* special_function */
1109          "R_PPC64_PLT16_LO_DS", /* name */
1110          FALSE,                 /* partial_inplace */
1111          0,                     /* src_mask */
1112          0xfffc,                /* dst_mask */
1113          FALSE),                /* pcrel_offset */
1114
1115   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1116   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1117          0,                     /* rightshift */
1118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1119          16,                    /* bitsize */
1120          FALSE,                 /* pc_relative */
1121          0,                     /* bitpos */
1122          complain_overflow_bitfield, /* complain_on_overflow */
1123          ppc64_elf_sectoff_reloc, /* special_function */
1124          "R_PPC64_SECTOFF_DS",  /* name */
1125          FALSE,                 /* partial_inplace */
1126          0,                     /* src_mask */
1127          0xfffc,                /* dst_mask */
1128          FALSE),                /* pcrel_offset */
1129
1130   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1132          0,                     /* rightshift */
1133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          16,                    /* bitsize */
1135          FALSE,                 /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_dont, /* complain_on_overflow */
1138          ppc64_elf_sectoff_reloc, /* special_function */
1139          "R_PPC64_SECTOFF_LO_DS",/* name */
1140          FALSE,                 /* partial_inplace */
1141          0,                     /* src_mask */
1142          0xfffc,                /* dst_mask */
1143          FALSE),                /* pcrel_offset */
1144
1145   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_TOC16_DS,      /* type */
1147          0,                     /* rightshift */
1148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1149          16,                    /* bitsize */
1150          FALSE,                 /* pc_relative */
1151          0,                     /* bitpos */
1152          complain_overflow_signed, /* complain_on_overflow */
1153          ppc64_elf_toc_reloc,   /* special_function */
1154          "R_PPC64_TOC16_DS",    /* name */
1155          FALSE,                 /* partial_inplace */
1156          0,                     /* src_mask */
1157          0xfffc,                /* dst_mask */
1158          FALSE),                /* pcrel_offset */
1159
1160   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1162          0,                     /* rightshift */
1163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          16,                    /* bitsize */
1165          FALSE,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_dont, /* complain_on_overflow */
1168          ppc64_elf_toc_reloc,   /* special_function */
1169          "R_PPC64_TOC16_LO_DS", /* name */
1170          FALSE,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xfffc,                /* dst_mask */
1173          FALSE),                /* pcrel_offset */
1174
1175   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1176   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1177     HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1178          0,                     /* rightshift */
1179          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1180          16,                    /* bitsize */
1181          FALSE,                 /* pc_relative */
1182          0,                     /* bitpos */
1183          complain_overflow_signed, /* complain_on_overflow */
1184          ppc64_elf_unhandled_reloc, /* special_function */
1185          "R_PPC64_PLTGOT16_DS", /* name */
1186          FALSE,                 /* partial_inplace */
1187          0,                     /* src_mask */
1188          0xfffc,                /* dst_mask */
1189          FALSE),                /* pcrel_offset */
1190
1191   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1192   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1193   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1194          0,                     /* rightshift */
1195          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          16,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_dont, /* complain_on_overflow */
1200          ppc64_elf_unhandled_reloc, /* special_function */
1201          "R_PPC64_PLTGOT16_LO_DS",/* name */
1202          FALSE,                 /* partial_inplace */
1203          0,                     /* src_mask */
1204          0xfffc,                /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Marker reloc for TLS.  */
1208   HOWTO (R_PPC64_TLS,
1209          0,                     /* rightshift */
1210          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1211          32,                    /* bitsize */
1212          FALSE,                 /* pc_relative */
1213          0,                     /* bitpos */
1214          complain_overflow_dont, /* complain_on_overflow */
1215          bfd_elf_generic_reloc, /* special_function */
1216          "R_PPC64_TLS",         /* name */
1217          FALSE,                 /* partial_inplace */
1218          0,                     /* src_mask */
1219          0,                     /* dst_mask */
1220          FALSE),                /* pcrel_offset */
1221
1222   /* Computes the load module index of the load module that contains the
1223      definition of its TLS sym.  */
1224   HOWTO (R_PPC64_DTPMOD64,
1225          0,                     /* rightshift */
1226          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1227          64,                    /* bitsize */
1228          FALSE,                 /* pc_relative */
1229          0,                     /* bitpos */
1230          complain_overflow_dont, /* complain_on_overflow */
1231          ppc64_elf_unhandled_reloc, /* special_function */
1232          "R_PPC64_DTPMOD64",    /* name */
1233          FALSE,                 /* partial_inplace */
1234          0,                     /* src_mask */
1235          ONES (64),             /* dst_mask */
1236          FALSE),                /* pcrel_offset */
1237
1238   /* Computes a dtv-relative displacement, the difference between the value
1239      of sym+add and the base address of the thread-local storage block that
1240      contains the definition of sym, minus 0x8000.  */
1241   HOWTO (R_PPC64_DTPREL64,
1242          0,                     /* rightshift */
1243          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1244          64,                    /* bitsize */
1245          FALSE,                 /* pc_relative */
1246          0,                     /* bitpos */
1247          complain_overflow_dont, /* complain_on_overflow */
1248          ppc64_elf_unhandled_reloc, /* special_function */
1249          "R_PPC64_DTPREL64",    /* name */
1250          FALSE,                 /* partial_inplace */
1251          0,                     /* src_mask */
1252          ONES (64),             /* dst_mask */
1253          FALSE),                /* pcrel_offset */
1254
1255   /* A 16 bit dtprel reloc.  */
1256   HOWTO (R_PPC64_DTPREL16,
1257          0,                     /* rightshift */
1258          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1259          16,                    /* bitsize */
1260          FALSE,                 /* pc_relative */
1261          0,                     /* bitpos */
1262          complain_overflow_signed, /* complain_on_overflow */
1263          ppc64_elf_unhandled_reloc, /* special_function */
1264          "R_PPC64_DTPREL16",    /* name */
1265          FALSE,                 /* partial_inplace */
1266          0,                     /* src_mask */
1267          0xffff,                /* dst_mask */
1268          FALSE),                /* pcrel_offset */
1269
1270   /* Like DTPREL16, but no overflow.  */
1271   HOWTO (R_PPC64_DTPREL16_LO,
1272          0,                     /* rightshift */
1273          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1274          16,                    /* bitsize */
1275          FALSE,                 /* pc_relative */
1276          0,                     /* bitpos */
1277          complain_overflow_dont, /* complain_on_overflow */
1278          ppc64_elf_unhandled_reloc, /* special_function */
1279          "R_PPC64_DTPREL16_LO", /* name */
1280          FALSE,                 /* partial_inplace */
1281          0,                     /* src_mask */
1282          0xffff,                /* dst_mask */
1283          FALSE),                /* pcrel_offset */
1284
1285   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1286   HOWTO (R_PPC64_DTPREL16_HI,
1287          16,                    /* rightshift */
1288          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1289          16,                    /* bitsize */
1290          FALSE,                 /* pc_relative */
1291          0,                     /* bitpos */
1292          complain_overflow_dont, /* complain_on_overflow */
1293          ppc64_elf_unhandled_reloc, /* special_function */
1294          "R_PPC64_DTPREL16_HI", /* name */
1295          FALSE,                 /* partial_inplace */
1296          0,                     /* src_mask */
1297          0xffff,                /* dst_mask */
1298          FALSE),                /* pcrel_offset */
1299
1300   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1301   HOWTO (R_PPC64_DTPREL16_HA,
1302          16,                    /* rightshift */
1303          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1304          16,                    /* bitsize */
1305          FALSE,                 /* pc_relative */
1306          0,                     /* bitpos */
1307          complain_overflow_dont, /* complain_on_overflow */
1308          ppc64_elf_unhandled_reloc, /* special_function */
1309          "R_PPC64_DTPREL16_HA", /* name */
1310          FALSE,                 /* partial_inplace */
1311          0,                     /* src_mask */
1312          0xffff,                /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1316   HOWTO (R_PPC64_DTPREL16_HIGHER,
1317          32,                    /* rightshift */
1318          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1319          16,                    /* bitsize */
1320          FALSE,                 /* pc_relative */
1321          0,                     /* bitpos */
1322          complain_overflow_dont, /* complain_on_overflow */
1323          ppc64_elf_unhandled_reloc, /* special_function */
1324          "R_PPC64_DTPREL16_HIGHER", /* name */
1325          FALSE,                 /* partial_inplace */
1326          0,                     /* src_mask */
1327          0xffff,                /* dst_mask */
1328          FALSE),                /* pcrel_offset */
1329
1330   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1331   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1332          32,                    /* rightshift */
1333          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          16,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          ppc64_elf_unhandled_reloc, /* special_function */
1339          "R_PPC64_DTPREL16_HIGHERA", /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0xffff,                /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1346   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1347          48,                    /* rightshift */
1348          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1349          16,                    /* bitsize */
1350          FALSE,                 /* pc_relative */
1351          0,                     /* bitpos */
1352          complain_overflow_dont, /* complain_on_overflow */
1353          ppc64_elf_unhandled_reloc, /* special_function */
1354          "R_PPC64_DTPREL16_HIGHEST", /* name */
1355          FALSE,                 /* partial_inplace */
1356          0,                     /* src_mask */
1357          0xffff,                /* dst_mask */
1358          FALSE),                /* pcrel_offset */
1359
1360   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1361   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1362          48,                    /* rightshift */
1363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1364          16,                    /* bitsize */
1365          FALSE,                 /* pc_relative */
1366          0,                     /* bitpos */
1367          complain_overflow_dont, /* complain_on_overflow */
1368          ppc64_elf_unhandled_reloc, /* special_function */
1369          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1370          FALSE,                 /* partial_inplace */
1371          0,                     /* src_mask */
1372          0xffff,                /* dst_mask */
1373          FALSE),                /* pcrel_offset */
1374
1375   /* Like DTPREL16, but for insns with a DS field.  */
1376   HOWTO (R_PPC64_DTPREL16_DS,
1377          0,                     /* rightshift */
1378          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1379          16,                    /* bitsize */
1380          FALSE,                 /* pc_relative */
1381          0,                     /* bitpos */
1382          complain_overflow_signed, /* complain_on_overflow */
1383          ppc64_elf_unhandled_reloc, /* special_function */
1384          "R_PPC64_DTPREL16_DS", /* name */
1385          FALSE,                 /* partial_inplace */
1386          0,                     /* src_mask */
1387          0xfffc,                /* dst_mask */
1388          FALSE),                /* pcrel_offset */
1389
1390   /* Like DTPREL16_DS, but no overflow.  */
1391   HOWTO (R_PPC64_DTPREL16_LO_DS,
1392          0,                     /* rightshift */
1393          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1394          16,                    /* bitsize */
1395          FALSE,                 /* pc_relative */
1396          0,                     /* bitpos */
1397          complain_overflow_dont, /* complain_on_overflow */
1398          ppc64_elf_unhandled_reloc, /* special_function */
1399          "R_PPC64_DTPREL16_LO_DS", /* name */
1400          FALSE,                 /* partial_inplace */
1401          0,                     /* src_mask */
1402          0xfffc,                /* dst_mask */
1403          FALSE),                /* pcrel_offset */
1404
1405   /* Computes a tp-relative displacement, the difference between the value of
1406      sym+add and the value of the thread pointer (r13).  */
1407   HOWTO (R_PPC64_TPREL64,
1408          0,                     /* rightshift */
1409          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1410          64,                    /* bitsize */
1411          FALSE,                 /* pc_relative */
1412          0,                     /* bitpos */
1413          complain_overflow_dont, /* complain_on_overflow */
1414          ppc64_elf_unhandled_reloc, /* special_function */
1415          "R_PPC64_TPREL64",     /* name */
1416          FALSE,                 /* partial_inplace */
1417          0,                     /* src_mask */
1418          ONES (64),             /* dst_mask */
1419          FALSE),                /* pcrel_offset */
1420
1421   /* A 16 bit tprel reloc.  */
1422   HOWTO (R_PPC64_TPREL16,
1423          0,                     /* rightshift */
1424          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1425          16,                    /* bitsize */
1426          FALSE,                 /* pc_relative */
1427          0,                     /* bitpos */
1428          complain_overflow_signed, /* complain_on_overflow */
1429          ppc64_elf_unhandled_reloc, /* special_function */
1430          "R_PPC64_TPREL16",     /* name */
1431          FALSE,                 /* partial_inplace */
1432          0,                     /* src_mask */
1433          0xffff,                /* dst_mask */
1434          FALSE),                /* pcrel_offset */
1435
1436   /* Like TPREL16, but no overflow.  */
1437   HOWTO (R_PPC64_TPREL16_LO,
1438          0,                     /* rightshift */
1439          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1440          16,                    /* bitsize */
1441          FALSE,                 /* pc_relative */
1442          0,                     /* bitpos */
1443          complain_overflow_dont, /* complain_on_overflow */
1444          ppc64_elf_unhandled_reloc, /* special_function */
1445          "R_PPC64_TPREL16_LO",  /* name */
1446          FALSE,                 /* partial_inplace */
1447          0,                     /* src_mask */
1448          0xffff,                /* dst_mask */
1449          FALSE),                /* pcrel_offset */
1450
1451   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1452   HOWTO (R_PPC64_TPREL16_HI,
1453          16,                    /* rightshift */
1454          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1455          16,                    /* bitsize */
1456          FALSE,                 /* pc_relative */
1457          0,                     /* bitpos */
1458          complain_overflow_dont, /* complain_on_overflow */
1459          ppc64_elf_unhandled_reloc, /* special_function */
1460          "R_PPC64_TPREL16_HI",  /* name */
1461          FALSE,                 /* partial_inplace */
1462          0,                     /* src_mask */
1463          0xffff,                /* dst_mask */
1464          FALSE),                /* pcrel_offset */
1465
1466   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1467   HOWTO (R_PPC64_TPREL16_HA,
1468          16,                    /* rightshift */
1469          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1470          16,                    /* bitsize */
1471          FALSE,                 /* pc_relative */
1472          0,                     /* bitpos */
1473          complain_overflow_dont, /* complain_on_overflow */
1474          ppc64_elf_unhandled_reloc, /* special_function */
1475          "R_PPC64_TPREL16_HA",  /* name */
1476          FALSE,                 /* partial_inplace */
1477          0,                     /* src_mask */
1478          0xffff,                /* dst_mask */
1479          FALSE),                /* pcrel_offset */
1480
1481   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1482   HOWTO (R_PPC64_TPREL16_HIGHER,
1483          32,                    /* rightshift */
1484          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1485          16,                    /* bitsize */
1486          FALSE,                 /* pc_relative */
1487          0,                     /* bitpos */
1488          complain_overflow_dont, /* complain_on_overflow */
1489          ppc64_elf_unhandled_reloc, /* special_function */
1490          "R_PPC64_TPREL16_HIGHER",      /* name */
1491          FALSE,                 /* partial_inplace */
1492          0,                     /* src_mask */
1493          0xffff,                /* dst_mask */
1494          FALSE),                /* pcrel_offset */
1495
1496   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1497   HOWTO (R_PPC64_TPREL16_HIGHERA,
1498          32,                    /* rightshift */
1499          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1500          16,                    /* bitsize */
1501          FALSE,                 /* pc_relative */
1502          0,                     /* bitpos */
1503          complain_overflow_dont, /* complain_on_overflow */
1504          ppc64_elf_unhandled_reloc, /* special_function */
1505          "R_PPC64_TPREL16_HIGHERA", /* name */
1506          FALSE,                 /* partial_inplace */
1507          0,                     /* src_mask */
1508          0xffff,                /* dst_mask */
1509          FALSE),                /* pcrel_offset */
1510
1511   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1512   HOWTO (R_PPC64_TPREL16_HIGHEST,
1513          48,                    /* rightshift */
1514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1515          16,                    /* bitsize */
1516          FALSE,                 /* pc_relative */
1517          0,                     /* bitpos */
1518          complain_overflow_dont, /* complain_on_overflow */
1519          ppc64_elf_unhandled_reloc, /* special_function */
1520          "R_PPC64_TPREL16_HIGHEST", /* name */
1521          FALSE,                 /* partial_inplace */
1522          0,                     /* src_mask */
1523          0xffff,                /* dst_mask */
1524          FALSE),                /* pcrel_offset */
1525
1526   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1527   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1528          48,                    /* rightshift */
1529          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1530          16,                    /* bitsize */
1531          FALSE,                 /* pc_relative */
1532          0,                     /* bitpos */
1533          complain_overflow_dont, /* complain_on_overflow */
1534          ppc64_elf_unhandled_reloc, /* special_function */
1535          "R_PPC64_TPREL16_HIGHESTA", /* name */
1536          FALSE,                 /* partial_inplace */
1537          0,                     /* src_mask */
1538          0xffff,                /* dst_mask */
1539          FALSE),                /* pcrel_offset */
1540
1541   /* Like TPREL16, but for insns with a DS field.  */
1542   HOWTO (R_PPC64_TPREL16_DS,
1543          0,                     /* rightshift */
1544          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1545          16,                    /* bitsize */
1546          FALSE,                 /* pc_relative */
1547          0,                     /* bitpos */
1548          complain_overflow_signed, /* complain_on_overflow */
1549          ppc64_elf_unhandled_reloc, /* special_function */
1550          "R_PPC64_TPREL16_DS",  /* name */
1551          FALSE,                 /* partial_inplace */
1552          0,                     /* src_mask */
1553          0xfffc,                /* dst_mask */
1554          FALSE),                /* pcrel_offset */
1555
1556   /* Like TPREL16_DS, but no overflow.  */
1557   HOWTO (R_PPC64_TPREL16_LO_DS,
1558          0,                     /* rightshift */
1559          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1560          16,                    /* bitsize */
1561          FALSE,                 /* pc_relative */
1562          0,                     /* bitpos */
1563          complain_overflow_dont, /* complain_on_overflow */
1564          ppc64_elf_unhandled_reloc, /* special_function */
1565          "R_PPC64_TPREL16_LO_DS", /* name */
1566          FALSE,                 /* partial_inplace */
1567          0,                     /* src_mask */
1568          0xfffc,                /* dst_mask */
1569          FALSE),                /* pcrel_offset */
1570
1571   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1572      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1573      to the first entry relative to the TOC base (r2).  */
1574   HOWTO (R_PPC64_GOT_TLSGD16,
1575          0,                     /* rightshift */
1576          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1577          16,                    /* bitsize */
1578          FALSE,                 /* pc_relative */
1579          0,                     /* bitpos */
1580          complain_overflow_signed, /* complain_on_overflow */
1581          ppc64_elf_unhandled_reloc, /* special_function */
1582          "R_PPC64_GOT_TLSGD16", /* name */
1583          FALSE,                 /* partial_inplace */
1584          0,                     /* src_mask */
1585          0xffff,                /* dst_mask */
1586          FALSE),                /* pcrel_offset */
1587
1588   /* Like GOT_TLSGD16, but no overflow.  */
1589   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1590          0,                     /* rightshift */
1591          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1592          16,                    /* bitsize */
1593          FALSE,                 /* pc_relative */
1594          0,                     /* bitpos */
1595          complain_overflow_dont, /* complain_on_overflow */
1596          ppc64_elf_unhandled_reloc, /* special_function */
1597          "R_PPC64_GOT_TLSGD16_LO", /* name */
1598          FALSE,                 /* partial_inplace */
1599          0,                     /* src_mask */
1600          0xffff,                /* dst_mask */
1601          FALSE),                /* pcrel_offset */
1602
1603   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1604   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1605          16,                    /* rightshift */
1606          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1607          16,                    /* bitsize */
1608          FALSE,                 /* pc_relative */
1609          0,                     /* bitpos */
1610          complain_overflow_dont, /* complain_on_overflow */
1611          ppc64_elf_unhandled_reloc, /* special_function */
1612          "R_PPC64_GOT_TLSGD16_HI", /* name */
1613          FALSE,                 /* partial_inplace */
1614          0,                     /* src_mask */
1615          0xffff,                /* dst_mask */
1616          FALSE),                /* pcrel_offset */
1617
1618   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1619   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1620          16,                    /* rightshift */
1621          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1622          16,                    /* bitsize */
1623          FALSE,                 /* pc_relative */
1624          0,                     /* bitpos */
1625          complain_overflow_dont, /* complain_on_overflow */
1626          ppc64_elf_unhandled_reloc, /* special_function */
1627          "R_PPC64_GOT_TLSGD16_HA", /* name */
1628          FALSE,                 /* partial_inplace */
1629          0,                     /* src_mask */
1630          0xffff,                /* dst_mask */
1631          FALSE),                /* pcrel_offset */
1632
1633   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1634      with values (sym+add)@dtpmod and zero, and computes the offset to the
1635      first entry relative to the TOC base (r2).  */
1636   HOWTO (R_PPC64_GOT_TLSLD16,
1637          0,                     /* rightshift */
1638          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1639          16,                    /* bitsize */
1640          FALSE,                 /* pc_relative */
1641          0,                     /* bitpos */
1642          complain_overflow_signed, /* complain_on_overflow */
1643          ppc64_elf_unhandled_reloc, /* special_function */
1644          "R_PPC64_GOT_TLSLD16", /* name */
1645          FALSE,                 /* partial_inplace */
1646          0,                     /* src_mask */
1647          0xffff,                /* dst_mask */
1648          FALSE),                /* pcrel_offset */
1649
1650   /* Like GOT_TLSLD16, but no overflow.  */
1651   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1652          0,                     /* rightshift */
1653          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1654          16,                    /* bitsize */
1655          FALSE,                 /* pc_relative */
1656          0,                     /* bitpos */
1657          complain_overflow_dont, /* complain_on_overflow */
1658          ppc64_elf_unhandled_reloc, /* special_function */
1659          "R_PPC64_GOT_TLSLD16_LO", /* name */
1660          FALSE,                 /* partial_inplace */
1661          0,                     /* src_mask */
1662          0xffff,                /* dst_mask */
1663          FALSE),                /* pcrel_offset */
1664
1665   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1666   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1667          16,                    /* rightshift */
1668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1669          16,                    /* bitsize */
1670          FALSE,                 /* pc_relative */
1671          0,                     /* bitpos */
1672          complain_overflow_dont, /* complain_on_overflow */
1673          ppc64_elf_unhandled_reloc, /* special_function */
1674          "R_PPC64_GOT_TLSLD16_HI", /* name */
1675          FALSE,                 /* partial_inplace */
1676          0,                     /* src_mask */
1677          0xffff,                /* dst_mask */
1678          FALSE),                /* pcrel_offset */
1679
1680   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1681   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1682          16,                    /* rightshift */
1683          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1684          16,                    /* bitsize */
1685          FALSE,                 /* pc_relative */
1686          0,                     /* bitpos */
1687          complain_overflow_dont, /* complain_on_overflow */
1688          ppc64_elf_unhandled_reloc, /* special_function */
1689          "R_PPC64_GOT_TLSLD16_HA", /* name */
1690          FALSE,                 /* partial_inplace */
1691          0,                     /* src_mask */
1692          0xffff,                /* dst_mask */
1693          FALSE),                /* pcrel_offset */
1694
1695   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1696      the offset to the entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_DTPREL16_DS", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xfffc,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_DTPREL16_DS, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xfffc,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_dont, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_DTPREL16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_dont, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_DTPREL16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1757      offset to the entry relative to the TOC base (r2).  */
1758   HOWTO (R_PPC64_GOT_TPREL16_DS,
1759          0,                     /* rightshift */
1760          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1761          16,                    /* bitsize */
1762          FALSE,                 /* pc_relative */
1763          0,                     /* bitpos */
1764          complain_overflow_signed, /* complain_on_overflow */
1765          ppc64_elf_unhandled_reloc, /* special_function */
1766          "R_PPC64_GOT_TPREL16_DS", /* name */
1767          FALSE,                 /* partial_inplace */
1768          0,                     /* src_mask */
1769          0xfffc,                /* dst_mask */
1770          FALSE),                /* pcrel_offset */
1771
1772   /* Like GOT_TPREL16_DS, but no overflow.  */
1773   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1774          0,                     /* rightshift */
1775          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1776          16,                    /* bitsize */
1777          FALSE,                 /* pc_relative */
1778          0,                     /* bitpos */
1779          complain_overflow_dont, /* complain_on_overflow */
1780          ppc64_elf_unhandled_reloc, /* special_function */
1781          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1782          FALSE,                 /* partial_inplace */
1783          0,                     /* src_mask */
1784          0xfffc,                /* dst_mask */
1785          FALSE),                /* pcrel_offset */
1786
1787   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1788   HOWTO (R_PPC64_GOT_TPREL16_HI,
1789          16,                    /* rightshift */
1790          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1791          16,                    /* bitsize */
1792          FALSE,                 /* pc_relative */
1793          0,                     /* bitpos */
1794          complain_overflow_dont, /* complain_on_overflow */
1795          ppc64_elf_unhandled_reloc, /* special_function */
1796          "R_PPC64_GOT_TPREL16_HI", /* name */
1797          FALSE,                 /* partial_inplace */
1798          0,                     /* src_mask */
1799          0xffff,                /* dst_mask */
1800          FALSE),                /* pcrel_offset */
1801
1802   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1803   HOWTO (R_PPC64_GOT_TPREL16_HA,
1804          16,                    /* rightshift */
1805          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1806          16,                    /* bitsize */
1807          FALSE,                 /* pc_relative */
1808          0,                     /* bitpos */
1809          complain_overflow_dont, /* complain_on_overflow */
1810          ppc64_elf_unhandled_reloc, /* special_function */
1811          "R_PPC64_GOT_TPREL16_HA", /* name */
1812          FALSE,                 /* partial_inplace */
1813          0,                     /* src_mask */
1814          0xffff,                /* dst_mask */
1815          FALSE),                /* pcrel_offset */
1816
1817   /* GNU extension to record C++ vtable hierarchy.  */
1818   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1819          0,                     /* rightshift */
1820          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1821          0,                     /* bitsize */
1822          FALSE,                 /* pc_relative */
1823          0,                     /* bitpos */
1824          complain_overflow_dont, /* complain_on_overflow */
1825          NULL,                  /* special_function */
1826          "R_PPC64_GNU_VTINHERIT", /* name */
1827          FALSE,                 /* partial_inplace */
1828          0,                     /* src_mask */
1829          0,                     /* dst_mask */
1830          FALSE),                /* pcrel_offset */
1831
1832   /* GNU extension to record C++ vtable member usage.  */
1833   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1834          0,                     /* rightshift */
1835          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1836          0,                     /* bitsize */
1837          FALSE,                 /* pc_relative */
1838          0,                     /* bitpos */
1839          complain_overflow_dont, /* complain_on_overflow */
1840          NULL,                  /* special_function */
1841          "R_PPC64_GNU_VTENTRY", /* name */
1842          FALSE,                 /* partial_inplace */
1843          0,                     /* src_mask */
1844          0,                     /* dst_mask */
1845          FALSE),                /* pcrel_offset */
1846 };
1847
1848 \f
1849 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1850    be done.  */
1851
1852 static void
1853 ppc_howto_init (void)
1854 {
1855   unsigned int i, type;
1856
1857   for (i = 0;
1858        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1859        i++)
1860     {
1861       type = ppc64_elf_howto_raw[i].type;
1862       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1863                           / sizeof (ppc64_elf_howto_table[0])));
1864       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1865     }
1866 }
1867
1868 static reloc_howto_type *
1869 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1870                              bfd_reloc_code_real_type code)
1871 {
1872   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1873
1874   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1875     /* Initialize howto table if needed.  */
1876     ppc_howto_init ();
1877
1878   switch (code)
1879     {
1880     default:
1881       return NULL;
1882
1883     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
1884       break;
1885     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
1886       break;
1887     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
1888       break;
1889     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
1890       break;
1891     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
1892       break;
1893     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
1894       break;
1895     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
1896       break;
1897     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
1898       break;
1899     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
1900       break;
1901     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
1902       break;
1903     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
1904       break;
1905     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
1906       break;
1907     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
1908       break;
1909     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
1910       break;
1911     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
1912       break;
1913     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
1914       break;
1915     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
1916       break;
1917     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
1918       break;
1919     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
1920       break;
1921     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
1922       break;
1923     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
1924       break;
1925     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
1926       break;
1927     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
1928       break;
1929     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
1930       break;
1931     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
1932       break;
1933     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
1934       break;
1935     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
1936       break;
1937     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
1938       break;
1939     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
1940       break;
1941     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
1942       break;
1943     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
1944       break;
1945     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
1946       break;
1947     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
1948       break;
1949     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
1950       break;
1951     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
1952       break;
1953     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
1954       break;
1955     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
1956       break;
1957     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
1958       break;
1959     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
1960       break;
1961     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
1962       break;
1963     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
1964       break;
1965     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
1966       break;
1967     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
1968       break;
1969     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
1970       break;
1971     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
1972       break;
1973     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
1974       break;
1975     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
1976       break;
1977     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
1978       break;
1979     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
1980       break;
1981     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
1982       break;
1983     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
1984       break;
1985     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
1986       break;
1987     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
1988       break;
1989     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
1990       break;
1991     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
1992       break;
1993     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
1994       break;
1995     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
1996       break;
1997     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
1998       break;
1999     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2000       break;
2001     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2002       break;
2003     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2004       break;
2005     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2006       break;
2007     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2008       break;
2009     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2010       break;
2011     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2012       break;
2013     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2014       break;
2015     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2016       break;
2017     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2018       break;
2019     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2020       break;
2021     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2022       break;
2023     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2024       break;
2025     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2026       break;
2027     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2028       break;
2029     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2030       break;
2031     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2032       break;
2033     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2034       break;
2035     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2036       break;
2037     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2038       break;
2039     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2040       break;
2041     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2042       break;
2043     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2044       break;
2045     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2046       break;
2047     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2048       break;
2049     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2050       break;
2051     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2052       break;
2053     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2054       break;
2055     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2056       break;
2057     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2058       break;
2059     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2060       break;
2061     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2062       break;
2063     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2064       break;
2065     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2066       break;
2067     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2068       break;
2069     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2070       break;
2071     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2072       break;
2073     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2074       break;
2075     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2076       break;
2077     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2078       break;
2079     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2080       break;
2081     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2082       break;
2083     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2084       break;
2085     }
2086
2087   return ppc64_elf_howto_table[r];
2088 };
2089
2090 /* Set the howto pointer for a PowerPC ELF reloc.  */
2091
2092 static void
2093 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2094                          Elf_Internal_Rela *dst)
2095 {
2096   unsigned int type;
2097
2098   /* Initialize howto table if needed.  */
2099   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2100     ppc_howto_init ();
2101
2102   type = ELF64_R_TYPE (dst->r_info);
2103   BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2104                       / sizeof (ppc64_elf_howto_table[0])));
2105   cache_ptr->howto = ppc64_elf_howto_table[type];
2106 }
2107
2108 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2109
2110 static bfd_reloc_status_type
2111 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2112                     void *data, asection *input_section,
2113                     bfd *output_bfd, char **error_message)
2114 {
2115   /* If this is a relocatable link (output_bfd test tells us), just
2116      call the generic function.  Any adjustment will be done at final
2117      link time.  */
2118   if (output_bfd != NULL)
2119     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2120                                   input_section, output_bfd, error_message);
2121
2122   /* Adjust the addend for sign extension of the low 16 bits.
2123      We won't actually be using the low 16 bits, so trashing them
2124      doesn't matter.  */
2125   reloc_entry->addend += 0x8000;
2126   return bfd_reloc_continue;
2127 }
2128
2129 static bfd_reloc_status_type
2130 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2131                          void *data, asection *input_section,
2132                          bfd *output_bfd, char **error_message)
2133 {
2134   long insn;
2135   enum elf_ppc64_reloc_type r_type;
2136   bfd_size_type octets;
2137   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2138   bfd_boolean is_power4 = FALSE;
2139
2140   /* If this is a relocatable link (output_bfd test tells us), just
2141      call the generic function.  Any adjustment will be done at final
2142      link time.  */
2143   if (output_bfd != NULL)
2144     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2145                                   input_section, output_bfd, error_message);
2146
2147   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2148   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2149   insn &= ~(0x01 << 21);
2150   r_type = reloc_entry->howto->type;
2151   if (r_type == R_PPC64_ADDR14_BRTAKEN
2152       || r_type == R_PPC64_REL14_BRTAKEN)
2153     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2154
2155   if (is_power4)
2156     {
2157       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2158          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2159          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2160       if ((insn & (0x14 << 21)) == (0x04 << 21))
2161         insn |= 0x02 << 21;
2162       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2163         insn |= 0x08 << 21;
2164       else
2165         return bfd_reloc_continue;
2166     }
2167   else
2168     {
2169       bfd_vma target = 0;
2170       bfd_vma from;
2171
2172       if (!bfd_is_com_section (symbol->section))
2173         target = symbol->value;
2174       target += symbol->section->output_section->vma;
2175       target += symbol->section->output_offset;
2176       target += reloc_entry->addend;
2177
2178       from = (reloc_entry->address
2179               + input_section->output_offset
2180               + input_section->output_section->vma);
2181
2182       /* Invert 'y' bit if not the default.  */
2183       if ((bfd_signed_vma) (target - from) < 0)
2184         insn ^= 0x01 << 21;
2185     }
2186   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2187   return bfd_reloc_continue;
2188 }
2189
2190 static bfd_reloc_status_type
2191 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2192                          void *data, asection *input_section,
2193                          bfd *output_bfd, char **error_message)
2194 {
2195   /* If this is a relocatable link (output_bfd test tells us), just
2196      call the generic function.  Any adjustment will be done at final
2197      link time.  */
2198   if (output_bfd != NULL)
2199     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2200                                   input_section, output_bfd, error_message);
2201
2202   /* Subtract the symbol section base address.  */
2203   reloc_entry->addend -= symbol->section->output_section->vma;
2204   return bfd_reloc_continue;
2205 }
2206
2207 static bfd_reloc_status_type
2208 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2209                             void *data, asection *input_section,
2210                             bfd *output_bfd, char **error_message)
2211 {
2212   /* If this is a relocatable link (output_bfd test tells us), just
2213      call the generic function.  Any adjustment will be done at final
2214      link time.  */
2215   if (output_bfd != NULL)
2216     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2217                                   input_section, output_bfd, error_message);
2218
2219   /* Subtract the symbol section base address.  */
2220   reloc_entry->addend -= symbol->section->output_section->vma;
2221
2222   /* Adjust the addend for sign extension of the low 16 bits.  */
2223   reloc_entry->addend += 0x8000;
2224   return bfd_reloc_continue;
2225 }
2226
2227 static bfd_reloc_status_type
2228 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2229                      void *data, asection *input_section,
2230                      bfd *output_bfd, char **error_message)
2231 {
2232   bfd_vma TOCstart;
2233
2234   /* If this is a relocatable link (output_bfd test tells us), just
2235      call the generic function.  Any adjustment will be done at final
2236      link time.  */
2237   if (output_bfd != NULL)
2238     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2239                                   input_section, output_bfd, error_message);
2240
2241   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2242   if (TOCstart == 0)
2243     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2244
2245   /* Subtract the TOC base address.  */
2246   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2247   return bfd_reloc_continue;
2248 }
2249
2250 static bfd_reloc_status_type
2251 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2252                         void *data, asection *input_section,
2253                         bfd *output_bfd, char **error_message)
2254 {
2255   bfd_vma TOCstart;
2256
2257   /* If this is a relocatable link (output_bfd test tells us), just
2258      call the generic function.  Any adjustment will be done at final
2259      link time.  */
2260   if (output_bfd != NULL)
2261     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2262                                   input_section, output_bfd, error_message);
2263
2264   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2265   if (TOCstart == 0)
2266     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2267
2268   /* Subtract the TOC base address.  */
2269   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2270
2271   /* Adjust the addend for sign extension of the low 16 bits.  */
2272   reloc_entry->addend += 0x8000;
2273   return bfd_reloc_continue;
2274 }
2275
2276 static bfd_reloc_status_type
2277 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2278                        void *data, asection *input_section,
2279                        bfd *output_bfd, char **error_message)
2280 {
2281   bfd_vma TOCstart;
2282   bfd_size_type octets;
2283
2284   /* If this is a relocatable link (output_bfd test tells us), just
2285      call the generic function.  Any adjustment will be done at final
2286      link time.  */
2287   if (output_bfd != NULL)
2288     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2289                                   input_section, output_bfd, error_message);
2290
2291   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2292   if (TOCstart == 0)
2293     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2294
2295   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2296   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2297   return bfd_reloc_ok;
2298 }
2299
2300 static bfd_reloc_status_type
2301 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2302                            void *data, asection *input_section,
2303                            bfd *output_bfd, char **error_message)
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   if (error_message != NULL)
2313     {
2314       static char buf[60];
2315       sprintf (buf, "generic linker can't handle %s",
2316                reloc_entry->howto->name);
2317       *error_message = buf;
2318     }
2319   return bfd_reloc_dangerous;
2320 }
2321
2322 struct ppc64_elf_obj_tdata
2323 {
2324   struct elf_obj_tdata elf;
2325
2326   /* Shortcuts to dynamic linker sections.  */
2327   asection *got;
2328   asection *relgot;
2329
2330   /* TLS local dynamic got entry handling.  Suppose for multiple GOT
2331      sections means we potentially need one of these for each input bfd.  */
2332   union {
2333     bfd_signed_vma refcount;
2334     bfd_vma offset;
2335   } tlsld_got;
2336 };
2337
2338 #define ppc64_elf_tdata(bfd) \
2339   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2340
2341 #define ppc64_tlsld_got(bfd) \
2342   (&ppc64_elf_tdata (bfd)->tlsld_got)
2343
2344 /* Override the generic function because we store some extras.  */
2345
2346 static bfd_boolean
2347 ppc64_elf_mkobject (bfd *abfd)
2348 {
2349   bfd_size_type amt = sizeof (struct ppc64_elf_obj_tdata);
2350   abfd->tdata.any = bfd_zalloc (abfd, amt);
2351   if (abfd->tdata.any == NULL)
2352     return FALSE;
2353   return TRUE;
2354 }
2355
2356 /* Fix bad default arch selected for a 64 bit input bfd when the
2357    default is 32 bit.  */
2358
2359 static bfd_boolean
2360 ppc64_elf_object_p (bfd *abfd)
2361 {
2362   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2363     {
2364       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2365
2366       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2367         {
2368           /* Relies on arch after 32 bit default being 64 bit default.  */
2369           abfd->arch_info = abfd->arch_info->next;
2370           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2371         }
2372     }
2373   return TRUE;
2374 }
2375
2376 /* Merge backend specific data from an object file to the output
2377    object file when linking.  */
2378
2379 static bfd_boolean
2380 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2381 {
2382   /* Check if we have the same endianess.  */
2383   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2384       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2385       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2386     {
2387       const char *msg;
2388
2389       if (bfd_big_endian (ibfd))
2390         msg = _("%s: compiled for a big endian system "
2391                 "and target is little endian");
2392       else
2393         msg = _("%s: compiled for a little endian system "
2394                 "and target is big endian");
2395
2396       (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
2397
2398       bfd_set_error (bfd_error_wrong_format);
2399       return FALSE;
2400     }
2401
2402   return TRUE;
2403 }
2404
2405 /* Add extra PPC sections.  */
2406
2407 static struct bfd_elf_special_section const ppc64_elf_special_sections[]=
2408 {
2409   { ".sdata",           0,      NULL,   0,
2410     SHT_PROGBITS,       SHF_ALLOC + SHF_WRITE },
2411   { ".sbss",            0,      NULL,   0,
2412     SHT_NOBITS,         SHF_ALLOC + SHF_WRITE },
2413   { ".plt",             0,      NULL,   0,
2414     SHT_NOBITS,         0 },
2415   { ".toc",             0,      NULL,   0,
2416     SHT_PROGBITS,       SHF_ALLOC + SHF_WRITE },
2417   { ".toc1",            0,      NULL,   0,
2418     SHT_PROGBITS,       SHF_ALLOC + SHF_WRITE },
2419   { ".tocbss",          0,      NULL,   0,
2420     SHT_NOBITS,         SHF_ALLOC + SHF_WRITE },
2421   { NULL,               0,      NULL,   0,
2422     0,                  0 }
2423 };
2424
2425 struct _ppc64_elf_section_data
2426 {
2427   struct bfd_elf_section_data elf;
2428
2429   /* An array with one entry for each opd function descriptor.  */
2430   union
2431   {
2432     /* Points to the function code section for local opd entries.  */
2433     asection **func_sec;
2434     /* After editing .opd, adjust references to opd local syms.  */
2435     long *adjust;
2436   } opd;
2437
2438   /* An array for toc sections, indexed by offset/8.
2439      Specifies the relocation symbol index used at a given toc offset.  */
2440   unsigned *t_symndx;
2441 };
2442
2443 #define ppc64_elf_section_data(sec) \
2444   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2445
2446 static bfd_boolean
2447 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2448 {
2449   struct _ppc64_elf_section_data *sdata;
2450   bfd_size_type amt = sizeof (*sdata);
2451
2452   sdata = bfd_zalloc (abfd, amt);
2453   if (sdata == NULL)
2454     return FALSE;
2455   sec->used_by_bfd = sdata;
2456
2457   return _bfd_elf_new_section_hook (abfd, sec);
2458 }
2459 \f
2460 /* The following functions are specific to the ELF linker, while
2461    functions above are used generally.  Those named ppc64_elf_* are
2462    called by the main ELF linker code.  They appear in this file more
2463    or less in the order in which they are called.  eg.
2464    ppc64_elf_check_relocs is called early in the link process,
2465    ppc64_elf_finish_dynamic_sections is one of the last functions
2466    called.
2467
2468    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2469    functions have both a function code symbol and a function descriptor
2470    symbol.  A call to foo in a relocatable object file looks like:
2471
2472    .            .text
2473    .    x:
2474    .            bl      .foo
2475    .            nop
2476
2477    The function definition in another object file might be:
2478
2479    .            .section .opd
2480    .    foo:    .quad   .foo
2481    .            .quad   .TOC.@tocbase
2482    .            .quad   0
2483    .
2484    .            .text
2485    .    .foo:   blr
2486
2487    When the linker resolves the call during a static link, the branch
2488    unsurprisingly just goes to .foo and the .opd information is unused.
2489    If the function definition is in a shared library, things are a little
2490    different:  The call goes via a plt call stub, the opd information gets
2491    copied to the plt, and the linker patches the nop.
2492
2493    .    x:
2494    .            bl      .foo_stub
2495    .            ld      2,40(1)
2496    .
2497    .
2498    .    .foo_stub:
2499    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
2500    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
2501    .            std     2,40(1)                 # this is the general idea
2502    .            ld      11,0(12)
2503    .            ld      2,8(12)
2504    .            mtctr   11
2505    .            ld      11,16(12)
2506    .            bctr
2507    .
2508    .            .section .plt
2509    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
2510
2511    The "reloc ()" notation is supposed to indicate that the linker emits
2512    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
2513    copying.
2514
2515    What are the difficulties here?  Well, firstly, the relocations
2516    examined by the linker in check_relocs are against the function code
2517    sym .foo, while the dynamic relocation in the plt is emitted against
2518    the function descriptor symbol, foo.  Somewhere along the line, we need
2519    to carefully copy dynamic link information from one symbol to the other.
2520    Secondly, the generic part of the elf linker will make .foo a dynamic
2521    symbol as is normal for most other backends.  We need foo dynamic
2522    instead, at least for an application final link.  However, when
2523    creating a shared library containing foo, we need to have both symbols
2524    dynamic so that references to .foo are satisfied during the early
2525    stages of linking.  Otherwise the linker might decide to pull in a
2526    definition from some other object, eg. a static library.  */
2527
2528 /* The linker needs to keep track of the number of relocs that it
2529    decides to copy as dynamic relocs in check_relocs for each symbol.
2530    This is so that it can later discard them if they are found to be
2531    unnecessary.  We store the information in a field extending the
2532    regular ELF linker hash table.  */
2533
2534 struct ppc_dyn_relocs
2535 {
2536   struct ppc_dyn_relocs *next;
2537
2538   /* The input section of the reloc.  */
2539   asection *sec;
2540
2541   /* Total number of relocs copied for the input section.  */
2542   bfd_size_type count;
2543
2544   /* Number of pc-relative relocs copied for the input section.  */
2545   bfd_size_type pc_count;
2546 };
2547
2548 /* Track GOT entries needed for a given symbol.  We might need more
2549    than one got entry per symbol.  */
2550 struct got_entry
2551 {
2552   struct got_entry *next;
2553
2554   /* The symbol addend that we'll be placing in the GOT.  */
2555   bfd_vma addend;
2556
2557   /* Unlike other ELF targets, we use separate GOT entries for the same
2558      symbol referenced from different input files.  This is to support
2559      automatic multiple TOC/GOT sections, where the TOC base can vary
2560      from one input file to another.
2561
2562      Point to the BFD owning this GOT entry.  */
2563   bfd *owner;
2564
2565   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2566      TLS_TPREL or TLS_DTPREL for tls entries.  */
2567   char tls_type;
2568
2569   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2570   union
2571     {
2572       bfd_signed_vma refcount;
2573       bfd_vma offset;
2574     } got;
2575 };
2576
2577 /* The same for PLT.  */
2578 struct plt_entry
2579 {
2580   struct plt_entry *next;
2581
2582   bfd_vma addend;
2583
2584   union
2585     {
2586       bfd_signed_vma refcount;
2587       bfd_vma offset;
2588     } plt;
2589 };
2590
2591 /* Of those relocs that might be copied as dynamic relocs, this macro
2592    selects those that must be copied when linking a shared library,
2593    even when the symbol is local.  */
2594
2595 #define MUST_BE_DYN_RELOC(RTYPE)                \
2596   ((RTYPE) != R_PPC64_REL32                     \
2597    && (RTYPE) != R_PPC64_REL64                  \
2598    && (RTYPE) != R_PPC64_REL30)
2599
2600 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2601    copying dynamic variables from a shared lib into an app's dynbss
2602    section, and instead use a dynamic relocation to point into the
2603    shared lib.  With code that gcc generates, it's vital that this be
2604    enabled;  In the PowerPC64 ABI, the address of a function is actually
2605    the address of a function descriptor, which resides in the .opd
2606    section.  gcc uses the descriptor directly rather than going via the
2607    GOT as some other ABI's do, which means that initialized function
2608    pointers must reference the descriptor.  Thus, a function pointer
2609    initialized to the address of a function in a shared library will
2610    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
2611    redefines the function desctriptor symbol to point to the copy.  This
2612    presents a problem as a plt entry for that function is also
2613    initialized from the function descriptor symbol and the copy reloc
2614    may not be initialized first.  */
2615 #define ELIMINATE_COPY_RELOCS 1
2616
2617 /* Section name for stubs is the associated section name plus this
2618    string.  */
2619 #define STUB_SUFFIX ".stub"
2620
2621 /* Linker stubs.
2622    ppc_stub_long_branch:
2623    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2624    destination, but a 24 bit branch in a stub section will reach.
2625    .    b       dest
2626
2627    ppc_stub_plt_branch:
2628    Similar to the above, but a 24 bit branch in the stub section won't
2629    reach its destination.
2630    .    addis   %r12,%r2,xxx@toc@ha
2631    .    ld      %r11,xxx@toc@l(%r12)
2632    .    mtctr   %r11
2633    .    bctr
2634
2635    ppc_stub_plt_call:
2636    Used to call a function in a shared library.
2637    .    addis   %r12,%r2,xxx@toc@ha
2638    .    std     %r2,40(%r1)
2639    .    ld      %r11,xxx+0@toc@l(%r12)
2640    .    ld      %r2,xxx+8@toc@l(%r12)
2641    .    mtctr   %r11
2642    .    ld      %r11,xxx+16@toc@l(%r12)
2643    .    bctr
2644
2645    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2646    code to adjust the value and save r2 to support multiple toc sections.
2647    A ppc_stub_long_branch with an r2 offset looks like:
2648    .    std     %r2,40(%r1)
2649    .    addis   %r2,%r2,off@ha
2650    .    addi    %r2,%r2,off@l
2651    .    b       dest
2652
2653    A ppc_stub_plt_branch with an r2 offset looks like:
2654    .    std     %r2,40(%r1)
2655    .    addis   %r12,%r2,xxx@toc@ha
2656    .    ld      %r11,xxx@toc@l(%r12)
2657    .    addis   %r2,%r2,off@ha
2658    .    addi    %r2,%r2,off@l
2659    .    mtctr   %r11
2660    .    bctr
2661 */
2662
2663 enum ppc_stub_type {
2664   ppc_stub_none,
2665   ppc_stub_long_branch,
2666   ppc_stub_long_branch_r2off,
2667   ppc_stub_plt_branch,
2668   ppc_stub_plt_branch_r2off,
2669   ppc_stub_plt_call
2670 };
2671
2672 struct ppc_stub_hash_entry {
2673
2674   /* Base hash table entry structure.  */
2675   struct bfd_hash_entry root;
2676
2677   enum ppc_stub_type stub_type;
2678
2679   /* The stub section.  */
2680   asection *stub_sec;
2681
2682   /* Offset within stub_sec of the beginning of this stub.  */
2683   bfd_vma stub_offset;
2684
2685   /* Given the symbol's value and its section we can determine its final
2686      value when building the stubs (so the stub knows where to jump.  */
2687   bfd_vma target_value;
2688   asection *target_section;
2689
2690   /* The symbol table entry, if any, that this was derived from.  */
2691   struct ppc_link_hash_entry *h;
2692
2693   /* And the reloc addend that this was derived from.  */
2694   bfd_vma addend;
2695
2696   /* Where this stub is being called from, or, in the case of combined
2697      stub sections, the first input section in the group.  */
2698   asection *id_sec;
2699 };
2700
2701 struct ppc_branch_hash_entry {
2702
2703   /* Base hash table entry structure.  */
2704   struct bfd_hash_entry root;
2705
2706   /* Offset within .branch_lt.  */
2707   unsigned int offset;
2708
2709   /* Generation marker.  */
2710   unsigned int iter;
2711 };
2712
2713 struct ppc_link_hash_entry
2714 {
2715   struct elf_link_hash_entry elf;
2716
2717   /* A pointer to the most recently used stub hash entry against this
2718      symbol.  */
2719   struct ppc_stub_hash_entry *stub_cache;
2720
2721   /* Track dynamic relocs copied for this symbol.  */
2722   struct ppc_dyn_relocs *dyn_relocs;
2723
2724   /* Link between function code and descriptor symbols.  */
2725   struct elf_link_hash_entry *oh;
2726
2727   /* Flag function code and descriptor symbols.  */
2728   unsigned int is_func:1;
2729   unsigned int is_func_descriptor:1;
2730   unsigned int is_entry:1;
2731
2732   /* Contexts in which symbol is used in the GOT (or TOC).
2733      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
2734      corresponding relocs are encountered during check_relocs.
2735      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
2736      indicate the corresponding GOT entry type is not needed.
2737      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
2738      a TPREL one.  We use a separate flag rather than setting TPREL
2739      just for convenience in distinguishing the two cases.  */
2740 #define TLS_GD           1      /* GD reloc. */
2741 #define TLS_LD           2      /* LD reloc. */
2742 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
2743 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
2744 #define TLS_TLS         16      /* Any TLS reloc.  */
2745 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
2746 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
2747   char tls_mask;
2748 };
2749
2750 /* ppc64 ELF linker hash table.  */
2751
2752 struct ppc_link_hash_table
2753 {
2754   struct elf_link_hash_table elf;
2755
2756   /* The stub hash table.  */
2757   struct bfd_hash_table stub_hash_table;
2758
2759   /* Another hash table for plt_branch stubs.  */
2760   struct bfd_hash_table branch_hash_table;
2761
2762   /* Linker stub bfd.  */
2763   bfd *stub_bfd;
2764
2765   /* Linker call-backs.  */
2766   asection * (*add_stub_section) (const char *, asection *);
2767   void (*layout_sections_again) (void);
2768
2769   /* Array to keep track of which stub sections have been created, and
2770      information on stub grouping.  */
2771   struct map_stub {
2772     /* This is the section to which stubs in the group will be attached.  */
2773     asection *link_sec;
2774     /* The stub section.  */
2775     asection *stub_sec;
2776     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
2777     bfd_vma toc_off;
2778   } *stub_group;
2779
2780   /* Support for multiple toc sections.  */
2781   unsigned int no_multi_toc;
2782   unsigned int multi_toc_needed;
2783
2784   /* Temp used when calculating TOC pointers.  */
2785   bfd_vma toc_curr;
2786
2787   /* Highest input section id.  */
2788   int top_id;
2789
2790   /* Highest output section index.  */
2791   int top_index;
2792
2793   /* List of input sections for each output section.  */
2794   asection **input_list;
2795
2796   /* Short-cuts to get to dynamic linker sections.  */
2797   asection *got;
2798   asection *plt;
2799   asection *relplt;
2800   asection *dynbss;
2801   asection *relbss;
2802   asection *glink;
2803   asection *sfpr;
2804   asection *brlt;
2805   asection *relbrlt;
2806
2807   /* Short-cut to first output tls section.  */
2808   asection *tls_sec;
2809
2810   /* Shortcut to .__tls_get_addr.  */
2811   struct elf_link_hash_entry *tls_get_addr;
2812
2813   /* Statistics.  */
2814   unsigned long stub_count[ppc_stub_plt_call];
2815
2816   /* Set if we should emit symbols for stubs.  */
2817   unsigned int emit_stub_syms;
2818
2819   /* Set on error.  */
2820   unsigned int stub_error;
2821
2822   /* Flag set when small branches are detected.  Used to
2823      select suitable defaults for the stub group size.  */
2824   unsigned int has_14bit_branch;
2825
2826   /* Set if we detect a reference undefined weak symbol.  */
2827   unsigned int have_undefweak;
2828
2829   /* Incremented every time we size stubs.  */
2830   unsigned int stub_iteration;
2831
2832   /* Small local sym to section mapping cache.  */
2833   struct sym_sec_cache sym_sec;
2834 };
2835
2836 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
2837
2838 #define ppc_hash_table(p) \
2839   ((struct ppc_link_hash_table *) ((p)->hash))
2840
2841 #define ppc_stub_hash_lookup(table, string, create, copy) \
2842   ((struct ppc_stub_hash_entry *) \
2843    bfd_hash_lookup ((table), (string), (create), (copy)))
2844
2845 #define ppc_branch_hash_lookup(table, string, create, copy) \
2846   ((struct ppc_branch_hash_entry *) \
2847    bfd_hash_lookup ((table), (string), (create), (copy)))
2848
2849 /* Create an entry in the stub hash table.  */
2850
2851 static struct bfd_hash_entry *
2852 stub_hash_newfunc (struct bfd_hash_entry *entry,
2853                    struct bfd_hash_table *table,
2854                    const char *string)
2855 {
2856   /* Allocate the structure if it has not already been allocated by a
2857      subclass.  */
2858   if (entry == NULL)
2859     {
2860       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
2861       if (entry == NULL)
2862         return entry;
2863     }
2864
2865   /* Call the allocation method of the superclass.  */
2866   entry = bfd_hash_newfunc (entry, table, string);
2867   if (entry != NULL)
2868     {
2869       struct ppc_stub_hash_entry *eh;
2870
2871       /* Initialize the local fields.  */
2872       eh = (struct ppc_stub_hash_entry *) entry;
2873       eh->stub_type = ppc_stub_none;
2874       eh->stub_sec = NULL;
2875       eh->stub_offset = 0;
2876       eh->target_value = 0;
2877       eh->target_section = NULL;
2878       eh->h = NULL;
2879       eh->id_sec = NULL;
2880     }
2881
2882   return entry;
2883 }
2884
2885 /* Create an entry in the branch hash table.  */
2886
2887 static struct bfd_hash_entry *
2888 branch_hash_newfunc (struct bfd_hash_entry *entry,
2889                      struct bfd_hash_table *table,
2890                      const char *string)
2891 {
2892   /* Allocate the structure if it has not already been allocated by a
2893      subclass.  */
2894   if (entry == NULL)
2895     {
2896       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
2897       if (entry == NULL)
2898         return entry;
2899     }
2900
2901   /* Call the allocation method of the superclass.  */
2902   entry = bfd_hash_newfunc (entry, table, string);
2903   if (entry != NULL)
2904     {
2905       struct ppc_branch_hash_entry *eh;
2906
2907       /* Initialize the local fields.  */
2908       eh = (struct ppc_branch_hash_entry *) entry;
2909       eh->offset = 0;
2910       eh->iter = 0;
2911     }
2912
2913   return entry;
2914 }
2915
2916 /* Create an entry in a ppc64 ELF linker hash table.  */
2917
2918 static struct bfd_hash_entry *
2919 link_hash_newfunc (struct bfd_hash_entry *entry,
2920                    struct bfd_hash_table *table,
2921                    const char *string)
2922 {
2923   /* Allocate the structure if it has not already been allocated by a
2924      subclass.  */
2925   if (entry == NULL)
2926     {
2927       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
2928       if (entry == NULL)
2929         return entry;
2930     }
2931
2932   /* Call the allocation method of the superclass.  */
2933   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2934   if (entry != NULL)
2935     {
2936       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
2937
2938       eh->stub_cache = NULL;
2939       eh->dyn_relocs = NULL;
2940       eh->oh = NULL;
2941       eh->is_func = 0;
2942       eh->is_func_descriptor = 0;
2943       eh->is_entry = 0;
2944       eh->tls_mask = 0;
2945     }
2946
2947   return entry;
2948 }
2949
2950 /* Create a ppc64 ELF linker hash table.  */
2951
2952 static struct bfd_link_hash_table *
2953 ppc64_elf_link_hash_table_create (bfd *abfd)
2954 {
2955   struct ppc_link_hash_table *htab;
2956   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
2957
2958   htab = bfd_zmalloc (amt);
2959   if (htab == NULL)
2960     return NULL;
2961
2962   if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
2963     {
2964       free (htab);
2965       return NULL;
2966     }
2967
2968   /* Init the stub hash table too.  */
2969   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc))
2970     return NULL;
2971
2972   /* And the branch hash table.  */
2973   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc))
2974     return NULL;
2975
2976   /* Initializing two fields of the union is just cosmetic.  We really
2977      only care about glist, but when compiled on a 32-bit host the
2978      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
2979      debugger inspection of these fields look nicer.  */
2980   htab->elf.init_refcount.refcount = 0;
2981   htab->elf.init_refcount.glist = NULL;
2982   htab->elf.init_offset.offset = 0;
2983   htab->elf.init_offset.glist = NULL;
2984
2985   return &htab->elf.root;
2986 }
2987
2988 /* Free the derived linker hash table.  */
2989
2990 static void
2991 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
2992 {
2993   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
2994
2995   bfd_hash_table_free (&ret->stub_hash_table);
2996   bfd_hash_table_free (&ret->branch_hash_table);
2997   _bfd_generic_link_hash_table_free (hash);
2998 }
2999
3000 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3001
3002 void
3003 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3004 {
3005   struct ppc_link_hash_table *htab;
3006
3007   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3008
3009 /* Always hook our dynamic sections into the first bfd, which is the
3010    linker created stub bfd.  This ensures that the GOT header is at
3011    the start of the output TOC section.  */
3012   htab = ppc_hash_table (info);
3013   htab->stub_bfd = abfd;
3014   htab->elf.dynobj = abfd;
3015 }
3016
3017 /* Build a name for an entry in the stub hash table.  */
3018
3019 static char *
3020 ppc_stub_name (const asection *input_section,
3021                const asection *sym_sec,
3022                const struct ppc_link_hash_entry *h,
3023                const Elf_Internal_Rela *rel)
3024 {
3025   char *stub_name;
3026   bfd_size_type len;
3027
3028   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3029      offsets from a sym as a branch target?  In fact, we could
3030      probably assume the addend is always zero.  */
3031   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3032
3033   if (h)
3034     {
3035       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3036       stub_name = bfd_malloc (len);
3037       if (stub_name != NULL)
3038         {
3039           sprintf (stub_name, "%08x_%s+%x",
3040                    input_section->id & 0xffffffff,
3041                    h->elf.root.root.string,
3042                    (int) rel->r_addend & 0xffffffff);
3043         }
3044     }
3045   else
3046     {
3047       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3048       stub_name = bfd_malloc (len);
3049       if (stub_name != NULL)
3050         {
3051           sprintf (stub_name, "%08x_%x:%x+%x",
3052                    input_section->id & 0xffffffff,
3053                    sym_sec->id & 0xffffffff,
3054                    (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3055                    (int) rel->r_addend & 0xffffffff);
3056         }
3057     }
3058   return stub_name;
3059 }
3060
3061 /* Look up an entry in the stub hash.  Stub entries are cached because
3062    creating the stub name takes a bit of time.  */
3063
3064 static struct ppc_stub_hash_entry *
3065 ppc_get_stub_entry (const asection *input_section,
3066                     const asection *sym_sec,
3067                     struct elf_link_hash_entry *hash,
3068                     const Elf_Internal_Rela *rel,
3069                     struct ppc_link_hash_table *htab)
3070 {
3071   struct ppc_stub_hash_entry *stub_entry;
3072   struct ppc_link_hash_entry *h = (struct ppc_link_hash_entry *) hash;
3073   const asection *id_sec;
3074
3075   /* If this input section is part of a group of sections sharing one
3076      stub section, then use the id of the first section in the group.
3077      Stub names need to include a section id, as there may well be
3078      more than one stub used to reach say, printf, and we need to
3079      distinguish between them.  */
3080   id_sec = htab->stub_group[input_section->id].link_sec;
3081
3082   if (h != NULL && h->stub_cache != NULL
3083       && h->stub_cache->h == h
3084       && h->stub_cache->id_sec == id_sec)
3085     {
3086       stub_entry = h->stub_cache;
3087     }
3088   else
3089     {
3090       char *stub_name;
3091
3092       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3093       if (stub_name == NULL)
3094         return NULL;
3095
3096       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3097                                          stub_name, FALSE, FALSE);
3098       if (h != NULL)
3099         h->stub_cache = stub_entry;
3100
3101       free (stub_name);
3102     }
3103
3104   return stub_entry;
3105 }
3106
3107 /* Add a new stub entry to the stub hash.  Not all fields of the new
3108    stub entry are initialised.  */
3109
3110 static struct ppc_stub_hash_entry *
3111 ppc_add_stub (const char *stub_name,
3112               asection *section,
3113               struct ppc_link_hash_table *htab)
3114 {
3115   asection *link_sec;
3116   asection *stub_sec;
3117   struct ppc_stub_hash_entry *stub_entry;
3118
3119   link_sec = htab->stub_group[section->id].link_sec;
3120   stub_sec = htab->stub_group[section->id].stub_sec;
3121   if (stub_sec == NULL)
3122     {
3123       stub_sec = htab->stub_group[link_sec->id].stub_sec;
3124       if (stub_sec == NULL)
3125         {
3126           size_t namelen;
3127           bfd_size_type len;
3128           char *s_name;
3129
3130           namelen = strlen (link_sec->name);
3131           len = namelen + sizeof (STUB_SUFFIX);
3132           s_name = bfd_alloc (htab->stub_bfd, len);
3133           if (s_name == NULL)
3134             return NULL;
3135
3136           memcpy (s_name, link_sec->name, namelen);
3137           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3138           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3139           if (stub_sec == NULL)
3140             return NULL;
3141           htab->stub_group[link_sec->id].stub_sec = stub_sec;
3142         }
3143       htab->stub_group[section->id].stub_sec = stub_sec;
3144     }
3145
3146   /* Enter this entry into the linker stub hash table.  */
3147   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3148                                      TRUE, FALSE);
3149   if (stub_entry == NULL)
3150     {
3151       (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
3152                              bfd_archive_filename (section->owner),
3153                              stub_name);
3154       return NULL;
3155     }
3156
3157   stub_entry->stub_sec = stub_sec;
3158   stub_entry->stub_offset = 0;
3159   stub_entry->id_sec = link_sec;
3160   return stub_entry;
3161 }
3162
3163 /* Create sections for linker generated code.  */
3164
3165 static bfd_boolean
3166 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3167 {
3168   struct ppc_link_hash_table *htab;
3169   flagword flags;
3170
3171   htab = ppc_hash_table (info);
3172
3173   /* Create .sfpr for code to save and restore fp regs.  */
3174   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3175            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3176   htab->sfpr = bfd_make_section_anyway (dynobj, ".sfpr");
3177   if (htab->sfpr == NULL
3178       || ! bfd_set_section_flags (dynobj, htab->sfpr, flags)
3179       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3180     return FALSE;
3181
3182   /* Create .glink for lazy dynamic linking support.  */
3183   htab->glink = bfd_make_section_anyway (dynobj, ".glink");
3184   if (htab->glink == NULL
3185       || ! bfd_set_section_flags (dynobj, htab->glink, flags)
3186       || ! bfd_set_section_alignment (dynobj, htab->glink, 2))
3187     return FALSE;
3188
3189   /* Create .branch_lt for plt_branch stubs.  */
3190   flags = (SEC_ALLOC | SEC_LOAD
3191            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3192   htab->brlt = bfd_make_section_anyway (dynobj, ".branch_lt");
3193   if (htab->brlt == NULL
3194       || ! bfd_set_section_flags (dynobj, htab->brlt, flags)
3195       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
3196     return FALSE;
3197
3198   if (info->shared)
3199     {
3200       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3201                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3202       htab->relbrlt = bfd_make_section_anyway (dynobj, ".rela.branch_lt");
3203       if (!htab->relbrlt
3204           || ! bfd_set_section_flags (dynobj, htab->relbrlt, flags)
3205           || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3206         return FALSE;
3207     }
3208   return TRUE;
3209 }
3210
3211 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3212    not already done.  */
3213
3214 static bfd_boolean
3215 create_got_section (bfd *abfd, struct bfd_link_info *info)
3216 {
3217   asection *got, *relgot;
3218   flagword flags;
3219   struct ppc_link_hash_table *htab = ppc_hash_table (info);
3220
3221   if (!htab->got)
3222     {
3223       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
3224         return FALSE;
3225
3226       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
3227       if (!htab->got)
3228         abort ();
3229     }
3230
3231   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3232            | SEC_LINKER_CREATED);
3233
3234   got = bfd_make_section (abfd, ".got");
3235   if (!got
3236       || !bfd_set_section_flags (abfd, got, flags)
3237       || !bfd_set_section_alignment (abfd, got, 3))
3238     return FALSE;
3239
3240   relgot = bfd_make_section (abfd, ".rela.got");
3241   if (!relgot
3242       || ! bfd_set_section_flags (abfd, relgot, flags | SEC_READONLY)
3243       || ! bfd_set_section_alignment (abfd, relgot, 3))
3244     return FALSE;
3245
3246   ppc64_elf_tdata (abfd)->got = got;
3247   ppc64_elf_tdata (abfd)->relgot = relgot;
3248   return TRUE;
3249 }
3250
3251 /* Create the dynamic sections, and set up shortcuts.  */
3252
3253 static bfd_boolean
3254 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3255 {
3256   struct ppc_link_hash_table *htab;
3257
3258   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3259     return FALSE;
3260
3261   htab = ppc_hash_table (info);
3262   if (!htab->got)
3263     htab->got = bfd_get_section_by_name (dynobj, ".got");
3264   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
3265   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
3266   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
3267   if (!info->shared)
3268     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
3269
3270   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
3271       || (!info->shared && !htab->relbss))
3272     abort ();
3273
3274   return TRUE;
3275 }
3276
3277 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3278
3279 static void
3280 ppc64_elf_copy_indirect_symbol (struct elf_backend_data *bed ATTRIBUTE_UNUSED,
3281                                 struct elf_link_hash_entry *dir,
3282                                 struct elf_link_hash_entry *ind)
3283 {
3284   struct ppc_link_hash_entry *edir, *eind;
3285   flagword mask;
3286
3287   edir = (struct ppc_link_hash_entry *) dir;
3288   eind = (struct ppc_link_hash_entry *) ind;
3289
3290   /* Copy over any dynamic relocs we may have on the indirect sym.  */
3291   if (eind->dyn_relocs != NULL)
3292     {
3293       if (edir->dyn_relocs != NULL)
3294         {
3295           struct ppc_dyn_relocs **pp;
3296           struct ppc_dyn_relocs *p;
3297
3298           if (eind->elf.root.type == bfd_link_hash_indirect)
3299             abort ();
3300
3301           /* Add reloc counts against the weak sym to the strong sym
3302              list.  Merge any entries against the same section.  */
3303           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3304             {
3305               struct ppc_dyn_relocs *q;
3306
3307               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3308                 if (q->sec == p->sec)
3309                   {
3310                     q->pc_count += p->pc_count;
3311                     q->count += p->count;
3312                     *pp = p->next;
3313                     break;
3314                   }
3315               if (q == NULL)
3316                 pp = &p->next;
3317             }
3318           *pp = edir->dyn_relocs;
3319         }
3320
3321       edir->dyn_relocs = eind->dyn_relocs;
3322       eind->dyn_relocs = NULL;
3323     }
3324
3325   edir->is_func |= eind->is_func;
3326   edir->is_func_descriptor |= eind->is_func_descriptor;
3327   edir->is_entry |= eind->is_entry;
3328   edir->tls_mask |= eind->tls_mask;
3329
3330   mask = (ELF_LINK_HASH_REF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR
3331           | ELF_LINK_HASH_REF_REGULAR_NONWEAK | ELF_LINK_NON_GOT_REF);
3332   /* If called to transfer flags for a weakdef during processing
3333      of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
3334      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
3335   if (ELIMINATE_COPY_RELOCS
3336       && eind->elf.root.type != bfd_link_hash_indirect
3337       && (edir->elf.elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
3338     mask &= ~ELF_LINK_NON_GOT_REF;
3339
3340   edir->elf.elf_link_hash_flags |= eind->elf.elf_link_hash_flags & mask;
3341
3342   /* If we were called to copy over info for a weak sym, that's all.  */
3343   if (eind->elf.root.type != bfd_link_hash_indirect)
3344     return;
3345
3346   /* Copy over got entries that we may have already seen to the
3347      symbol which just became indirect.  */
3348   if (eind->elf.got.glist != NULL)
3349     {
3350       if (edir->elf.got.glist != NULL)
3351         {
3352           struct got_entry **entp;
3353           struct got_entry *ent;
3354
3355           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3356             {
3357               struct got_entry *dent;
3358
3359               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3360                 if (dent->addend == ent->addend
3361                     && dent->owner == ent->owner
3362                     && dent->tls_type == ent->tls_type)
3363                   {
3364                     dent->got.refcount += ent->got.refcount;
3365                     *entp = ent->next;
3366                     break;
3367                   }
3368               if (dent == NULL)
3369                 entp = &ent->next;
3370             }
3371           *entp = edir->elf.got.glist;
3372         }
3373
3374       edir->elf.got.glist = eind->elf.got.glist;
3375       eind->elf.got.glist = NULL;
3376     }
3377
3378   /* And plt entries.  */
3379   if (eind->elf.plt.plist != NULL)
3380     {
3381       if (edir->elf.plt.plist != NULL)
3382         {
3383           struct plt_entry **entp;
3384           struct plt_entry *ent;
3385
3386           for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; )
3387             {
3388               struct plt_entry *dent;
3389
3390               for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next)
3391                 if (dent->addend == ent->addend)
3392                   {
3393                     dent->plt.refcount += ent->plt.refcount;
3394                     *entp = ent->next;
3395                     break;
3396                   }
3397               if (dent == NULL)
3398                 entp = &ent->next;
3399             }
3400           *entp = edir->elf.plt.plist;
3401         }
3402
3403       edir->elf.plt.plist = eind->elf.plt.plist;
3404       eind->elf.plt.plist = NULL;
3405     }
3406
3407   if (edir->elf.dynindx == -1)
3408     {
3409       edir->elf.dynindx = eind->elf.dynindx;
3410       edir->elf.dynstr_index = eind->elf.dynstr_index;
3411       eind->elf.dynindx = -1;
3412       eind->elf.dynstr_index = 0;
3413     }
3414   else
3415     BFD_ASSERT (eind->elf.dynindx == -1);
3416 }
3417
3418 /* Set a flag, used by ppc64_elf_gc_mark_hook, on the entry symbol and
3419    symbols undefined on the command-line.  */
3420
3421 bfd_boolean
3422 ppc64_elf_mark_entry_syms (struct bfd_link_info *info)
3423 {
3424   struct ppc_link_hash_table *htab;
3425   struct bfd_sym_chain *sym;
3426
3427   htab = ppc_hash_table (info);
3428   for (sym = info->gc_sym_list; sym; sym = sym->next)
3429     {
3430       struct elf_link_hash_entry *h;
3431
3432       h = elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
3433       if (h != NULL)
3434         ((struct ppc_link_hash_entry *) h)->is_entry = 1;
3435     }
3436   return TRUE;
3437 }
3438
3439 static bfd_boolean
3440 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
3441                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
3442 {
3443   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
3444   char *local_got_tls_masks;
3445
3446   if (local_got_ents == NULL)
3447     {
3448       bfd_size_type size = symtab_hdr->sh_info;
3449
3450       size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
3451       local_got_ents = bfd_zalloc (abfd, size);
3452       if (local_got_ents == NULL)
3453         return FALSE;
3454       elf_local_got_ents (abfd) = local_got_ents;
3455     }
3456
3457   if ((tls_type & TLS_EXPLICIT) == 0)
3458     {
3459       struct got_entry *ent;
3460
3461       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
3462         if (ent->addend == r_addend
3463             && ent->owner == abfd
3464             && ent->tls_type == tls_type)
3465           break;
3466       if (ent == NULL)
3467         {
3468           bfd_size_type amt = sizeof (*ent);
3469           ent = bfd_alloc (abfd, amt);
3470           if (ent == NULL)
3471             return FALSE;
3472           ent->next = local_got_ents[r_symndx];
3473           ent->addend = r_addend;
3474           ent->owner = abfd;
3475           ent->tls_type = tls_type;
3476           ent->got.refcount = 0;
3477           local_got_ents[r_symndx] = ent;
3478         }
3479       ent->got.refcount += 1;
3480     }
3481
3482   local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
3483   local_got_tls_masks[r_symndx] |= tls_type;
3484   return TRUE;
3485 }
3486
3487 static bfd_boolean
3488 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
3489 {
3490   struct plt_entry *ent;
3491
3492   for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
3493     if (ent->addend == addend)
3494       break;
3495   if (ent == NULL)
3496     {
3497       bfd_size_type amt = sizeof (*ent);
3498       ent = bfd_alloc (abfd, amt);
3499       if (ent == NULL)
3500         return FALSE;
3501       ent->next = eh->elf.plt.plist;
3502       ent->addend = addend;
3503       ent->plt.refcount = 0;
3504       eh->elf.plt.plist = ent;
3505     }
3506   ent->plt.refcount += 1;
3507   eh->elf.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3508   eh->is_func = 1;
3509   return TRUE;
3510 }
3511
3512 /* Find the function descriptor hash entry from the given function code
3513    hash entry FH.  Link the entries via their OH fields.  */
3514 static struct ppc_link_hash_entry *
3515 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
3516 {
3517   struct ppc_link_hash_entry *fdh = (struct ppc_link_hash_entry *) fh->oh;
3518
3519   if (fdh == NULL)
3520     {
3521       const char *fd_name = fh->elf.root.root.string + 1;
3522
3523       fdh = (struct ppc_link_hash_entry *)
3524         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
3525       if (fdh != NULL)
3526         {
3527           fdh->is_func_descriptor = 1;
3528           fdh->oh = &fh->elf;
3529           fh->is_func = 1;
3530           fh->oh = &fdh->elf;
3531         }
3532     }
3533
3534   return fdh;
3535 }
3536
3537 /* Look through the relocs for a section during the first phase, and
3538    calculate needed space in the global offset table, procedure
3539    linkage table, and dynamic reloc sections.  */
3540
3541 static bfd_boolean
3542 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
3543                         asection *sec, const Elf_Internal_Rela *relocs)
3544 {
3545   struct ppc_link_hash_table *htab;
3546   Elf_Internal_Shdr *symtab_hdr;
3547   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3548   const Elf_Internal_Rela *rel;
3549   const Elf_Internal_Rela *rel_end;
3550   asection *sreloc;
3551   asection **opd_sym_map;
3552
3553   if (info->relocatable)
3554     return TRUE;
3555
3556   htab = ppc_hash_table (info);
3557   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3558
3559   sym_hashes = elf_sym_hashes (abfd);
3560   sym_hashes_end = (sym_hashes
3561                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
3562                     - symtab_hdr->sh_info);
3563
3564   sreloc = NULL;
3565   opd_sym_map = NULL;
3566   if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
3567     {
3568       /* Garbage collection needs some extra help with .opd sections.
3569          We don't want to necessarily keep everything referenced by
3570          relocs in .opd, as that would keep all functions.  Instead,
3571          if we reference an .opd symbol (a function descriptor), we
3572          want to keep the function code symbol's section.  This is
3573          easy for global symbols, but for local syms we need to keep
3574          information about the associated function section.  Later, if
3575          edit_opd deletes entries, we'll use this array to adjust
3576          local syms in .opd.  */
3577       union opd_info {
3578         asection *func_section;
3579         long entry_adjust;
3580       };
3581       bfd_size_type amt;
3582
3583       amt = sec->_raw_size * sizeof (union opd_info) / 24;
3584       opd_sym_map = bfd_zalloc (abfd, amt);
3585       if (opd_sym_map == NULL)
3586         return FALSE;
3587       ppc64_elf_section_data (sec)->opd.func_sec = opd_sym_map;
3588     }
3589
3590   if (htab->sfpr == NULL
3591       && !create_linkage_sections (htab->elf.dynobj, info))
3592     return FALSE;
3593
3594   rel_end = relocs + sec->reloc_count;
3595   for (rel = relocs; rel < rel_end; rel++)
3596     {
3597       unsigned long r_symndx;
3598       struct elf_link_hash_entry *h;
3599       enum elf_ppc64_reloc_type r_type;
3600       int tls_type = 0;
3601
3602       r_symndx = ELF64_R_SYM (rel->r_info);
3603       if (r_symndx < symtab_hdr->sh_info)
3604         h = NULL;
3605       else
3606         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3607
3608       r_type = ELF64_R_TYPE (rel->r_info);
3609       switch (r_type)
3610         {
3611         case R_PPC64_GOT_TLSLD16:
3612         case R_PPC64_GOT_TLSLD16_LO:
3613         case R_PPC64_GOT_TLSLD16_HI:
3614         case R_PPC64_GOT_TLSLD16_HA:
3615           ppc64_tlsld_got (abfd)->refcount += 1;
3616           tls_type = TLS_TLS | TLS_LD;
3617           goto dogottls;
3618
3619         case R_PPC64_GOT_TLSGD16:
3620         case R_PPC64_GOT_TLSGD16_LO:
3621         case R_PPC64_GOT_TLSGD16_HI:
3622         case R_PPC64_GOT_TLSGD16_HA:
3623           tls_type = TLS_TLS | TLS_GD;
3624           goto dogottls;
3625
3626         case R_PPC64_GOT_TPREL16_DS:
3627         case R_PPC64_GOT_TPREL16_LO_DS:
3628         case R_PPC64_GOT_TPREL16_HI:
3629         case R_PPC64_GOT_TPREL16_HA:
3630           if (info->shared)
3631             info->flags |= DF_STATIC_TLS;
3632           tls_type = TLS_TLS | TLS_TPREL;
3633           goto dogottls;
3634
3635         case R_PPC64_GOT_DTPREL16_DS:
3636         case R_PPC64_GOT_DTPREL16_LO_DS:
3637         case R_PPC64_GOT_DTPREL16_HI:
3638         case R_PPC64_GOT_DTPREL16_HA:
3639           tls_type = TLS_TLS | TLS_DTPREL;
3640         dogottls:
3641           sec->has_tls_reloc = 1;
3642           /* Fall thru */
3643
3644         case R_PPC64_GOT16:
3645         case R_PPC64_GOT16_DS:
3646         case R_PPC64_GOT16_HA:
3647         case R_PPC64_GOT16_HI:
3648         case R_PPC64_GOT16_LO:
3649         case R_PPC64_GOT16_LO_DS:
3650           /* This symbol requires a global offset table entry.  */
3651           sec->has_gp_reloc = 1;
3652           if (ppc64_elf_tdata (abfd)->got == NULL
3653               && !create_got_section (abfd, info))
3654             return FALSE;
3655
3656           if (h != NULL)
3657             {
3658               struct ppc_link_hash_entry *eh;
3659               struct got_entry *ent;
3660
3661               eh = (struct ppc_link_hash_entry *) h;
3662               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
3663                 if (ent->addend == rel->r_addend
3664                     && ent->owner == abfd
3665                     && ent->tls_type == tls_type)
3666                   break;
3667               if (ent == NULL)
3668                 {
3669                   bfd_size_type amt = sizeof (*ent);
3670                   ent = bfd_alloc (abfd, amt);
3671                   if (ent == NULL)
3672                     return FALSE;
3673                   ent->next = eh->elf.got.glist;
3674                   ent->addend = rel->r_addend;
3675                   ent->owner = abfd;
3676                   ent->tls_type = tls_type;
3677                   ent->got.refcount = 0;
3678                   eh->elf.got.glist = ent;
3679                 }
3680               ent->got.refcount += 1;
3681               eh->tls_mask |= tls_type;
3682             }
3683           else
3684             /* This is a global offset table entry for a local symbol.  */
3685             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
3686                                         rel->r_addend, tls_type))
3687               return FALSE;
3688           break;
3689
3690         case R_PPC64_PLT16_HA:
3691         case R_PPC64_PLT16_HI:
3692         case R_PPC64_PLT16_LO:
3693         case R_PPC64_PLT32:
3694         case R_PPC64_PLT64:
3695           /* This symbol requires a procedure linkage table entry.  We
3696              actually build the entry in adjust_dynamic_symbol,
3697              because this might be a case of linking PIC code without
3698              linking in any dynamic objects, in which case we don't
3699              need to generate a procedure linkage table after all.  */
3700           if (h == NULL)
3701             {
3702               /* It does not make sense to have a procedure linkage
3703                  table entry for a local symbol.  */
3704               bfd_set_error (bfd_error_bad_value);
3705               return FALSE;
3706             }
3707           else
3708             if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
3709                                   rel->r_addend))
3710               return FALSE;
3711           break;
3712
3713           /* The following relocations don't need to propagate the
3714              relocation if linking a shared object since they are
3715              section relative.  */
3716         case R_PPC64_SECTOFF:
3717         case R_PPC64_SECTOFF_LO:
3718         case R_PPC64_SECTOFF_HI:
3719         case R_PPC64_SECTOFF_HA:
3720         case R_PPC64_SECTOFF_DS:
3721         case R_PPC64_SECTOFF_LO_DS:
3722         case R_PPC64_DTPREL16:
3723         case R_PPC64_DTPREL16_LO:
3724         case R_PPC64_DTPREL16_HI:
3725         case R_PPC64_DTPREL16_HA:
3726         case R_PPC64_DTPREL16_DS:
3727         case R_PPC64_DTPREL16_LO_DS:
3728         case R_PPC64_DTPREL16_HIGHER:
3729         case R_PPC64_DTPREL16_HIGHERA:
3730         case R_PPC64_DTPREL16_HIGHEST:
3731         case R_PPC64_DTPREL16_HIGHESTA:
3732           break;
3733
3734           /* Nor do these.  */
3735         case R_PPC64_TOC16:
3736         case R_PPC64_TOC16_LO:
3737         case R_PPC64_TOC16_HI:
3738         case R_PPC64_TOC16_HA:
3739         case R_PPC64_TOC16_DS:
3740         case R_PPC64_TOC16_LO_DS:
3741           sec->has_gp_reloc = 1;
3742           break;
3743
3744           /* This relocation describes the C++ object vtable hierarchy.
3745              Reconstruct it for later use during GC.  */
3746         case R_PPC64_GNU_VTINHERIT:
3747           if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3748             return FALSE;
3749           break;
3750
3751           /* This relocation describes which C++ vtable entries are actually
3752              used.  Record for later use during GC.  */
3753         case R_PPC64_GNU_VTENTRY:
3754           if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3755             return FALSE;
3756           break;
3757
3758         case R_PPC64_REL14:
3759         case R_PPC64_REL14_BRTAKEN:
3760         case R_PPC64_REL14_BRNTAKEN:
3761           htab->has_14bit_branch = 1;
3762           /* Fall through.  */
3763
3764         case R_PPC64_REL24:
3765           if (h != NULL
3766               && h->root.root.string[0] == '.'
3767               && h->root.root.string[1] != 0)
3768             {
3769               /* We may need a .plt entry if the function this reloc
3770                  refers to is in a shared lib.  */
3771               if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
3772                                     rel->r_addend))
3773                 return FALSE;
3774               if (h == htab->tls_get_addr)
3775                 sec->has_tls_reloc = 1;
3776               else if ((strncmp (h->root.root.string, ".__tls_get_addr", 15)
3777                         == 0)
3778                        && (h->root.root.string[15] == 0
3779                            || h->root.root.string[15] == '@'))
3780                 {
3781                   htab->tls_get_addr = h;
3782                   sec->has_tls_reloc = 1;
3783                 }
3784             }
3785           break;
3786
3787         case R_PPC64_TPREL64:
3788           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
3789           if (info->shared)
3790             info->flags |= DF_STATIC_TLS;
3791           goto dotlstoc;
3792
3793         case R_PPC64_DTPMOD64:
3794           if (rel + 1 < rel_end
3795               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
3796               && rel[1].r_offset == rel->r_offset + 8)
3797             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
3798           else
3799             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
3800           goto dotlstoc;
3801
3802         case R_PPC64_DTPREL64:
3803           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
3804           if (rel != relocs
3805               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
3806               && rel[-1].r_offset == rel->r_offset - 8)
3807             /* This is the second reloc of a dtpmod, dtprel pair.
3808                Don't mark with TLS_DTPREL.  */
3809             goto dodyn;
3810
3811         dotlstoc:
3812           sec->has_tls_reloc = 1;
3813           if (h != NULL)
3814             {
3815               struct ppc_link_hash_entry *eh;
3816               eh = (struct ppc_link_hash_entry *) h;
3817               eh->tls_mask |= tls_type;
3818             }
3819           else
3820             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
3821                                         rel->r_addend, tls_type))
3822               return FALSE;
3823
3824           if (ppc64_elf_section_data (sec)->t_symndx == NULL)
3825             {
3826               /* One extra to simplify get_tls_mask.  */
3827               bfd_size_type amt = sec->_raw_size * sizeof (unsigned) / 8 + 1;
3828               ppc64_elf_section_data (sec)->t_symndx = bfd_zalloc (abfd, amt);
3829               if (ppc64_elf_section_data (sec)->t_symndx == NULL)
3830                 return FALSE;
3831             }
3832           BFD_ASSERT (rel->r_offset % 8 == 0);
3833           ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8] = r_symndx;
3834
3835           /* Mark the second slot of a GD or LD entry.
3836              -1 to indicate GD and -2 to indicate LD.  */
3837           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
3838             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -1;
3839           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
3840             ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -2;
3841           goto dodyn;
3842
3843         case R_PPC64_TPREL16:
3844         case R_PPC64_TPREL16_LO:
3845         case R_PPC64_TPREL16_HI:
3846         case R_PPC64_TPREL16_HA:
3847         case R_PPC64_TPREL16_DS:
3848         case R_PPC64_TPREL16_LO_DS:
3849         case R_PPC64_TPREL16_HIGHER:
3850         case R_PPC64_TPREL16_HIGHERA:
3851         case R_PPC64_TPREL16_HIGHEST:
3852         case R_PPC64_TPREL16_HIGHESTA:
3853           if (info->shared)
3854             {
3855               info->flags |= DF_STATIC_TLS;
3856               goto dodyn;
3857             }
3858           break;
3859
3860         case R_PPC64_ADDR64:
3861           if (opd_sym_map != NULL
3862               && h != NULL
3863               && h->root.root.string[0] == '.'
3864               && h->root.root.string[1] != 0)
3865             get_fdh ((struct ppc_link_hash_entry *) h, htab);
3866
3867           if (opd_sym_map != NULL
3868               && h == NULL
3869               && rel + 1 < rel_end
3870               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
3871             {
3872               asection *s;
3873
3874               s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
3875                                              r_symndx);
3876               if (s == NULL)
3877                 return FALSE;
3878               else if (s != sec)
3879                 opd_sym_map[rel->r_offset / 24] = s;
3880             }
3881           /* Fall through.  */
3882
3883         case R_PPC64_REL30:
3884         case R_PPC64_REL32:
3885         case R_PPC64_REL64:
3886         case R_PPC64_ADDR14:
3887         case R_PPC64_ADDR14_BRNTAKEN:
3888         case R_PPC64_ADDR14_BRTAKEN:
3889         case R_PPC64_ADDR16:
3890         case R_PPC64_ADDR16_DS:
3891         case R_PPC64_ADDR16_HA:
3892         case R_PPC64_ADDR16_HI:
3893         case R_PPC64_ADDR16_HIGHER:
3894         case R_PPC64_ADDR16_HIGHERA:
3895         case R_PPC64_ADDR16_HIGHEST:
3896         case R_PPC64_ADDR16_HIGHESTA:
3897         case R_PPC64_ADDR16_LO:
3898         case R_PPC64_ADDR16_LO_DS:
3899         case R_PPC64_ADDR24:
3900         case R_PPC64_ADDR32:
3901         case R_PPC64_UADDR16:
3902         case R_PPC64_UADDR32:
3903         case R_PPC64_UADDR64:
3904         case R_PPC64_TOC:
3905           if (h != NULL && !info->shared)
3906             /* We may need a copy reloc.  */
3907             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
3908
3909           /* Don't propagate .opd relocs.  */
3910           if (NO_OPD_RELOCS && opd_sym_map != NULL)
3911             break;
3912
3913           /* Don't propagate relocs that the dynamic linker won't relocate.  */
3914           if ((sec->flags & SEC_ALLOC) == 0)
3915             break;
3916
3917           /* If we are creating a shared library, and this is a reloc
3918              against a global symbol, or a non PC relative reloc
3919              against a local symbol, then we need to copy the reloc
3920              into the shared library.  However, if we are linking with
3921              -Bsymbolic, we do not need to copy a reloc against a
3922              global symbol which is defined in an object we are
3923              including in the link (i.e., DEF_REGULAR is set).  At
3924              this point we have not seen all the input files, so it is
3925              possible that DEF_REGULAR is not set now but will be set
3926              later (it is never cleared).  In case of a weak definition,
3927              DEF_REGULAR may be cleared later by a strong definition in
3928              a shared library.  We account for that possibility below by
3929              storing information in the dyn_relocs field of the hash
3930              table entry.  A similar situation occurs when creating
3931              shared libraries and symbol visibility changes render the
3932              symbol local.
3933
3934              If on the other hand, we are creating an executable, we
3935              may need to keep relocations for symbols satisfied by a
3936              dynamic library if we manage to avoid copy relocs for the
3937              symbol.  */
3938         dodyn:
3939           if ((info->shared
3940                && (MUST_BE_DYN_RELOC (r_type)
3941                    || (h != NULL
3942                        && (! info->symbolic
3943                            || h->root.type == bfd_link_hash_defweak
3944                            || (h->elf_link_hash_flags
3945                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3946               || (ELIMINATE_COPY_RELOCS
3947                   && !info->shared
3948                   && h != NULL
3949                   && (h->root.type == bfd_link_hash_defweak
3950                       || (h->elf_link_hash_flags
3951                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3952             {
3953               struct ppc_dyn_relocs *p;
3954               struct ppc_dyn_relocs **head;
3955
3956               /* We must copy these reloc types into the output file.
3957                  Create a reloc section in dynobj and make room for
3958                  this reloc.  */
3959               if (sreloc == NULL)
3960                 {
3961                   const char *name;
3962                   bfd *dynobj;
3963
3964                   name = (bfd_elf_string_from_elf_section
3965                           (abfd,
3966                            elf_elfheader (abfd)->e_shstrndx,
3967                            elf_section_data (sec)->rel_hdr.sh_name));
3968                   if (name == NULL)
3969                     return FALSE;
3970
3971                   if (strncmp (name, ".rela", 5) != 0
3972                       || strcmp (bfd_get_section_name (abfd, sec),
3973                                  name + 5) != 0)
3974                     {
3975                       (*_bfd_error_handler)
3976                         (_("%s: bad relocation section name `%s\'"),
3977                          bfd_archive_filename (abfd), name);
3978                       bfd_set_error (bfd_error_bad_value);
3979                     }
3980
3981                   dynobj = htab->elf.dynobj;
3982                   sreloc = bfd_get_section_by_name (dynobj, name);
3983                   if (sreloc == NULL)
3984                     {
3985                       flagword flags;
3986
3987                       sreloc = bfd_make_section (dynobj, name);
3988                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
3989                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3990                       if ((sec->flags & SEC_ALLOC) != 0)
3991                         flags |= SEC_ALLOC | SEC_LOAD;
3992                       if (sreloc == NULL
3993                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
3994                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
3995                         return FALSE;
3996                     }
3997                   elf_section_data (sec)->sreloc = sreloc;
3998                 }
3999
4000               /* If this is a global symbol, we count the number of
4001                  relocations we need for this symbol.  */
4002               if (h != NULL)
4003                 {
4004                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
4005                 }
4006               else
4007                 {
4008                   /* Track dynamic relocs needed for local syms too.
4009                      We really need local syms available to do this
4010                      easily.  Oh well.  */
4011
4012                   asection *s;
4013                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4014                                                  sec, r_symndx);
4015                   if (s == NULL)
4016                     return FALSE;
4017
4018                   head = ((struct ppc_dyn_relocs **)
4019                           &elf_section_data (s)->local_dynrel);
4020                 }
4021
4022               p = *head;
4023               if (p == NULL || p->sec != sec)
4024                 {
4025                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4026                   if (p == NULL)
4027                     return FALSE;
4028                   p->next = *head;
4029                   *head = p;
4030                   p->sec = sec;
4031                   p->count = 0;
4032                   p->pc_count = 0;
4033                 }
4034
4035               p->count += 1;
4036               if (!MUST_BE_DYN_RELOC (r_type))
4037                 p->pc_count += 1;
4038             }
4039           break;
4040
4041         default:
4042           break;
4043         }
4044     }
4045
4046   return TRUE;
4047 }
4048
4049 /* Return the section that should be marked against GC for a given
4050    relocation.  */
4051
4052 static asection *
4053 ppc64_elf_gc_mark_hook (asection *sec,
4054                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
4055                         Elf_Internal_Rela *rel,
4056                         struct elf_link_hash_entry *h,
4057                         Elf_Internal_Sym *sym)
4058 {
4059   asection *rsec = NULL;
4060
4061   if (h != NULL)
4062     {
4063       enum elf_ppc64_reloc_type r_type;
4064       struct ppc_link_hash_entry *fdh;
4065
4066       r_type = ELF64_R_TYPE (rel->r_info);
4067       switch (r_type)
4068         {
4069         case R_PPC64_GNU_VTINHERIT:
4070         case R_PPC64_GNU_VTENTRY:
4071           break;
4072
4073         default:
4074           switch (h->root.type)
4075             {
4076             case bfd_link_hash_defined:
4077             case bfd_link_hash_defweak:
4078               fdh = (struct ppc_link_hash_entry *) h;
4079
4080               /* Function descriptor syms cause the associated
4081                  function code sym section to be marked.  */
4082               if (fdh->is_func_descriptor)
4083                 rsec = fdh->oh->root.u.def.section;
4084
4085               /* Function entry syms return NULL if they are in .opd
4086                  and are not ._start (or others undefined on the ld
4087                  command line).  Thus we avoid marking all function
4088                  sections, as all functions are referenced in .opd.  */
4089               else if ((fdh->oh != NULL
4090                         && ((struct ppc_link_hash_entry *) fdh->oh)->is_entry)
4091                        || ppc64_elf_section_data (sec)->opd.func_sec == NULL)
4092                 rsec = h->root.u.def.section;
4093               break;
4094
4095             case bfd_link_hash_common:
4096               rsec = h->root.u.c.p->section;
4097               break;
4098
4099             default:
4100               break;
4101             }
4102         }
4103     }
4104   else
4105     {
4106       asection **opd_sym_section;
4107
4108       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4109       opd_sym_section = ppc64_elf_section_data (rsec)->opd.func_sec;
4110       if (opd_sym_section != NULL)
4111         rsec = opd_sym_section[sym->st_value / 24];
4112       else if (ppc64_elf_section_data (sec)->opd.func_sec != NULL)
4113         rsec = NULL;
4114     }
4115
4116   return rsec;
4117 }
4118
4119 /* Update the .got, .plt. and dynamic reloc reference counts for the
4120    section being removed.  */
4121
4122 static bfd_boolean
4123 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
4124                          asection *sec, const Elf_Internal_Rela *relocs)
4125 {
4126   struct ppc_link_hash_table *htab;
4127   Elf_Internal_Shdr *symtab_hdr;
4128   struct elf_link_hash_entry **sym_hashes;
4129   struct got_entry **local_got_ents;
4130   const Elf_Internal_Rela *rel, *relend;
4131
4132   elf_section_data (sec)->local_dynrel = NULL;
4133
4134   htab = ppc_hash_table (info);
4135   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4136   sym_hashes = elf_sym_hashes (abfd);
4137   local_got_ents = elf_local_got_ents (abfd);
4138
4139   relend = relocs + sec->reloc_count;
4140   for (rel = relocs; rel < relend; rel++)
4141     {
4142       unsigned long r_symndx;
4143       enum elf_ppc64_reloc_type r_type;
4144       struct elf_link_hash_entry *h = NULL;
4145       char tls_type = 0;
4146
4147       r_symndx = ELF64_R_SYM (rel->r_info);
4148       r_type = ELF64_R_TYPE (rel->r_info);
4149       if (r_symndx >= symtab_hdr->sh_info)
4150         {
4151           struct ppc_link_hash_entry *eh;
4152           struct ppc_dyn_relocs **pp;
4153           struct ppc_dyn_relocs *p;
4154
4155           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4156           eh = (struct ppc_link_hash_entry *) h;
4157
4158           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
4159             if (p->sec == sec)
4160               {
4161                 /* Everything must go for SEC.  */
4162                 *pp = p->next;
4163                 break;
4164               }
4165         }
4166
4167       switch (r_type)
4168         {
4169         case R_PPC64_GOT_TLSLD16:
4170         case R_PPC64_GOT_TLSLD16_LO:
4171         case R_PPC64_GOT_TLSLD16_HI:
4172         case R_PPC64_GOT_TLSLD16_HA:
4173           ppc64_tlsld_got (abfd)->refcount -= 1;
4174           tls_type = TLS_TLS | TLS_LD;
4175           goto dogot;
4176
4177         case R_PPC64_GOT_TLSGD16:
4178         case R_PPC64_GOT_TLSGD16_LO:
4179         case R_PPC64_GOT_TLSGD16_HI:
4180         case R_PPC64_GOT_TLSGD16_HA:
4181           tls_type = TLS_TLS | TLS_GD;
4182           goto dogot;
4183
4184         case R_PPC64_GOT_TPREL16_DS:
4185         case R_PPC64_GOT_TPREL16_LO_DS:
4186         case R_PPC64_GOT_TPREL16_HI:
4187         case R_PPC64_GOT_TPREL16_HA:
4188           tls_type = TLS_TLS | TLS_TPREL;
4189           goto dogot;
4190
4191         case R_PPC64_GOT_DTPREL16_DS:
4192         case R_PPC64_GOT_DTPREL16_LO_DS:
4193         case R_PPC64_GOT_DTPREL16_HI:
4194         case R_PPC64_GOT_DTPREL16_HA:
4195           tls_type = TLS_TLS | TLS_DTPREL;
4196           goto dogot;
4197
4198         case R_PPC64_GOT16:
4199         case R_PPC64_GOT16_DS:
4200         case R_PPC64_GOT16_HA:
4201         case R_PPC64_GOT16_HI:
4202         case R_PPC64_GOT16_LO:
4203         case R_PPC64_GOT16_LO_DS:
4204         dogot:
4205           {
4206             struct got_entry *ent;
4207
4208             if (h != NULL)
4209               ent = h->got.glist;
4210             else
4211               ent = local_got_ents[r_symndx];
4212
4213             for (; ent != NULL; ent = ent->next)
4214               if (ent->addend == rel->r_addend
4215                   && ent->owner == abfd
4216                   && ent->tls_type == tls_type)
4217                 break;
4218             if (ent == NULL)
4219               abort ();
4220             if (ent->got.refcount > 0)
4221               ent->got.refcount -= 1;
4222           }
4223           break;
4224
4225         case R_PPC64_PLT16_HA:
4226         case R_PPC64_PLT16_HI:
4227         case R_PPC64_PLT16_LO:
4228         case R_PPC64_PLT32:
4229         case R_PPC64_PLT64:
4230         case R_PPC64_REL14:
4231         case R_PPC64_REL14_BRNTAKEN:
4232         case R_PPC64_REL14_BRTAKEN:
4233         case R_PPC64_REL24:
4234           if (h != NULL)
4235             {
4236               struct plt_entry *ent;
4237
4238               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
4239                 if (ent->addend == rel->r_addend)
4240                   break;
4241               if (ent == NULL)
4242                 abort ();
4243               if (ent->plt.refcount > 0)
4244                 ent->plt.refcount -= 1;
4245             }
4246           break;
4247
4248         default:
4249           break;
4250         }
4251     }
4252   return TRUE;
4253 }
4254
4255 /* Called via elf_link_hash_traverse to transfer dynamic linking
4256    information on function code symbol entries to their corresponding
4257    function descriptor symbol entries.  */
4258 static bfd_boolean
4259 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
4260 {
4261   struct bfd_link_info *info;
4262   struct ppc_link_hash_table *htab;
4263   struct plt_entry *ent;
4264   struct ppc_link_hash_entry *fh;
4265   struct ppc_link_hash_entry *fdh;
4266   bfd_boolean force_local;
4267
4268   fh = (struct ppc_link_hash_entry *) h;
4269   if (fh->elf.root.type == bfd_link_hash_indirect)
4270     return TRUE;
4271
4272   if (fh->elf.root.type == bfd_link_hash_warning)
4273     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
4274
4275   info = inf;
4276   htab = ppc_hash_table (info);
4277
4278   /* If this is a function code symbol, transfer dynamic linking
4279      information to the function descriptor symbol.  */
4280   if (!fh->is_func)
4281     return TRUE;
4282
4283   if (fh->elf.root.type == bfd_link_hash_undefweak
4284       && (fh->elf.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR))
4285     htab->have_undefweak = TRUE;
4286
4287   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
4288     if (ent->plt.refcount > 0)
4289       break;
4290   if (ent == NULL
4291       || fh->elf.root.root.string[0] != '.'
4292       || fh->elf.root.root.string[1] == '\0')
4293     return TRUE;
4294
4295   /* Find the corresponding function descriptor symbol.  Create it
4296      as undefined if necessary.  */
4297
4298   fdh = get_fdh (fh, htab);
4299   if (fdh != NULL)
4300     while (fdh->elf.root.type == bfd_link_hash_indirect
4301            || fdh->elf.root.type == bfd_link_hash_warning)
4302       fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
4303
4304   if (fdh == NULL
4305       && info->shared
4306       && (fh->elf.root.type == bfd_link_hash_undefined
4307           || fh->elf.root.type == bfd_link_hash_undefweak))
4308     {
4309       bfd *abfd;
4310       asymbol *newsym;
4311       struct bfd_link_hash_entry *bh;
4312
4313       abfd = fh->elf.root.u.undef.abfd;
4314       newsym = bfd_make_empty_symbol (abfd);
4315       newsym->name = fh->elf.root.root.string + 1;
4316       newsym->section = bfd_und_section_ptr;
4317       newsym->value = 0;
4318       newsym->flags = BSF_OBJECT;
4319       if (fh->elf.root.type == bfd_link_hash_undefweak)
4320         newsym->flags |= BSF_WEAK;
4321
4322       bh = &fdh->elf.root;
4323       if ( !(_bfd_generic_link_add_one_symbol
4324              (info, abfd, newsym->name, newsym->flags,
4325               newsym->section, newsym->value, NULL, FALSE, FALSE, &bh)))
4326         {
4327           return FALSE;
4328         }
4329       fdh = (struct ppc_link_hash_entry *) bh;
4330       fdh->elf.elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4331       fdh->elf.size = 24;
4332       fdh->elf.type = STT_OBJECT;
4333     }
4334
4335   if (fdh != NULL
4336       && (fdh->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
4337       && (info->shared
4338           || (fdh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4339           || (fdh->elf.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
4340           || (fdh->elf.root.type == bfd_link_hash_undefweak
4341               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
4342     {
4343       if (fdh->elf.dynindx == -1)
4344         if (! bfd_elf64_link_record_dynamic_symbol (info, &fdh->elf))
4345           return FALSE;
4346       fdh->elf.elf_link_hash_flags
4347         |= (fh->elf.elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
4348                                       | ELF_LINK_HASH_REF_DYNAMIC
4349                                       | ELF_LINK_HASH_REF_REGULAR_NONWEAK
4350                                       | ELF_LINK_NON_GOT_REF));
4351       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
4352         {
4353           fdh->elf.plt.plist = fh->elf.plt.plist;
4354           fdh->elf.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
4355         }
4356       fdh->is_func_descriptor = 1;
4357       fdh->oh = &fh->elf;
4358       fh->oh = &fdh->elf;
4359     }
4360
4361   /* Now that the info is on the function descriptor, clear the
4362      function code sym info.  Any function code syms for which we
4363      don't have a definition in a regular file, we force local.
4364      This prevents a shared library from exporting syms that have
4365      been imported from another library.  Function code syms that
4366      are really in the library we must leave global to prevent the
4367      linker dragging in a definition from a static library.  */
4368   force_local
4369     = (info->shared
4370        && ((fh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
4371            || fdh == NULL
4372            || (fdh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
4373            || (fdh->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0));
4374   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
4375
4376   return TRUE;
4377 }
4378
4379 #define MIN_SAVE_FPR 14
4380 #define MAX_SAVE_FPR 31
4381
4382 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
4383    this hook to a) provide some gcc support functions, and b) transfer
4384    dynamic linking information gathered so far on function code symbol
4385    entries, to their corresponding function descriptor symbol entries.  */
4386 static bfd_boolean
4387 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
4388                             struct bfd_link_info *info)
4389 {
4390   struct ppc_link_hash_table *htab;
4391   unsigned int lowest_savef = MAX_SAVE_FPR + 2;
4392   unsigned int lowest_restf = MAX_SAVE_FPR + 2;
4393   unsigned int i;
4394   struct elf_link_hash_entry *h;
4395   bfd_byte *p;
4396   char sym[10];
4397
4398   htab = ppc_hash_table (info);
4399
4400   if (htab->sfpr == NULL)
4401     /* We don't have any relocs.  */
4402     return TRUE;
4403
4404   /* First provide any missing ._savef* and ._restf* functions.  */
4405   memcpy (sym, "._savef14", 10);
4406   for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
4407     {
4408       sym[7] = i / 10 + '0';
4409       sym[8] = i % 10 + '0';
4410       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
4411       if (h != NULL
4412           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4413         {
4414           if (lowest_savef > i)
4415             lowest_savef = i;
4416           h->root.type = bfd_link_hash_defined;
4417           h->root.u.def.section = htab->sfpr;
4418           h->root.u.def.value = (i - lowest_savef) * 4;
4419           h->type = STT_FUNC;
4420           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4421           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
4422         }
4423     }
4424
4425   memcpy (sym, "._restf14", 10);
4426   for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
4427     {
4428       sym[7] = i / 10 + '0';
4429       sym[8] = i % 10 + '0';
4430       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
4431       if (h != NULL
4432           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4433         {
4434           if (lowest_restf > i)
4435             lowest_restf = i;
4436           h->root.type = bfd_link_hash_defined;
4437           h->root.u.def.section = htab->sfpr;
4438           h->root.u.def.value = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
4439                                  + (i - lowest_restf) * 4);
4440           h->type = STT_FUNC;
4441           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4442           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
4443         }
4444     }
4445
4446   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
4447
4448   htab->sfpr->_raw_size = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
4449                            + (MAX_SAVE_FPR + 2 - lowest_restf) * 4);
4450
4451   if (htab->sfpr->_raw_size == 0)
4452     {
4453       if (!htab->have_undefweak)
4454         {
4455           _bfd_strip_section_from_output (info, htab->sfpr);
4456           return TRUE;
4457         }
4458
4459       htab->sfpr->_raw_size = 4;
4460     }
4461
4462   p = bfd_alloc (htab->elf.dynobj, htab->sfpr->_raw_size);
4463   if (p == NULL)
4464     return FALSE;
4465   htab->sfpr->contents = p;
4466
4467   for (i = lowest_savef; i <= MAX_SAVE_FPR; i++)
4468     {
4469       unsigned int fpr = i << 21;
4470       unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
4471       bfd_put_32 (htab->elf.dynobj, STFD_FR0_0R1 + fpr + stackoff, p);
4472       p += 4;
4473     }
4474   if (lowest_savef <= MAX_SAVE_FPR)
4475     {
4476       bfd_put_32 (htab->elf.dynobj, BLR, p);
4477       p += 4;
4478     }
4479
4480   for (i = lowest_restf; i <= MAX_SAVE_FPR; i++)
4481     {
4482       unsigned int fpr = i << 21;
4483       unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
4484       bfd_put_32 (htab->elf.dynobj, LFD_FR0_0R1 + fpr + stackoff, p);
4485       p += 4;
4486     }
4487   if (lowest_restf <= MAX_SAVE_FPR
4488       || htab->sfpr->_raw_size == 4)
4489     {
4490       bfd_put_32 (htab->elf.dynobj, BLR, p);
4491     }
4492
4493   return TRUE;
4494 }
4495
4496 /* Adjust a symbol defined by a dynamic object and referenced by a
4497    regular object.  The current definition is in some section of the
4498    dynamic object, but we're not including those sections.  We have to
4499    change the definition to something the rest of the link can
4500    understand.  */
4501
4502 static bfd_boolean
4503 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
4504                                  struct elf_link_hash_entry *h)
4505 {
4506   struct ppc_link_hash_table *htab;
4507   asection *s;
4508   unsigned int power_of_two;
4509
4510   htab = ppc_hash_table (info);
4511
4512   /* Deal with function syms.  */
4513   if (h->type == STT_FUNC
4514       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4515     {
4516       /* Clear procedure linkage table information for any symbol that
4517          won't need a .plt entry.  */
4518       struct plt_entry *ent;
4519       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
4520         if (ent->plt.refcount > 0)
4521           break;
4522       if (!((struct ppc_link_hash_entry *) h)->is_func_descriptor
4523           || ent == NULL
4524           || SYMBOL_CALLS_LOCAL (info, h)
4525           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4526               && h->root.type == bfd_link_hash_undefweak))
4527         {
4528           h->plt.plist = NULL;
4529           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4530         }
4531     }
4532   else
4533     h->plt.plist = NULL;
4534
4535   /* If this is a weak symbol, and there is a real definition, the
4536      processor independent code will have arranged for us to see the
4537      real definition first, and we can just use the same value.  */
4538   if (h->weakdef != NULL)
4539     {
4540       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
4541                   || h->weakdef->root.type == bfd_link_hash_defweak);
4542       h->root.u.def.section = h->weakdef->root.u.def.section;
4543       h->root.u.def.value = h->weakdef->root.u.def.value;
4544       if (ELIMINATE_COPY_RELOCS)
4545         h->elf_link_hash_flags
4546           = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
4547              | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
4548       return TRUE;
4549     }
4550
4551   /* If we are creating a shared library, we must presume that the
4552      only references to the symbol are via the global offset table.
4553      For such cases we need not do anything here; the relocations will
4554      be handled correctly by relocate_section.  */
4555   if (info->shared)
4556     return TRUE;
4557
4558   /* If there are no references to this symbol that do not use the
4559      GOT, we don't need to generate a copy reloc.  */
4560   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
4561     return TRUE;
4562
4563   if (ELIMINATE_COPY_RELOCS)
4564     {
4565       struct ppc_link_hash_entry * eh;
4566       struct ppc_dyn_relocs *p;
4567
4568       eh = (struct ppc_link_hash_entry *) h;
4569       for (p = eh->dyn_relocs; p != NULL; p = p->next)
4570         {
4571           s = p->sec->output_section;
4572           if (s != NULL && (s->flags & SEC_READONLY) != 0)
4573             break;
4574         }
4575
4576       /* If we didn't find any dynamic relocs in read-only sections, then
4577          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
4578       if (p == NULL)
4579         {
4580           h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
4581           return TRUE;
4582         }
4583     }
4584
4585   if (h->plt.plist != NULL)
4586     return TRUE;
4587
4588   /* This is a reference to a symbol defined by a dynamic object which
4589      is not a function.  */
4590
4591   /* We must allocate the symbol in our .dynbss section, which will
4592      become part of the .bss section of the executable.  There will be
4593      an entry for this symbol in the .dynsym section.  The dynamic
4594      object will contain position independent code, so all references
4595      from the dynamic object to this symbol will go through the global
4596      offset table.  The dynamic linker will use the .dynsym entry to
4597      determine the address it must put in the global offset table, so
4598      both the dynamic object and the regular object will refer to the
4599      same memory location for the variable.  */
4600
4601   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
4602      to copy the initial value out of the dynamic object and into the
4603      runtime process image.  We need to remember the offset into the
4604      .rela.bss section we are going to use.  */
4605   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4606     {
4607       htab->relbss->_raw_size += sizeof (Elf64_External_Rela);
4608       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
4609     }
4610
4611   /* We need to figure out the alignment required for this symbol.  I
4612      have no idea how ELF linkers handle this.  */
4613   power_of_two = bfd_log2 (h->size);
4614   if (power_of_two > 4)
4615     power_of_two = 4;
4616
4617   /* Apply the required alignment.  */
4618   s = htab->dynbss;
4619   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
4620   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
4621     {
4622       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
4623         return FALSE;
4624     }
4625
4626   /* Define the symbol as being at this point in the section.  */
4627   h->root.u.def.section = s;
4628   h->root.u.def.value = s->_raw_size;
4629
4630   /* Increment the section size to make room for the symbol.  */
4631   s->_raw_size += h->size;
4632
4633   return TRUE;
4634 }
4635
4636 /* If given a function descriptor symbol, hide both the function code
4637    sym and the descriptor.  */
4638 static void
4639 ppc64_elf_hide_symbol (struct bfd_link_info *info,
4640                        struct elf_link_hash_entry *h,
4641                        bfd_boolean force_local)
4642 {
4643   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
4644
4645   if (((struct ppc_link_hash_entry *) h)->is_func_descriptor)
4646     {
4647       struct elf_link_hash_entry *fh = ((struct ppc_link_hash_entry *) h)->oh;
4648
4649       if (fh == NULL)
4650         {
4651           const char *p, *q;
4652           struct ppc_link_hash_table *htab;
4653           char save;
4654
4655           /* We aren't supposed to use alloca in BFD because on
4656              systems which do not have alloca the version in libiberty
4657              calls xmalloc, which might cause the program to crash
4658              when it runs out of memory.  This function doesn't have a
4659              return status, so there's no way to gracefully return an
4660              error.  So cheat.  We know that string[-1] can be safely
4661              dereferenced;  It's either a string in an ELF string
4662              table, or allocated in an objalloc structure.  */
4663
4664           p = h->root.root.string - 1;
4665           save = *p;
4666           *(char *) p = '.';
4667           htab = ppc_hash_table (info);
4668           fh = elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
4669           *(char *) p = save;
4670
4671           /* Unfortunately, if it so happens that the string we were
4672              looking for was allocated immediately before this string,
4673              then we overwrote the string terminator.  That's the only
4674              reason the lookup should fail.  */
4675           if (fh == NULL)
4676             {
4677               q = h->root.root.string + strlen (h->root.root.string);
4678               while (q >= h->root.root.string && *q == *p)
4679                 --q, --p;
4680               if (q < h->root.root.string && *p == '.')
4681                 fh = elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
4682             }
4683           if (fh != NULL)
4684             {
4685               ((struct ppc_link_hash_entry *) h)->oh = fh;
4686               ((struct ppc_link_hash_entry *) fh)->oh = h;
4687             }
4688         }
4689       if (fh != NULL)
4690         _bfd_elf_link_hash_hide_symbol (info, fh, force_local);
4691     }
4692 }
4693
4694 static bfd_boolean
4695 get_sym_h (struct elf_link_hash_entry **hp, Elf_Internal_Sym **symp,
4696            asection **symsecp, char **tls_maskp, Elf_Internal_Sym **locsymsp,
4697            unsigned long r_symndx, bfd *ibfd)
4698 {
4699   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4700
4701   if (r_symndx >= symtab_hdr->sh_info)
4702     {
4703       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
4704       struct elf_link_hash_entry *h;
4705
4706       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4707       while (h->root.type == bfd_link_hash_indirect
4708              || h->root.type == bfd_link_hash_warning)
4709         h = (struct elf_link_hash_entry *) h->root.u.i.link;
4710
4711       if (hp != NULL)
4712         *hp = h;
4713
4714       if (symp != NULL)
4715         *symp = NULL;
4716
4717       if (symsecp != NULL)
4718         {
4719           asection *symsec = NULL;
4720           if (h->root.type == bfd_link_hash_defined
4721               || h->root.type == bfd_link_hash_defweak)
4722             symsec = h->root.u.def.section;
4723           *symsecp = symsec;
4724         }
4725
4726       if (tls_maskp != NULL)
4727         {
4728           struct ppc_link_hash_entry *eh;
4729
4730           eh = (struct ppc_link_hash_entry *) h;
4731           *tls_maskp = &eh->tls_mask;
4732         }
4733     }
4734   else
4735     {
4736       Elf_Internal_Sym *sym;
4737       Elf_Internal_Sym *locsyms = *locsymsp;
4738
4739       if (locsyms == NULL)
4740         {
4741           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
4742           if (locsyms == NULL)
4743             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
4744                                             symtab_hdr->sh_info,
4745                                             0, NULL, NULL, NULL);
4746           if (locsyms == NULL)
4747             return FALSE;
4748           *locsymsp = locsyms;
4749         }
4750       sym = locsyms + r_symndx;
4751
4752       if (hp != NULL)
4753         *hp = NULL;
4754
4755       if (symp != NULL)
4756         *symp = sym;
4757
4758       if (symsecp != NULL)
4759         {
4760           asection *symsec = NULL;
4761           if ((sym->st_shndx != SHN_UNDEF
4762                && sym->st_shndx < SHN_LORESERVE)
4763               || sym->st_shndx > SHN_HIRESERVE)
4764             symsec = bfd_section_from_elf_index (ibfd, sym->st_shndx);
4765           *symsecp = symsec;
4766         }
4767
4768       if (tls_maskp != NULL)
4769         {
4770           struct got_entry **lgot_ents;
4771           char *tls_mask;
4772
4773           tls_mask = NULL;
4774           lgot_ents = elf_local_got_ents (ibfd);
4775           if (lgot_ents != NULL)
4776             {
4777               char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
4778               tls_mask = &lgot_masks[r_symndx];
4779             }
4780           *tls_maskp = tls_mask;
4781         }
4782     }
4783   return TRUE;
4784 }
4785
4786 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
4787    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
4788    type suitable for optimization, and 1 otherwise.  */
4789
4790 static int
4791 get_tls_mask (char **tls_maskp, Elf_Internal_Sym **locsymsp,
4792               const Elf_Internal_Rela *rel, bfd *ibfd)
4793 {
4794   unsigned long r_symndx;
4795   unsigned int next_r;
4796   struct elf_link_hash_entry *h;
4797   Elf_Internal_Sym *sym;
4798   asection *sec;
4799   bfd_vma off;
4800
4801   r_symndx = ELF64_R_SYM (rel->r_info);
4802   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
4803     return 0;
4804
4805   if ((*tls_maskp != NULL && **tls_maskp != 0)
4806       || sec == NULL
4807       || ppc64_elf_section_data (sec)->t_symndx == NULL)
4808     return 1;
4809
4810   /* Look inside a TOC section too.  */
4811   if (h != NULL)
4812     {
4813       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
4814       off = h->root.u.def.value;
4815     }
4816   else
4817     off = sym->st_value;
4818   off += rel->r_addend;
4819   BFD_ASSERT (off % 8 == 0);
4820   r_symndx = ppc64_elf_section_data (sec)->t_symndx[off / 8];
4821   next_r = ppc64_elf_section_data (sec)->t_symndx[off / 8 + 1];
4822   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
4823     return 0;
4824   if (h == NULL
4825       || h->root.type == bfd_link_hash_defined
4826       || h->root.type == bfd_link_hash_defweak)
4827     {
4828       if (next_r == (unsigned) -1)
4829         return 2;
4830       if (next_r == (unsigned) -2
4831           && (h == NULL
4832               || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)))
4833         return 3;
4834     }
4835   return 1;
4836 }
4837
4838 bfd_boolean
4839 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info)
4840 {
4841   bfd *ibfd;
4842
4843   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4844     {
4845       asection *sec;
4846       Elf_Internal_Rela *relstart, *rel, *relend;
4847       Elf_Internal_Shdr *symtab_hdr;
4848       Elf_Internal_Sym *local_syms;
4849       struct elf_link_hash_entry **sym_hashes;
4850       bfd_vma offset;
4851       bfd_size_type amt;
4852       long *adjust;
4853       bfd_boolean need_edit;
4854
4855       sec = bfd_get_section_by_name (ibfd, ".opd");
4856       if (sec == NULL)
4857         continue;
4858
4859       amt = sec->_raw_size * sizeof (long) / 24;
4860       adjust = ppc64_elf_section_data (sec)->opd.adjust;
4861       if (adjust == NULL)
4862         {
4863           /* Must be a ld -r link.  ie. check_relocs hasn't been
4864              called.  */
4865           adjust = bfd_zalloc (obfd, amt);
4866           ppc64_elf_section_data (sec)->opd.adjust = adjust;
4867         }
4868       memset (adjust, 0, amt);
4869
4870       if (sec->output_section == bfd_abs_section_ptr)
4871         continue;
4872
4873       /* Look through the section relocs.  */
4874       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
4875         continue;
4876
4877       local_syms = NULL;
4878       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4879       sym_hashes = elf_sym_hashes (ibfd);
4880
4881       /* Read the relocations.  */
4882       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
4883                                             info->keep_memory);
4884       if (relstart == NULL)
4885         return FALSE;
4886
4887       /* First run through the relocs to check they are sane, and to
4888          determine whether we need to edit this opd section.  */
4889       need_edit = FALSE;
4890       offset = 0;
4891       relend = relstart + sec->reloc_count;
4892       for (rel = relstart; rel < relend; )
4893         {
4894           enum elf_ppc64_reloc_type r_type;
4895           unsigned long r_symndx;
4896           asection *sym_sec;
4897           struct elf_link_hash_entry *h;
4898           Elf_Internal_Sym *sym;
4899
4900           /* .opd contains a regular array of 24 byte entries.  We're
4901              only interested in the reloc pointing to a function entry
4902              point.  */
4903           if (rel->r_offset != offset
4904               || rel + 1 >= relend
4905               || (rel + 1)->r_offset != offset + 8)
4906             {
4907               /* If someone messes with .opd alignment then after a
4908                  "ld -r" we might have padding in the middle of .opd.
4909                  Also, there's nothing to prevent someone putting
4910                  something silly in .opd with the assembler.  No .opd
4911                  optimization for them!  */
4912               (*_bfd_error_handler)
4913                 (_("%s: .opd is not a regular array of opd entries"),
4914                  bfd_archive_filename (ibfd));
4915               need_edit = FALSE;
4916               break;
4917             }
4918
4919           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
4920               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
4921             {
4922               (*_bfd_error_handler)
4923                 (_("%s: unexpected reloc type %u in .opd section"),
4924                  bfd_archive_filename (ibfd), r_type);
4925               need_edit = FALSE;
4926               break;
4927             }
4928
4929           r_symndx = ELF64_R_SYM (rel->r_info);
4930           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
4931                           r_symndx, ibfd))
4932             goto error_ret;
4933
4934           if (sym_sec == NULL || sym_sec->owner == NULL)
4935             {
4936               const char *sym_name;
4937               if (h != NULL)
4938                 sym_name = h->root.root.string;
4939               else
4940                 sym_name = bfd_elf_local_sym_name (ibfd, sym);
4941
4942               (*_bfd_error_handler)
4943                 (_("%s: undefined sym `%s' in .opd section"),
4944                  bfd_archive_filename (ibfd),
4945                  sym_name);
4946               need_edit = FALSE;
4947               break;
4948             }
4949
4950           /* opd entries are always for functions defined in the
4951              current input bfd.  If the symbol isn't defined in the
4952              input bfd, then we won't be using the function in this
4953              bfd;  It must be defined in a linkonce section in another
4954              bfd, or is weak.  It's also possible that we are
4955              discarding the function due to a linker script /DISCARD/,
4956              which we test for via the output_section.  */
4957           if (sym_sec->owner != ibfd
4958               || sym_sec->output_section == bfd_abs_section_ptr)
4959             need_edit = TRUE;
4960
4961           offset += 24;
4962           rel += 2;
4963           /* Allow for the possibility of a reloc on the third word.  */
4964           if (rel < relend
4965               && rel->r_offset == offset - 8)
4966             rel += 1;
4967         }
4968
4969       if (need_edit)
4970         {
4971           Elf_Internal_Rela *write_rel;
4972           bfd_byte *rptr, *wptr;
4973           bfd_boolean skip;
4974
4975           /* This seems a waste of time as input .opd sections are all
4976              zeros as generated by gcc, but I suppose there's no reason
4977              this will always be so.  We might start putting something in
4978              the third word of .opd entries.  */
4979           if ((sec->flags & SEC_IN_MEMORY) == 0)
4980             {
4981               bfd_byte *loc = bfd_alloc (ibfd, sec->_raw_size);
4982               if (loc == NULL
4983                   || !bfd_get_section_contents (ibfd, sec, loc, 0,
4984                                                 sec->_raw_size))
4985                 {
4986                 error_ret:
4987                   if (local_syms != NULL
4988                       && symtab_hdr->contents != (unsigned char *) local_syms)
4989                     free (local_syms);
4990                   if (elf_section_data (sec)->relocs != relstart)
4991                     free (relstart);
4992                   return FALSE;
4993                 }
4994               sec->contents = loc;
4995               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
4996             }
4997
4998           elf_section_data (sec)->relocs = relstart;
4999
5000           wptr = sec->contents;
5001           rptr = sec->contents;
5002           write_rel = relstart;
5003           skip = FALSE;
5004           offset = 0;
5005           for (rel = relstart; rel < relend; rel++)
5006             {
5007               unsigned long r_symndx;
5008               asection *sym_sec;
5009               struct elf_link_hash_entry *h;
5010               Elf_Internal_Sym *sym;
5011
5012               r_symndx = ELF64_R_SYM (rel->r_info);
5013               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
5014                               r_symndx, ibfd))
5015                 goto error_ret;
5016
5017               if (rel->r_offset == offset)
5018                 {
5019                   struct ppc_link_hash_entry *fdh = NULL;
5020                   if (h != NULL)
5021                     fdh = get_fdh ((struct ppc_link_hash_entry *) h,
5022                                    ppc_hash_table (info));
5023
5024                   skip = (sym_sec->owner != ibfd
5025                           || sym_sec->output_section == bfd_abs_section_ptr);
5026                   if (skip)
5027                     {
5028                       if (h != NULL && sym_sec->owner == ibfd)
5029                         {
5030                           /* Arrange for the function descriptor sym
5031                              to be dropped.  */
5032                           fdh->elf.root.u.def.value = 0;
5033                           fdh->elf.root.u.def.section = sym_sec;
5034                         }
5035                     }
5036                   else
5037                     {
5038                       /* We'll be keeping this opd entry.  */
5039
5040                       if (h != NULL)
5041                         {
5042                           /* Redefine the function descriptor symbol
5043                              to this location in the opd section.
5044                              We've checked above that opd relocs are
5045                              ordered.  */
5046                           fdh->elf.root.u.def.value = wptr - sec->contents;
5047                         }
5048                       else
5049                         {
5050                           /* Local syms are a bit tricky.  We could
5051                              tweak them as they can be cached, but
5052                              we'd need to look through the local syms
5053                              for the function descriptor sym which we
5054                              don't have at the moment.  So keep an
5055                              array of adjustments.  */
5056                           adjust[rel->r_offset / 24] = wptr - rptr;
5057                         }
5058
5059                       if (wptr != rptr)
5060                         memcpy (wptr, rptr, 24);
5061                       wptr += 24;
5062                     }
5063                   rptr += 24;
5064                   offset += 24;
5065                 }
5066
5067               if (skip)
5068                 {
5069                   BFD_ASSERT (MUST_BE_DYN_RELOC (ELF64_R_TYPE (rel->r_info)));
5070                   if (info->shared)
5071                     {
5072                       /* We won't be needing dynamic relocs here.  */
5073                       struct ppc_dyn_relocs **pp;
5074                       struct ppc_dyn_relocs *p;
5075
5076                       if (h != NULL)
5077                         pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5078                       else if (sym_sec != NULL)
5079                         pp = ((struct ppc_dyn_relocs **)
5080                               &elf_section_data (sym_sec)->local_dynrel);
5081                       else
5082                         pp = ((struct ppc_dyn_relocs **)
5083                               &elf_section_data (sec)->local_dynrel);
5084                       while ((p = *pp) != NULL)
5085                         {
5086                           if (p->sec == sec)
5087                             {
5088                               p->count -= 1;
5089                               if (p->count == 0)
5090                                 *pp = p->next;
5091                               break;
5092                             }
5093                           pp = &p->next;
5094                         }
5095                     }
5096                 }
5097               else
5098                 {
5099                   /* We need to adjust any reloc offsets to point to the
5100                      new opd entries.  While we're at it, we may as well
5101                      remove redundant relocs.  */
5102                   rel->r_offset += wptr - rptr;
5103                   if (write_rel != rel)
5104                     memcpy (write_rel, rel, sizeof (*rel));
5105                   ++write_rel;
5106                 }
5107             }
5108
5109           sec->_cooked_size = wptr - sec->contents;
5110           sec->reloc_count = write_rel - relstart;
5111           /* Fudge the size too, as this is used later in
5112              elf_bfd_final_link if we are emitting relocs.  */
5113           elf_section_data (sec)->rel_hdr.sh_size
5114             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
5115           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
5116         }
5117       else if (elf_section_data (sec)->relocs != relstart)
5118         free (relstart);
5119
5120       if (local_syms != NULL
5121           && symtab_hdr->contents != (unsigned char *) local_syms)
5122         {
5123           if (!info->keep_memory)
5124             free (local_syms);
5125           else
5126             symtab_hdr->contents = (unsigned char *) local_syms;
5127         }
5128     }
5129
5130   return TRUE;
5131 }
5132
5133 /* Set htab->tls_sec.  */
5134
5135 bfd_boolean
5136 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
5137 {
5138   asection *tls;
5139   struct ppc_link_hash_table *htab;
5140
5141   for (tls = obfd->sections; tls != NULL; tls = tls->next)
5142     if ((tls->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
5143         == (SEC_THREAD_LOCAL | SEC_LOAD))
5144       break;
5145
5146   htab = ppc_hash_table (info);
5147   htab->tls_sec = tls;
5148
5149   if (htab->tls_get_addr != NULL)
5150     {
5151       struct elf_link_hash_entry *h = htab->tls_get_addr;
5152
5153       while (h->root.type == bfd_link_hash_indirect
5154              || h->root.type == bfd_link_hash_warning)
5155         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5156
5157       htab->tls_get_addr = h;
5158     }
5159
5160   return tls != NULL;
5161 }
5162
5163 /* Run through all the TLS relocs looking for optimization
5164    opportunities.  The linker has been hacked (see ppc64elf.em) to do
5165    a preliminary section layout so that we know the TLS segment
5166    offsets.  We can't optimize earlier because some optimizations need
5167    to know the tp offset, and we need to optimize before allocating
5168    dynamic relocations.  */
5169
5170 bfd_boolean
5171 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
5172 {
5173   bfd *ibfd;
5174   asection *sec;
5175   struct ppc_link_hash_table *htab;
5176
5177   if (info->relocatable || info->shared)
5178     return TRUE;
5179
5180   htab = ppc_hash_table (info);
5181   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5182     {
5183       Elf_Internal_Sym *locsyms = NULL;
5184
5185       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5186         if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
5187           {
5188             Elf_Internal_Rela *relstart, *rel, *relend;
5189             int expecting_tls_get_addr;
5190
5191             /* Read the relocations.  */
5192             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
5193                                                   info->keep_memory);
5194             if (relstart == NULL)
5195               return FALSE;
5196
5197             expecting_tls_get_addr = 0;
5198             relend = relstart + sec->reloc_count;
5199             for (rel = relstart; rel < relend; rel++)
5200               {
5201                 enum elf_ppc64_reloc_type r_type;
5202                 unsigned long r_symndx;
5203                 struct elf_link_hash_entry *h;
5204                 Elf_Internal_Sym *sym;
5205                 asection *sym_sec;
5206                 char *tls_mask;
5207                 char tls_set, tls_clear, tls_type = 0;
5208                 bfd_vma value;
5209                 bfd_boolean ok_tprel, is_local;
5210
5211                 r_symndx = ELF64_R_SYM (rel->r_info);
5212                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
5213                                 r_symndx, ibfd))
5214                   {
5215                   err_free_rel:
5216                     if (elf_section_data (sec)->relocs != relstart)
5217                       free (relstart);
5218                     if (locsyms != NULL
5219                         && (elf_tdata (ibfd)->symtab_hdr.contents
5220                             != (unsigned char *) locsyms))
5221                       free (locsyms);
5222                     return FALSE;
5223                   }
5224
5225                 if (h != NULL)
5226                   {
5227                     if (h->root.type != bfd_link_hash_defined
5228                         && h->root.type != bfd_link_hash_defweak)
5229                       continue;
5230                     value = h->root.u.def.value;
5231                   }
5232                 else
5233                   value = sym->st_value;
5234
5235                 ok_tprel = FALSE;
5236                 is_local = FALSE;
5237                 if (h == NULL
5238                     || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
5239                   {
5240                     is_local = TRUE;
5241                     value += sym_sec->output_offset;
5242                     value += sym_sec->output_section->vma;
5243                     value -= htab->tls_sec->vma;
5244                     ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
5245                                 < (bfd_vma) 1 << 32);
5246                   }
5247
5248                 r_type = ELF64_R_TYPE (rel->r_info);
5249                 switch (r_type)
5250                   {
5251                   case R_PPC64_GOT_TLSLD16:
5252                   case R_PPC64_GOT_TLSLD16_LO:
5253                   case R_PPC64_GOT_TLSLD16_HI:
5254                   case R_PPC64_GOT_TLSLD16_HA:
5255                     /* These relocs should never be against a symbol
5256                        defined in a shared lib.  Leave them alone if
5257                        that turns out to be the case.  */
5258                     ppc64_tlsld_got (ibfd)->refcount -= 1;
5259                     if (!is_local)
5260                       continue;
5261
5262                     /* LD -> LE */
5263                     tls_set = 0;
5264                     tls_clear = TLS_LD;
5265                     tls_type = TLS_TLS | TLS_LD;
5266                     expecting_tls_get_addr = 1;
5267                     break;
5268
5269                   case R_PPC64_GOT_TLSGD16:
5270                   case R_PPC64_GOT_TLSGD16_LO:
5271                   case R_PPC64_GOT_TLSGD16_HI:
5272                   case R_PPC64_GOT_TLSGD16_HA:
5273                     if (ok_tprel)
5274                       /* GD -> LE */
5275                       tls_set = 0;
5276                     else
5277                       /* GD -> IE */
5278                       tls_set = TLS_TLS | TLS_TPRELGD;
5279                     tls_clear = TLS_GD;
5280                     tls_type = TLS_TLS | TLS_GD;
5281                     expecting_tls_get_addr = 1;
5282                     break;
5283
5284                   case R_PPC64_GOT_TPREL16_DS:
5285                   case R_PPC64_GOT_TPREL16_LO_DS:
5286                   case R_PPC64_GOT_TPREL16_HI:
5287                   case R_PPC64_GOT_TPREL16_HA:
5288                     expecting_tls_get_addr = 0;
5289                     if (ok_tprel)
5290                       {
5291                         /* IE -> LE */
5292                         tls_set = 0;
5293                         tls_clear = TLS_TPREL;
5294                         tls_type = TLS_TLS | TLS_TPREL;
5295                         break;
5296                       }
5297                     else
5298                       continue;
5299
5300                   case R_PPC64_REL14:
5301                   case R_PPC64_REL14_BRTAKEN:
5302                   case R_PPC64_REL14_BRNTAKEN:
5303                   case R_PPC64_REL24:
5304                     if (h != NULL
5305                         && h == htab->tls_get_addr)
5306                       {
5307                         if (!expecting_tls_get_addr
5308                             && rel != relstart
5309                             && ((ELF64_R_TYPE (rel[-1].r_info)
5310                                  == R_PPC64_TOC16)
5311                                 || (ELF64_R_TYPE (rel[-1].r_info)
5312                                     == R_PPC64_TOC16_LO)))
5313                           {
5314                             /* Check for toc tls entries.  */
5315                             char *toc_tls;
5316                             int retval;
5317
5318                             retval = get_tls_mask (&toc_tls, &locsyms,
5319                                                    rel - 1, ibfd);
5320                             if (retval == 0)
5321                               goto err_free_rel;
5322                             if (toc_tls != NULL)
5323                               expecting_tls_get_addr = retval > 1;
5324                           }
5325
5326                         if (expecting_tls_get_addr)
5327                           {
5328                             struct plt_entry *ent;
5329                             for (ent = h->plt.plist; ent; ent = ent->next)
5330                               if (ent->addend == 0)
5331                                 {
5332                                   if (ent->plt.refcount > 0)
5333                                     ent->plt.refcount -= 1;
5334                                   break;
5335                                 }
5336                           }
5337                       }
5338                     expecting_tls_get_addr = 0;
5339                     continue;
5340
5341                   case R_PPC64_TPREL64:
5342                     expecting_tls_get_addr = 0;
5343                     if (ok_tprel)
5344                       {
5345                         /* IE -> LE */
5346                         tls_set = TLS_EXPLICIT;
5347                         tls_clear = TLS_TPREL;
5348                         break;
5349                       }
5350                     else
5351                       continue;
5352
5353                   case R_PPC64_DTPMOD64:
5354                     expecting_tls_get_addr = 0;
5355                     if (rel + 1 < relend
5356                         && (rel[1].r_info
5357                             == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
5358                         && rel[1].r_offset == rel->r_offset + 8)
5359                       {
5360                         if (ok_tprel)
5361                           /* GD -> LE */
5362                           tls_set = TLS_EXPLICIT | TLS_GD;
5363                         else
5364                           /* GD -> IE */
5365                           tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
5366                         tls_clear = TLS_GD;
5367                       }
5368                     else
5369                       {
5370                         if (!is_local)
5371                           continue;
5372
5373                         /* LD -> LE */
5374                         tls_set = TLS_EXPLICIT;
5375                         tls_clear = TLS_LD;
5376                       }
5377                     break;
5378
5379                   default:
5380                     expecting_tls_get_addr = 0;
5381                     continue;
5382                   }
5383
5384                 if ((tls_set & TLS_EXPLICIT) == 0)
5385                   {
5386                     struct got_entry *ent;
5387
5388                     /* Adjust got entry for this reloc.  */
5389                     if (h != NULL)
5390                       ent = h->got.glist;
5391                     else
5392                       ent = elf_local_got_ents (ibfd)[r_symndx];
5393
5394                     for (; ent != NULL; ent = ent->next)
5395                       if (ent->addend == rel->r_addend
5396                           && ent->owner == ibfd
5397                           && ent->tls_type == tls_type)
5398                         break;
5399                     if (ent == NULL)
5400                       abort ();
5401
5402                     if (tls_set == 0)
5403                       {
5404                         /* We managed to get rid of a got entry.  */
5405                         if (ent->got.refcount > 0)
5406                           ent->got.refcount -= 1;
5407                       }
5408                   }
5409                 else if (h != NULL)
5410                   {
5411                     struct ppc_link_hash_entry * eh;
5412                     struct ppc_dyn_relocs **pp;
5413                     struct ppc_dyn_relocs *p;
5414
5415                     /* Adjust dynamic relocs.  */
5416                     eh = (struct ppc_link_hash_entry *) h;
5417                     for (pp = &eh->dyn_relocs;
5418                          (p = *pp) != NULL;
5419                          pp = &p->next)
5420                       if (p->sec == sec)
5421                         {
5422                           /* If we got rid of a DTPMOD/DTPREL reloc
5423                              pair then we'll lose one or two dyn
5424                              relocs.  */
5425                           if (tls_set == (TLS_EXPLICIT | TLS_GD))
5426                             p->count -= 1;
5427                           p->count -= 1;
5428                           if (p->count == 0)
5429                             *pp = p->next;
5430                           break;
5431                         }
5432                   }
5433
5434                 *tls_mask |= tls_set;
5435                 *tls_mask &= ~tls_clear;
5436               }
5437
5438             if (elf_section_data (sec)->relocs != relstart)
5439               free (relstart);
5440           }
5441
5442       if (locsyms != NULL
5443           && (elf_tdata (ibfd)->symtab_hdr.contents
5444               != (unsigned char *) locsyms))
5445         {
5446           if (!info->keep_memory)
5447             free (locsyms);
5448           else
5449             elf_tdata (ibfd)->symtab_hdr.contents = (unsigned char *) locsyms;
5450         }
5451     }
5452   return TRUE;
5453 }
5454
5455 /* This is the condition under which ppc64_elf_finish_dynamic_symbol
5456    will be called from elflink.h.  If elflink.h doesn't call our
5457    finish_dynamic_symbol routine, we'll need to do something about
5458    initializing any .plt and .got entries in ppc64_elf_relocate_section.  */
5459 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
5460   ((DYN)                                                                \
5461    && ((SHARED)                                                         \
5462        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
5463    && ((H)->dynindx != -1                                               \
5464        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
5465
5466 /* Allocate space in .plt, .got and associated reloc sections for
5467    dynamic relocs.  */
5468
5469 static bfd_boolean
5470 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5471 {
5472   struct bfd_link_info *info;
5473   struct ppc_link_hash_table *htab;
5474   asection *s;
5475   struct ppc_link_hash_entry *eh;
5476   struct ppc_dyn_relocs *p;
5477   struct got_entry *gent;
5478
5479   if (h->root.type == bfd_link_hash_indirect)
5480     return TRUE;
5481
5482   if (h->root.type == bfd_link_hash_warning)
5483     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5484
5485   info = (struct bfd_link_info *) inf;
5486   htab = ppc_hash_table (info);
5487
5488   if (htab->elf.dynamic_sections_created
5489       && h->dynindx != -1
5490       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
5491     {
5492       struct plt_entry *pent;
5493       bfd_boolean doneone = FALSE;
5494       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
5495         if (pent->plt.refcount > 0)
5496           {
5497             BFD_ASSERT (((struct ppc_link_hash_entry *) h)->is_func_descriptor);
5498
5499             /* If this is the first .plt entry, make room for the special
5500                first entry.  */
5501             s = htab->plt;
5502             if (s->_raw_size == 0)
5503               s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
5504
5505             pent->plt.offset = s->_raw_size;
5506
5507             /* Make room for this entry.  */
5508             s->_raw_size += PLT_ENTRY_SIZE;
5509
5510             /* Make room for the .glink code.  */
5511             s = htab->glink;
5512             if (s->_raw_size == 0)
5513               s->_raw_size += GLINK_CALL_STUB_SIZE;
5514             /* We need bigger stubs past index 32767.  */
5515             if (s->_raw_size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
5516               s->_raw_size += 4;
5517             s->_raw_size += 2*4;
5518
5519             /* We also need to make an entry in the .rela.plt section.  */
5520             s = htab->relplt;
5521             s->_raw_size += sizeof (Elf64_External_Rela);
5522             doneone = TRUE;
5523           }
5524         else
5525           pent->plt.offset = (bfd_vma) -1;
5526       if (!doneone)
5527         {
5528           h->plt.plist = NULL;
5529           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
5530         }
5531     }
5532   else
5533     {
5534       h->plt.plist = NULL;
5535       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
5536     }
5537
5538   eh = (struct ppc_link_hash_entry *) h;
5539   /* Run through the TLS GD got entries first if we're changing them
5540      to TPREL.  */
5541   if ((eh->tls_mask & TLS_TPRELGD) != 0)
5542     for (gent = h->got.glist; gent != NULL; gent = gent->next)
5543       if (gent->got.refcount > 0
5544           && (gent->tls_type & TLS_GD) != 0)
5545         {
5546           /* This was a GD entry that has been converted to TPREL.  If
5547              there happens to be a TPREL entry we can use that one.  */
5548           struct got_entry *ent;
5549           for (ent = h->got.glist; ent != NULL; ent = ent->next)
5550             if (ent->got.refcount > 0
5551                 && (ent->tls_type & TLS_TPREL) != 0
5552                 && ent->addend == gent->addend
5553                 && ent->owner == gent->owner)
5554               {
5555                 gent->got.refcount = 0;
5556                 break;
5557               }
5558
5559           /* If not, then we'll be using our own TPREL entry.  */
5560           if (gent->got.refcount != 0)
5561             gent->tls_type = TLS_TLS | TLS_TPREL;
5562         }
5563
5564   for (gent = h->got.glist; gent != NULL; gent = gent->next)
5565     if (gent->got.refcount > 0)
5566       {
5567         bfd_boolean dyn;
5568
5569         /* Make sure this symbol is output as a dynamic symbol.
5570            Undefined weak syms won't yet be marked as dynamic,
5571            nor will all TLS symbols.  */
5572         if (h->dynindx == -1
5573             && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
5574           {
5575             if (! bfd_elf64_link_record_dynamic_symbol (info, h))
5576               return FALSE;
5577           }
5578
5579         if ((gent->tls_type & TLS_LD) != 0
5580             && !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
5581           {
5582             gent->got.offset = ppc64_tlsld_got (gent->owner)->offset;
5583             continue;
5584           }
5585
5586         s = ppc64_elf_tdata (gent->owner)->got;
5587         gent->got.offset = s->_raw_size;
5588         s->_raw_size
5589           += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
5590         dyn = htab->elf.dynamic_sections_created;
5591         if ((info->shared
5592              || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
5593             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5594                 || h->root.type != bfd_link_hash_undefweak))
5595           ppc64_elf_tdata (gent->owner)->relgot->_raw_size
5596             += (gent->tls_type & eh->tls_mask & TLS_GD
5597                 ? 2 * sizeof (Elf64_External_Rela)
5598                 : sizeof (Elf64_External_Rela));
5599       }
5600     else
5601       gent->got.offset = (bfd_vma) -1;
5602
5603   if (eh->dyn_relocs == NULL)
5604     return TRUE;
5605
5606   /* In the shared -Bsymbolic case, discard space allocated for
5607      dynamic pc-relative relocs against symbols which turn out to be
5608      defined in regular objects.  For the normal shared case, discard
5609      space for relocs that have become local due to symbol visibility
5610      changes.  */
5611
5612   if (info->shared)
5613     {
5614       /* Relocs that use pc_count are those that appear on a call insn,
5615          or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
5616          generated via assembly.  We want calls to protected symbols to
5617          resolve directly to the function rather than going via the plt.
5618          If people want function pointer comparisons to work as expected
5619          then they should avoid writing weird assembly.  */
5620       if (SYMBOL_CALLS_LOCAL (info, h))
5621         {
5622           struct ppc_dyn_relocs **pp;
5623
5624           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5625             {
5626               p->count -= p->pc_count;
5627               p->pc_count = 0;
5628               if (p->count == 0)
5629                 *pp = p->next;
5630               else
5631                 pp = &p->next;
5632             }
5633         }
5634
5635       /* Also discard relocs on undefined weak syms with non-default
5636          visibility.  */
5637       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5638           && h->root.type == bfd_link_hash_undefweak)
5639         eh->dyn_relocs = NULL;
5640     }
5641   else if (ELIMINATE_COPY_RELOCS)
5642     {
5643       /* For the non-shared case, discard space for relocs against
5644          symbols which turn out to need copy relocs or are not
5645          dynamic.  */
5646
5647       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
5648           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5649           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
5650         {
5651           /* Make sure this symbol is output as a dynamic symbol.
5652              Undefined weak syms won't yet be marked as dynamic.  */
5653           if (h->dynindx == -1
5654               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
5655             {
5656               if (! bfd_elf64_link_record_dynamic_symbol (info, h))
5657                 return FALSE;
5658             }
5659
5660           /* If that succeeded, we know we'll be keeping all the
5661              relocs.  */
5662           if (h->dynindx != -1)
5663             goto keep;
5664         }
5665
5666       eh->dyn_relocs = NULL;
5667
5668     keep: ;
5669     }
5670
5671   /* Finally, allocate space.  */
5672   for (p = eh->dyn_relocs; p != NULL; p = p->next)
5673     {
5674       asection *sreloc = elf_section_data (p->sec)->sreloc;
5675       sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
5676     }
5677
5678   return TRUE;
5679 }
5680
5681 /* Find any dynamic relocs that apply to read-only sections.  */
5682
5683 static bfd_boolean
5684 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5685 {
5686   struct ppc_link_hash_entry *eh;
5687   struct ppc_dyn_relocs *p;
5688
5689   if (h->root.type == bfd_link_hash_warning)
5690     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5691
5692   eh = (struct ppc_link_hash_entry *) h;
5693   for (p = eh->dyn_relocs; p != NULL; p = p->next)
5694     {
5695       asection *s = p->sec->output_section;
5696
5697       if (s != NULL && (s->flags & SEC_READONLY) != 0)
5698         {
5699           struct bfd_link_info *info = inf;
5700
5701           info->flags |= DF_TEXTREL;
5702
5703           /* Not an error, just cut short the traversal.  */
5704           return FALSE;
5705         }
5706     }
5707   return TRUE;
5708 }
5709
5710 /* Set the sizes of the dynamic sections.  */
5711
5712 static bfd_boolean
5713 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5714                                  struct bfd_link_info *info)
5715 {
5716   struct ppc_link_hash_table *htab;
5717   bfd *dynobj;
5718   asection *s;
5719   bfd_boolean relocs;
5720   bfd *ibfd;
5721
5722   htab = ppc_hash_table (info);
5723   dynobj = htab->elf.dynobj;
5724   if (dynobj == NULL)
5725     abort ();
5726
5727   if (htab->elf.dynamic_sections_created)
5728     {
5729       /* Set the contents of the .interp section to the interpreter.  */
5730       if (info->executable)
5731         {
5732           s = bfd_get_section_by_name (dynobj, ".interp");
5733           if (s == NULL)
5734             abort ();
5735           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
5736           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5737         }
5738     }
5739
5740   /* Set up .got offsets for local syms, and space for local dynamic
5741      relocs.  */
5742   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5743     {
5744       struct got_entry **lgot_ents;
5745       struct got_entry **end_lgot_ents;
5746       char *lgot_masks;
5747       bfd_size_type locsymcount;
5748       Elf_Internal_Shdr *symtab_hdr;
5749       asection *srel;
5750
5751       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5752         continue;
5753
5754       if (ppc64_tlsld_got (ibfd)->refcount > 0)
5755         {
5756           s = ppc64_elf_tdata (ibfd)->got;
5757           ppc64_tlsld_got (ibfd)->offset = s->_raw_size;
5758           s->_raw_size += 16;
5759           if (info->shared)
5760             {
5761               srel = ppc64_elf_tdata (ibfd)->relgot;
5762               srel->_raw_size += sizeof (Elf64_External_Rela);
5763             }
5764         }
5765       else
5766         ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
5767
5768       for (s = ibfd->sections; s != NULL; s = s->next)
5769         {
5770           struct ppc_dyn_relocs *p;
5771
5772           for (p = *((struct ppc_dyn_relocs **)
5773                      &elf_section_data (s)->local_dynrel);
5774                p != NULL;
5775                p = p->next)
5776             {
5777               if (!bfd_is_abs_section (p->sec)
5778                   && bfd_is_abs_section (p->sec->output_section))
5779                 {
5780                   /* Input section has been discarded, either because
5781                      it is a copy of a linkonce section or due to
5782                      linker script /DISCARD/, so we'll be discarding
5783                      the relocs too.  */
5784                 }
5785               else if (p->count != 0)
5786                 {
5787                   srel = elf_section_data (p->sec)->sreloc;
5788                   srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
5789                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
5790                     info->flags |= DF_TEXTREL;
5791                 }
5792             }
5793         }
5794
5795       lgot_ents = elf_local_got_ents (ibfd);
5796       if (!lgot_ents)
5797         continue;
5798
5799       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5800       locsymcount = symtab_hdr->sh_info;
5801       end_lgot_ents = lgot_ents + locsymcount;
5802       lgot_masks = (char *) end_lgot_ents;
5803       s = ppc64_elf_tdata (ibfd)->got;
5804       srel = ppc64_elf_tdata (ibfd)->relgot;
5805       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
5806         {
5807           struct got_entry *ent;
5808
5809           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
5810             if (ent->got.refcount > 0)
5811               {
5812                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
5813                   {
5814                     if (ppc64_tlsld_got (ibfd)->offset == (bfd_vma) -1)
5815                       {
5816                         ppc64_tlsld_got (ibfd)->offset = s->_raw_size;
5817                         s->_raw_size += 16;
5818                         if (info->shared)
5819                           srel->_raw_size += sizeof (Elf64_External_Rela);
5820                       }
5821                     ent->got.offset = ppc64_tlsld_got (ibfd)->offset;
5822                   }
5823                 else
5824                   {
5825                     ent->got.offset = s->_raw_size;
5826                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
5827                       {
5828                         s->_raw_size += 16;
5829                         if (info->shared)
5830                           srel->_raw_size += 2 * sizeof (Elf64_External_Rela);
5831                       }
5832                     else
5833                       {
5834                         s->_raw_size += 8;
5835                         if (info->shared)
5836                           srel->_raw_size += sizeof (Elf64_External_Rela);
5837                       }
5838                   }
5839               }
5840             else
5841               ent->got.offset = (bfd_vma) -1;
5842         }
5843     }
5844
5845   /* Allocate global sym .plt and .got entries, and space for global
5846      sym dynamic relocs.  */
5847   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
5848
5849   /* We now have determined the sizes of the various dynamic sections.
5850      Allocate memory for them.  */
5851   relocs = FALSE;
5852   for (s = dynobj->sections; s != NULL; s = s->next)
5853     {
5854       if ((s->flags & SEC_LINKER_CREATED) == 0)
5855         continue;
5856
5857       /* Reset _cooked_size since prelim layout will set it wrongly,
5858          and a non-zero _cooked_size sticks.  */
5859       s->_cooked_size = 0;
5860
5861       if (s == htab->brlt || s == htab->relbrlt)
5862         /* These haven't been allocated yet;  don't strip.  */
5863         continue;
5864       else if (s == htab->got
5865                || s == htab->plt
5866                || s == htab->glink)
5867         {
5868           /* Strip this section if we don't need it; see the
5869              comment below.  */
5870         }
5871       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
5872         {
5873           if (s->_raw_size == 0)
5874             {
5875               /* If we don't need this section, strip it from the
5876                  output file.  This is mostly to handle .rela.bss and
5877                  .rela.plt.  We must create both sections in
5878                  create_dynamic_sections, because they must be created
5879                  before the linker maps input sections to output
5880                  sections.  The linker does that before
5881                  adjust_dynamic_symbol is called, and it is that
5882                  function which decides whether anything needs to go
5883                  into these sections.  */
5884             }
5885           else
5886             {
5887               if (s != htab->relplt)
5888                 relocs = TRUE;
5889
5890               /* We use the reloc_count field as a counter if we need
5891                  to copy relocs into the output file.  */
5892               s->reloc_count = 0;
5893             }
5894         }
5895       else
5896         {
5897           /* It's not one of our sections, so don't allocate space.  */
5898           continue;
5899         }
5900
5901       if (s->_raw_size == 0)
5902         {
5903           _bfd_strip_section_from_output (info, s);
5904           continue;
5905         }
5906
5907       /* .plt is in the bss section.  We don't initialise it.  */
5908       if ((s->flags & SEC_LOAD) == 0)
5909         continue;
5910
5911       /* Allocate memory for the section contents.  We use bfd_zalloc
5912          here in case unused entries are not reclaimed before the
5913          section's contents are written out.  This should not happen,
5914          but this way if it does we get a R_PPC64_NONE reloc in .rela
5915          sections instead of garbage.
5916          We also rely on the section contents being zero when writing
5917          the GOT.  */
5918       s->contents = bfd_zalloc (dynobj, s->_raw_size);
5919       if (s->contents == NULL)
5920         return FALSE;
5921     }
5922
5923   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5924     {
5925       s = ppc64_elf_tdata (ibfd)->got;
5926       if (s != NULL && s != htab->got)
5927         {
5928           s->_cooked_size = 0;
5929           if (s->_raw_size == 0)
5930             _bfd_strip_section_from_output (info, s);
5931           else
5932             {
5933               s->contents = bfd_zalloc (ibfd, s->_raw_size);
5934               if (s->contents == NULL)
5935                 return FALSE;
5936             }
5937         }
5938       s = ppc64_elf_tdata (ibfd)->relgot;
5939       if (s != NULL)
5940         {
5941           s->_cooked_size = 0;
5942           if (s->_raw_size == 0)
5943             _bfd_strip_section_from_output (info, s);
5944           else
5945             {
5946               s->contents = bfd_zalloc (ibfd, s->_raw_size);
5947               if (s->contents == NULL)
5948                 return FALSE;
5949               relocs = TRUE;
5950               s->reloc_count = 0;
5951             }
5952         }
5953     }
5954
5955   if (htab->elf.dynamic_sections_created)
5956     {
5957       /* Add some entries to the .dynamic section.  We fill in the
5958          values later, in ppc64_elf_finish_dynamic_sections, but we
5959          must add the entries now so that we get the correct size for
5960          the .dynamic section.  The DT_DEBUG entry is filled in by the
5961          dynamic linker and used by the debugger.  */
5962 #define add_dynamic_entry(TAG, VAL) \
5963   bfd_elf64_add_dynamic_entry (info, (TAG), (VAL))
5964
5965       if (info->executable)
5966         {
5967           if (!add_dynamic_entry (DT_DEBUG, 0))
5968             return FALSE;
5969         }
5970
5971       if (htab->plt != NULL && htab->plt->_raw_size != 0)
5972         {
5973           if (!add_dynamic_entry (DT_PLTGOT, 0)
5974               || !add_dynamic_entry (DT_PLTRELSZ, 0)
5975               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5976               || !add_dynamic_entry (DT_JMPREL, 0)
5977               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
5978             return FALSE;
5979         }
5980
5981       if (NO_OPD_RELOCS)
5982         {
5983           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
5984               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
5985             return FALSE;
5986         }
5987
5988       if (relocs)
5989         {
5990           if (!add_dynamic_entry (DT_RELA, 0)
5991               || !add_dynamic_entry (DT_RELASZ, 0)
5992               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
5993             return FALSE;
5994
5995           /* If any dynamic relocs apply to a read-only section,
5996              then we need a DT_TEXTREL entry.  */
5997           if ((info->flags & DF_TEXTREL) == 0)
5998             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
5999
6000           if ((info->flags & DF_TEXTREL) != 0)
6001             {
6002               if (!add_dynamic_entry (DT_TEXTREL, 0))
6003                 return FALSE;
6004             }
6005         }
6006     }
6007 #undef add_dynamic_entry
6008
6009   return TRUE;
6010 }
6011
6012 /* Determine the type of stub needed, if any, for a call.  */
6013
6014 static inline enum ppc_stub_type
6015 ppc_type_of_stub (asection *input_sec,
6016                   const Elf_Internal_Rela *rel,
6017                   struct ppc_link_hash_entry **hash,
6018                   bfd_vma destination)
6019 {
6020   struct ppc_link_hash_entry *h = *hash;
6021   bfd_vma location;
6022   bfd_vma branch_offset;
6023   bfd_vma max_branch_offset;
6024   enum elf_ppc64_reloc_type r_type;
6025
6026   if (h != NULL)
6027     {
6028       if (h->oh != NULL
6029           && h->oh->dynindx != -1)
6030         {
6031           struct plt_entry *ent;
6032           for (ent = h->oh->plt.plist; ent != NULL; ent = ent->next)
6033             if (ent->addend == rel->r_addend
6034                 && ent->plt.offset != (bfd_vma) -1)
6035               {
6036                 *hash = (struct ppc_link_hash_entry *) h->oh;
6037                 return ppc_stub_plt_call;
6038               }
6039         }
6040
6041       if (h->elf.root.type != bfd_link_hash_defined
6042           && h->elf.root.type != bfd_link_hash_defweak)
6043         return ppc_stub_none;
6044     }
6045
6046   /* Determine where the call point is.  */
6047   location = (input_sec->output_offset
6048               + input_sec->output_section->vma
6049               + rel->r_offset);
6050
6051   branch_offset = destination - location;
6052   r_type = ELF64_R_TYPE (rel->r_info);
6053
6054   /* Determine if a long branch stub is needed.  */
6055   max_branch_offset = 1 << 25;
6056   if (r_type != R_PPC64_REL24)
6057     max_branch_offset = 1 << 15;
6058
6059   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
6060     /* We need a stub.  Figure out whether a long_branch or plt_branch
6061        is needed later.  */
6062     return ppc_stub_long_branch;
6063
6064   return ppc_stub_none;
6065 }
6066
6067 /* Build a .plt call stub.  */
6068
6069 static inline bfd_byte *
6070 build_plt_stub (bfd *obfd, bfd_byte *p, int offset)
6071 {
6072 #define PPC_LO(v) ((v) & 0xffff)
6073 #define PPC_HI(v) (((v) >> 16) & 0xffff)
6074 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
6075
6076   bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
6077   bfd_put_32 (obfd, STD_R2_40R1, p),                    p += 4;
6078   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
6079   if (PPC_HA (offset + 8) != PPC_HA (offset))
6080     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
6081   offset += 8;
6082   bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p),   p += 4;
6083   if (PPC_HA (offset + 8) != PPC_HA (offset))
6084     bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p),            p += 4;
6085   offset += 8;
6086   bfd_put_32 (obfd, MTCTR_R11, p),                      p += 4;
6087   bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),  p += 4;
6088   bfd_put_32 (obfd, BCTR, p),                           p += 4;
6089   return p;
6090 }
6091
6092 static bfd_boolean
6093 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
6094 {
6095   struct ppc_stub_hash_entry *stub_entry;
6096   struct ppc_branch_hash_entry *br_entry;
6097   struct bfd_link_info *info;
6098   struct ppc_link_hash_table *htab;
6099   asection *stub_sec;
6100   bfd *stub_bfd;
6101   bfd_byte *loc;
6102   bfd_byte *p;
6103   unsigned int indx;
6104   struct plt_entry *ent;
6105   bfd_vma off;
6106   int size;
6107
6108   /* Massage our args to the form they really have.  */
6109   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
6110   info = in_arg;
6111
6112   htab = ppc_hash_table (info);
6113   stub_sec = stub_entry->stub_sec;
6114
6115   /* Make a note of the offset within the stubs for this entry.  */
6116   stub_entry->stub_offset = stub_sec->_cooked_size;
6117   loc = stub_sec->contents + stub_entry->stub_offset;
6118
6119   if (htab->emit_stub_syms)
6120     {
6121       struct elf_link_hash_entry *h;
6122       h = elf_link_hash_lookup (&htab->elf, stub_entry->root.string,
6123                                 TRUE, FALSE, FALSE);
6124       if (h == NULL)
6125         return FALSE;
6126       h->root.type = bfd_link_hash_defined;
6127       h->root.u.def.section = stub_entry->stub_sec;
6128       h->root.u.def.value = stub_entry->stub_offset;
6129       h->elf_link_hash_flags = (ELF_LINK_HASH_REF_REGULAR
6130                                 | ELF_LINK_HASH_DEF_REGULAR
6131                                 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
6132                                 | ELF_LINK_FORCED_LOCAL);
6133     }
6134
6135   stub_bfd = stub_sec->owner;
6136
6137   htab->stub_count[stub_entry->stub_type - 1] += 1;
6138   switch (stub_entry->stub_type)
6139     {
6140     case ppc_stub_long_branch:
6141     case ppc_stub_long_branch_r2off:
6142       /* Branches are relative.  This is where we are going to.  */
6143       off = (stub_entry->target_value
6144              + stub_entry->target_section->output_offset
6145              + stub_entry->target_section->output_section->vma);
6146
6147       /* And this is where we are coming from.  */
6148       off -= (stub_entry->stub_offset
6149               + stub_sec->output_offset
6150               + stub_sec->output_section->vma);
6151
6152       if (stub_entry->stub_type != ppc_stub_long_branch_r2off)
6153         size = 4;
6154       else
6155         {
6156           bfd_vma r2off;
6157
6158           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
6159                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
6160           bfd_put_32 (stub_bfd, STD_R2_40R1, loc);
6161           loc += 4;
6162           bfd_put_32 (stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
6163           loc += 4;
6164           bfd_put_32 (stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
6165           loc += 4;
6166           off -= 12;
6167           size = 16;
6168         }
6169       bfd_put_32 (stub_bfd, B_DOT | (off & 0x3fffffc), loc);
6170
6171       BFD_ASSERT (off + (1 << 25) < (bfd_vma) (1 << 26));
6172       break;
6173
6174     case ppc_stub_plt_branch:
6175     case ppc_stub_plt_branch_r2off:
6176       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
6177                                          stub_entry->root.string + 9,
6178                                          FALSE, FALSE);
6179       if (br_entry == NULL)
6180         {
6181           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
6182                                  stub_entry->root.string + 9);
6183           htab->stub_error = TRUE;
6184           return FALSE;
6185         }
6186
6187       off = (stub_entry->target_value
6188              + stub_entry->target_section->output_offset
6189              + stub_entry->target_section->output_section->vma);
6190
6191       bfd_put_64 (htab->brlt->owner, off,
6192                   htab->brlt->contents + br_entry->offset);
6193
6194       if (info->shared)
6195         {
6196           /* Create a reloc for the branch lookup table entry.  */
6197           Elf_Internal_Rela rela;
6198           bfd_byte *rl;
6199
6200           rela.r_offset = (br_entry->offset
6201                            + htab->brlt->output_offset
6202                            + htab->brlt->output_section->vma);
6203           rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
6204           rela.r_addend = off;
6205
6206           rl = htab->relbrlt->contents;
6207           rl += htab->relbrlt->reloc_count++ * sizeof (Elf64_External_Rela);
6208           bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
6209         }
6210
6211       off = (br_entry->offset
6212              + htab->brlt->output_offset
6213              + htab->brlt->output_section->vma
6214              - elf_gp (htab->brlt->output_section->owner)
6215              - htab->stub_group[stub_entry->id_sec->id].toc_off);
6216
6217       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
6218         {
6219           (*_bfd_error_handler)
6220             (_("linkage table error against `%s'"),
6221              stub_entry->root.string);
6222           bfd_set_error (bfd_error_bad_value);
6223           htab->stub_error = TRUE;
6224           return FALSE;
6225         }
6226
6227       indx = off;
6228       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
6229         {
6230           bfd_put_32 (stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
6231           loc += 4;
6232           bfd_put_32 (stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
6233           size = 16;
6234         }
6235       else
6236         {
6237           bfd_vma r2off;
6238
6239           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
6240                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
6241           bfd_put_32 (stub_bfd, STD_R2_40R1, loc);
6242           loc += 4;
6243           bfd_put_32 (stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
6244           loc += 4;
6245           bfd_put_32 (stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
6246           loc += 4;
6247           bfd_put_32 (stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
6248           loc += 4;
6249           bfd_put_32 (stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
6250           size = 28;
6251         }
6252       loc += 4;
6253       bfd_put_32 (stub_bfd, MTCTR_R11, loc);
6254       loc += 4;
6255       bfd_put_32 (stub_bfd, BCTR, loc);
6256       break;
6257
6258     case ppc_stub_plt_call:
6259       /* Do the best we can for shared libraries built without
6260          exporting ".foo" for each "foo".  This can happen when symbol
6261          versioning scripts strip all bar a subset of symbols.  */
6262       if (stub_entry->h->oh->root.type != bfd_link_hash_defined
6263           && stub_entry->h->oh->root.type != bfd_link_hash_defweak)
6264         {
6265           /* Point the symbol at the stub.  There may be multiple stubs,
6266              we don't really care;  The main thing is to make this sym
6267              defined somewhere.  Maybe defining the symbol in the stub
6268              section is a silly idea.  If we didn't do this, htab->top_id
6269              could disappear.  */
6270           stub_entry->h->oh->root.type = bfd_link_hash_defined;
6271           stub_entry->h->oh->root.u.def.section = stub_entry->stub_sec;
6272           stub_entry->h->oh->root.u.def.value = stub_entry->stub_offset;
6273         }
6274
6275       /* Now build the stub.  */
6276       off = (bfd_vma) -1;
6277       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
6278         if (ent->addend == stub_entry->addend)
6279           {
6280             off = ent->plt.offset;
6281             break;
6282           }
6283       if (off >= (bfd_vma) -2)
6284         abort ();
6285
6286       off &= ~ (bfd_vma) 1;
6287       off += (htab->plt->output_offset
6288               + htab->plt->output_section->vma
6289               - elf_gp (htab->plt->output_section->owner)
6290               - htab->stub_group[stub_entry->id_sec->id].toc_off);
6291
6292       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
6293         {
6294           (*_bfd_error_handler)
6295             (_("linkage table error against `%s'"),
6296              stub_entry->h->elf.root.root.string);
6297           bfd_set_error (bfd_error_bad_value);
6298           htab->stub_error = TRUE;
6299           return FALSE;
6300         }
6301
6302       p = build_plt_stub (stub_bfd, loc, off);
6303       size = p - loc;
6304       break;
6305
6306     default:
6307       BFD_FAIL ();
6308       return FALSE;
6309     }
6310
6311   stub_sec->_cooked_size += size;
6312   return TRUE;
6313 }
6314
6315 /* As above, but don't actually build the stub.  Just bump offset so
6316    we know stub section sizes, and select plt_branch stubs where
6317    long_branch stubs won't do.  */
6318
6319 static bfd_boolean
6320 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
6321 {
6322   struct ppc_stub_hash_entry *stub_entry;
6323   struct ppc_link_hash_table *htab;
6324   bfd_vma off;
6325   int size;
6326
6327   /* Massage our args to the form they really have.  */
6328   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
6329   htab = in_arg;
6330
6331   if (stub_entry->stub_type == ppc_stub_plt_call)
6332     {
6333       struct plt_entry *ent;
6334       off = (bfd_vma) -1;
6335       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
6336         if (ent->addend == stub_entry->addend)
6337           {
6338             off = ent->plt.offset & ~(bfd_vma) 1;
6339             break;
6340           }
6341       if (off >= (bfd_vma) -2)
6342         abort ();
6343       off += (htab->plt->output_offset
6344               + htab->plt->output_section->vma
6345               - elf_gp (htab->plt->output_section->owner)
6346               - htab->stub_group[stub_entry->id_sec->id].toc_off);
6347
6348       size = PLT_CALL_STUB_SIZE;
6349       if (PPC_HA (off + 16) != PPC_HA (off))
6350         size += 4;
6351     }
6352   else
6353     {
6354       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
6355          variants.  */
6356       off = (stub_entry->target_value
6357              + stub_entry->target_section->output_offset
6358              + stub_entry->target_section->output_section->vma);
6359       off -= (stub_entry->stub_sec->_raw_size
6360               + stub_entry->stub_sec->output_offset
6361               + stub_entry->stub_sec->output_section->vma);
6362
6363       /* Reset the stub type from the plt variant in case we now
6364          can reach with a shorter stub.  */
6365       if (stub_entry->stub_type >= ppc_stub_plt_branch)
6366         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
6367
6368       size = 4;
6369       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
6370         {
6371           off -= 12;
6372           size = 16;
6373         }
6374
6375       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
6376       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
6377         {
6378           struct ppc_branch_hash_entry *br_entry;
6379
6380           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
6381                                              stub_entry->root.string + 9,
6382                                              TRUE, FALSE);
6383           if (br_entry == NULL)
6384             {
6385               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
6386                                      stub_entry->root.string + 9);
6387               htab->stub_error = TRUE;
6388               return FALSE;
6389             }
6390
6391           if (br_entry->iter != htab->stub_iteration)
6392             {
6393               br_entry->iter = htab->stub_iteration;
6394               br_entry->offset = htab->brlt->_raw_size;
6395               htab->brlt->_raw_size += 8;
6396             }
6397
6398           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
6399           size = 16;
6400           if (stub_entry->stub_type != ppc_stub_plt_branch)
6401             size = 28;
6402         }
6403     }
6404
6405   stub_entry->stub_sec->_raw_size += size;
6406   return TRUE;
6407 }
6408
6409 /* Set up various things so that we can make a list of input sections
6410    for each output section included in the link.  Returns -1 on error,
6411    0 when no stubs will be needed, and 1 on success.  */
6412
6413 int
6414 ppc64_elf_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
6415 {
6416   bfd *input_bfd;
6417   int top_id, top_index, id;
6418   asection *section;
6419   asection **input_list;
6420   bfd_size_type amt;
6421   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6422
6423   if (htab->brlt == NULL)
6424     return 0;
6425
6426   /* Find the top input section id.  */
6427   for (input_bfd = info->input_bfds, top_id = 3;
6428        input_bfd != NULL;
6429        input_bfd = input_bfd->link_next)
6430     {
6431       for (section = input_bfd->sections;
6432            section != NULL;
6433            section = section->next)
6434         {
6435           if (top_id < section->id)
6436             top_id = section->id;
6437         }
6438     }
6439
6440   htab->top_id = top_id;
6441   amt = sizeof (struct map_stub) * (top_id + 1);
6442   htab->stub_group = bfd_zmalloc (amt);
6443   if (htab->stub_group == NULL)
6444     return -1;
6445
6446   /* Set toc_off for com, und, abs and ind sections.  */
6447   for (id = 0; id < 3; id++)
6448     htab->stub_group[id].toc_off = TOC_BASE_OFF;
6449
6450   elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
6451
6452   /* We can't use output_bfd->section_count here to find the top output
6453      section index as some sections may have been removed, and
6454      _bfd_strip_section_from_output doesn't renumber the indices.  */
6455   for (section = output_bfd->sections, top_index = 0;
6456        section != NULL;
6457        section = section->next)
6458     {
6459       if (top_index < section->index)
6460         top_index = section->index;
6461     }
6462
6463   htab->top_index = top_index;
6464   amt = sizeof (asection *) * (top_index + 1);
6465   input_list = bfd_zmalloc (amt);
6466   htab->input_list = input_list;
6467   if (input_list == NULL)
6468     return -1;
6469
6470   return 1;
6471 }
6472
6473 /* The linker repeatedly calls this function for each TOC input section
6474    and linker generated GOT section.  Group input bfds such that the toc
6475    within a group is less than 64k in size.  Will break with cute linker
6476    scripts that play games with dot in the output toc section.  */
6477
6478 void
6479 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
6480 {
6481   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6482
6483   if (!htab->no_multi_toc)
6484     {
6485       bfd_vma addr = isec->output_offset + isec->output_section->vma;
6486       bfd_vma off = addr - htab->toc_curr;
6487       if (off + isec->_raw_size > 0x10000)
6488         {
6489           htab->toc_curr = addr;
6490           htab->multi_toc_needed = 1;
6491         }
6492       elf_gp (isec->owner) = (htab->toc_curr
6493                               - elf_gp (isec->output_section->owner)
6494                               + TOC_BASE_OFF);
6495     }
6496 }
6497
6498 /* Called after the last call to the above function.  */
6499
6500 void
6501 ppc64_elf_reinit_toc (bfd *output_bfd ATTRIBUTE_UNUSED,
6502                       struct bfd_link_info *info)
6503 {
6504   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6505
6506   /* toc_curr tracks the TOC offset used for code sections below in
6507      ppc64_elf_next_input_section.  Start off at 0x8000.  */
6508   htab->toc_curr = TOC_BASE_OFF;
6509 }
6510
6511 /* No toc references were found in ISEC.  If the code in ISEC makes no
6512    calls, then there's no need to use toc adjusting stubs when branching
6513    into ISEC.  Actually, indirect calls from ISEC are OK as they will
6514    load r2.  */
6515
6516 static int
6517 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
6518 {
6519   bfd_byte *contents;
6520   bfd_size_type i;
6521   int ret;
6522   int branch_ok;
6523
6524   /* We know none of our code bearing sections will need toc stubs.  */
6525   if ((isec->flags & SEC_LINKER_CREATED) != 0)
6526     return 0;
6527
6528   /* Hack for linux kernel.  .fixup contains branches, but only back to
6529      the function that hit an exception.  */
6530   branch_ok = strcmp (isec->name, ".fixup") == 0;
6531
6532   contents = elf_section_data (isec)->this_hdr.contents;
6533   if (contents == NULL)
6534     {
6535       contents = bfd_malloc (isec->_raw_size);
6536       if (contents == NULL)
6537         return -1;
6538       if (! bfd_get_section_contents (isec->owner, isec, contents,
6539                                       0, isec->_raw_size))
6540         {
6541           free (contents);
6542           return -1;
6543         }
6544       if (info->keep_memory)
6545         elf_section_data (isec)->this_hdr.contents = contents;
6546     }
6547
6548   /* Code scan, because we don't necessarily have relocs on calls to
6549      static functions.  */
6550   ret = 0;
6551   for (i = 0; i < isec->_raw_size; i += 4)
6552     {
6553       unsigned long insn = bfd_get_32 (isec->owner, contents + i);
6554       /* Is this a branch?  */
6555       if ((insn & (0x3f << 26)) == (18 << 26)
6556           /* If branch and link, it's a function call.  */
6557           && ((insn & 1) != 0
6558               /* Sibling calls use a plain branch.  I don't know a way
6559                  of deciding whether a branch is really a sibling call.  */
6560               || !branch_ok))
6561         {
6562           ret = 1;
6563           break;
6564         }
6565     }
6566
6567   if (elf_section_data (isec)->this_hdr.contents != contents)
6568     free (contents);
6569   return ret;
6570 }
6571
6572 /* The linker repeatedly calls this function for each input section,
6573    in the order that input sections are linked into output sections.
6574    Build lists of input sections to determine groupings between which
6575    we may insert linker stubs.  */
6576
6577 bfd_boolean
6578 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
6579 {
6580   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6581   int ret;
6582
6583   if ((isec->output_section->flags & SEC_CODE) != 0
6584       && isec->output_section->index <= htab->top_index)
6585     {
6586       asection **list = htab->input_list + isec->output_section->index;
6587       /* Steal the link_sec pointer for our list.  */
6588 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
6589       /* This happens to make the list in reverse order,
6590          which is what we want.  */
6591       PREV_SEC (isec) = *list;
6592       *list = isec;
6593     }
6594
6595   /* If a code section has a function that uses the TOC then we need
6596      to use the right TOC (obviously).  Also, make sure that .opd gets
6597      the correct TOC value.  */
6598   if (isec->has_gp_reloc || (isec->flags & SEC_CODE) == 0)
6599     {
6600       if (elf_gp (isec->owner) != 0)
6601         htab->toc_curr = elf_gp (isec->owner);
6602     }
6603   else if ((ret = toc_adjusting_stub_needed (info, isec)) < 0)
6604     return FALSE;
6605   else
6606     isec->has_gp_reloc = ret;
6607
6608   /* Functions that don't use the TOC can belong in any TOC group.
6609      Use the last TOC base.  This happens to make _init and _fini
6610      pasting work.  */
6611   htab->stub_group[isec->id].toc_off = htab->toc_curr;
6612   return TRUE;
6613 }
6614
6615 /* See whether we can group stub sections together.  Grouping stub
6616    sections may result in fewer stubs.  More importantly, we need to
6617    put all .init* and .fini* stubs at the beginning of the .init or
6618    .fini output sections respectively, because glibc splits the
6619    _init and _fini functions into multiple parts.  Putting a stub in
6620    the middle of a function is not a good idea.  */
6621
6622 static void
6623 group_sections (struct ppc_link_hash_table *htab,
6624                 bfd_size_type stub_group_size,
6625                 bfd_boolean stubs_always_before_branch)
6626 {
6627   asection **list = htab->input_list + htab->top_index;
6628   do
6629     {
6630       asection *tail = *list;
6631       while (tail != NULL)
6632         {
6633           asection *curr;
6634           asection *prev;
6635           bfd_size_type total;
6636           bfd_boolean big_sec;
6637           bfd_vma curr_toc;
6638
6639           curr = tail;
6640           if (tail->_cooked_size)
6641             total = tail->_cooked_size;
6642           else
6643             total = tail->_raw_size;
6644           big_sec = total >= stub_group_size;
6645           curr_toc = htab->stub_group[tail->id].toc_off;
6646
6647           while ((prev = PREV_SEC (curr)) != NULL
6648                  && ((total += curr->output_offset - prev->output_offset)
6649                      < stub_group_size)
6650                  && htab->stub_group[prev->id].toc_off == curr_toc)
6651             curr = prev;
6652
6653           /* OK, the size from the start of CURR to the end is less
6654              than stub_group_size and thus can be handled by one stub
6655              section.  (or the tail section is itself larger than
6656              stub_group_size, in which case we may be toast.)  We
6657              should really be keeping track of the total size of stubs
6658              added here, as stubs contribute to the final output
6659              section size.  That's a little tricky, and this way will
6660              only break if stubs added make the total size more than
6661              2^25, ie. for the default stub_group_size, if stubs total
6662              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
6663           do
6664             {
6665               prev = PREV_SEC (tail);
6666               /* Set up this stub group.  */
6667               htab->stub_group[tail->id].link_sec = curr;
6668             }
6669           while (tail != curr && (tail = prev) != NULL);
6670
6671           /* But wait, there's more!  Input sections up to stub_group_size
6672              bytes before the stub section can be handled by it too.
6673              Don't do this if we have a really large section after the
6674              stubs, as adding more stubs increases the chance that
6675              branches may not reach into the stub section.  */
6676           if (!stubs_always_before_branch && !big_sec)
6677             {
6678               total = 0;
6679               while (prev != NULL
6680                      && ((total += tail->output_offset - prev->output_offset)
6681                          < stub_group_size)
6682                      && htab->stub_group[prev->id].toc_off == curr_toc)
6683                 {
6684                   tail = prev;
6685                   prev = PREV_SEC (tail);
6686                   htab->stub_group[tail->id].link_sec = curr;
6687                 }
6688             }
6689           tail = prev;
6690         }
6691     }
6692   while (list-- != htab->input_list);
6693   free (htab->input_list);
6694 #undef PREV_SEC
6695 }
6696
6697 /* Determine and set the size of the stub section for a final link.
6698
6699    The basic idea here is to examine all the relocations looking for
6700    PC-relative calls to a target that is unreachable with a "bl"
6701    instruction.  */
6702
6703 bfd_boolean
6704 ppc64_elf_size_stubs (bfd *output_bfd,
6705                       struct bfd_link_info *info,
6706                       bfd_signed_vma group_size,
6707                       asection *(*add_stub_section) (const char *, asection *),
6708                       void (*layout_sections_again) (void))
6709 {
6710   bfd_size_type stub_group_size;
6711   bfd_boolean stubs_always_before_branch;
6712   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6713
6714   /* Stash our params away.  */
6715   htab->add_stub_section = add_stub_section;
6716   htab->layout_sections_again = layout_sections_again;
6717   stubs_always_before_branch = group_size < 0;
6718   if (group_size < 0)
6719     stub_group_size = -group_size;
6720   else
6721     stub_group_size = group_size;
6722   if (stub_group_size == 1)
6723     {
6724       /* Default values.  */
6725       if (stubs_always_before_branch)
6726         {
6727           stub_group_size = 0x1e00000;
6728           if (htab->has_14bit_branch)
6729             stub_group_size = 0x7800;
6730         }
6731       else
6732         {
6733           stub_group_size = 0x1c00000;
6734           if (htab->has_14bit_branch)
6735             stub_group_size = 0x7000;
6736         }
6737     }
6738
6739   group_sections (htab, stub_group_size, stubs_always_before_branch);
6740
6741   while (1)
6742     {
6743       bfd *input_bfd;
6744       unsigned int bfd_indx;
6745       asection *stub_sec;
6746       bfd_boolean stub_changed;
6747
6748       htab->stub_iteration += 1;
6749       stub_changed = FALSE;
6750
6751       for (input_bfd = info->input_bfds, bfd_indx = 0;
6752            input_bfd != NULL;
6753            input_bfd = input_bfd->link_next, bfd_indx++)
6754         {
6755           Elf_Internal_Shdr *symtab_hdr;
6756           asection *section;
6757           Elf_Internal_Sym *local_syms = NULL;
6758
6759           /* We'll need the symbol table in a second.  */
6760           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6761           if (symtab_hdr->sh_info == 0)
6762             continue;
6763
6764           /* Walk over each section attached to the input bfd.  */
6765           for (section = input_bfd->sections;
6766                section != NULL;
6767                section = section->next)
6768             {
6769               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
6770
6771               /* If there aren't any relocs, then there's nothing more
6772                  to do.  */
6773               if ((section->flags & SEC_RELOC) == 0
6774                   || section->reloc_count == 0)
6775                 continue;
6776
6777               /* If this section is a link-once section that will be
6778                  discarded, then don't create any stubs.  */
6779               if (section->output_section == NULL
6780                   || section->output_section->owner != output_bfd)
6781                 continue;
6782
6783               /* Get the relocs.  */
6784               internal_relocs
6785                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
6786                                              info->keep_memory);
6787               if (internal_relocs == NULL)
6788                 goto error_ret_free_local;
6789
6790               /* Now examine each relocation.  */
6791               irela = internal_relocs;
6792               irelaend = irela + section->reloc_count;
6793               for (; irela < irelaend; irela++)
6794                 {
6795                   enum elf_ppc64_reloc_type r_type;
6796                   unsigned int r_indx;
6797                   enum ppc_stub_type stub_type;
6798                   struct ppc_stub_hash_entry *stub_entry;
6799                   asection *sym_sec;
6800                   bfd_vma sym_value;
6801                   bfd_vma destination;
6802                   struct ppc_link_hash_entry *hash;
6803                   struct elf_link_hash_entry *h;
6804                   Elf_Internal_Sym *sym;
6805                   char *stub_name;
6806                   const asection *id_sec;
6807
6808                   r_type = ELF64_R_TYPE (irela->r_info);
6809                   r_indx = ELF64_R_SYM (irela->r_info);
6810
6811                   if (r_type >= R_PPC64_max)
6812                     {
6813                       bfd_set_error (bfd_error_bad_value);
6814                       goto error_ret_free_internal;
6815                     }
6816
6817                   /* Only look for stubs on branch instructions.  */
6818                   if (r_type != R_PPC64_REL24
6819                       && r_type != R_PPC64_REL14
6820                       && r_type != R_PPC64_REL14_BRTAKEN
6821                       && r_type != R_PPC64_REL14_BRNTAKEN)
6822                     continue;
6823
6824                   /* Now determine the call target, its name, value,
6825                      section.  */
6826                   destination = 0;
6827                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6828                                   r_indx, input_bfd))
6829                     goto error_ret_free_internal;
6830                   hash = (struct ppc_link_hash_entry *) h;
6831
6832                   if (hash == NULL)
6833                     {
6834                       /* It's a local symbol.  */
6835                       sym_value = sym->st_value;
6836                       destination = (sym_value + irela->r_addend
6837                                      + sym_sec->output_offset
6838                                      + sym_sec->output_section->vma);
6839                     }
6840                   else
6841                     {
6842                       /* It's an external symbol.  */
6843                       sym_value = 0;
6844                       if (hash->elf.root.type == bfd_link_hash_defined
6845                           || hash->elf.root.type == bfd_link_hash_defweak)
6846                         {
6847                           sym_value = hash->elf.root.u.def.value;
6848                           if (sym_sec->output_section != NULL)
6849                             destination = (sym_value + irela->r_addend
6850                                            + sym_sec->output_offset
6851                                            + sym_sec->output_section->vma);
6852                         }
6853                       else if (hash->elf.root.type == bfd_link_hash_undefweak)
6854                         ;
6855                       else if (hash->elf.root.type == bfd_link_hash_undefined)
6856                         ;
6857                       else
6858                         {
6859                           bfd_set_error (bfd_error_bad_value);
6860                           goto error_ret_free_internal;
6861                         }
6862                     }
6863
6864                   /* Determine what (if any) linker stub is needed.  */
6865                   stub_type = ppc_type_of_stub (section, irela, &hash,
6866                                                 destination);
6867
6868                   if (stub_type != ppc_stub_plt_call)
6869                     {
6870                       /* Check whether we need a TOC adjusting stub.
6871                          Since the linker pastes together pieces from
6872                          different object files when creating the
6873                          _init and _fini functions, it may be that a
6874                          call to what looks like a local sym is in
6875                          fact a call needing a TOC adjustment.  */
6876                       if (sym_sec != NULL
6877                           && sym_sec->output_section != NULL
6878                           && (htab->stub_group[sym_sec->id].toc_off
6879                               != htab->stub_group[section->id].toc_off)
6880                           && sym_sec->has_gp_reloc
6881                           && section->has_gp_reloc)
6882                         stub_type = ppc_stub_long_branch_r2off;
6883                     }
6884
6885                   if (stub_type == ppc_stub_none)
6886                     continue;
6887
6888                   /* __tls_get_addr calls might be eliminated.  */
6889                   if (stub_type != ppc_stub_plt_call
6890                       && hash != NULL
6891                       && &hash->elf == htab->tls_get_addr
6892                       && section->has_tls_reloc
6893                       && irela != internal_relocs)
6894                     {
6895                       /* Get tls info.  */
6896                       char *tls_mask;
6897
6898                       if (!get_tls_mask (&tls_mask, &local_syms,
6899                                          irela - 1, input_bfd))
6900                         goto error_ret_free_internal;
6901                       if (*tls_mask != 0)
6902                         continue;
6903                     }
6904
6905                   /* Support for grouping stub sections.  */
6906                   id_sec = htab->stub_group[section->id].link_sec;
6907
6908                   /* Get the name of this stub.  */
6909                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
6910                   if (!stub_name)
6911                     goto error_ret_free_internal;
6912
6913                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
6914                                                      stub_name, FALSE, FALSE);
6915                   if (stub_entry != NULL)
6916                     {
6917                       /* The proper stub has already been created.  */
6918                       free (stub_name);
6919                       continue;
6920                     }
6921
6922                   stub_entry = ppc_add_stub (stub_name, section, htab);
6923                   if (stub_entry == NULL)
6924                     {
6925                       free (stub_name);
6926                     error_ret_free_internal:
6927                       if (elf_section_data (section)->relocs == NULL)
6928                         free (internal_relocs);
6929                     error_ret_free_local:
6930                       if (local_syms != NULL
6931                           && (symtab_hdr->contents
6932                               != (unsigned char *) local_syms))
6933                         free (local_syms);
6934                       return FALSE;
6935                     }
6936
6937                   stub_entry->stub_type = stub_type;
6938                   stub_entry->target_value = sym_value;
6939                   stub_entry->target_section = sym_sec;
6940                   stub_entry->h = hash;
6941                   stub_entry->addend = irela->r_addend;
6942                   stub_changed = TRUE;
6943                 }
6944
6945               /* We're done with the internal relocs, free them.  */
6946               if (elf_section_data (section)->relocs != internal_relocs)
6947                 free (internal_relocs);
6948             }
6949
6950           if (local_syms != NULL
6951               && symtab_hdr->contents != (unsigned char *) local_syms)
6952             {
6953               if (!info->keep_memory)
6954                 free (local_syms);
6955               else
6956                 symtab_hdr->contents = (unsigned char *) local_syms;
6957             }
6958         }
6959
6960       if (!stub_changed)
6961         break;
6962
6963       /* OK, we've added some stubs.  Find out the new size of the
6964          stub sections.  */
6965       for (stub_sec = htab->stub_bfd->sections;
6966            stub_sec != NULL;
6967            stub_sec = stub_sec->next)
6968         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
6969           {
6970             stub_sec->_raw_size = 0;
6971             stub_sec->_cooked_size = 0;
6972           }
6973       htab->brlt->_raw_size = 0;
6974       htab->brlt->_cooked_size = 0;
6975
6976       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, htab);
6977
6978       /* Ask the linker to do its stuff.  */
6979       (*htab->layout_sections_again) ();
6980     }
6981
6982   /* It would be nice to strip .branch_lt from the output if the
6983      section is empty, but it's too late.  If we strip sections here,
6984      the dynamic symbol table is corrupted since the section symbol
6985      for the stripped section isn't written.  */
6986
6987   return TRUE;
6988 }
6989
6990 /* Called after we have determined section placement.  If sections
6991    move, we'll be called again.  Provide a value for TOCstart.  */
6992
6993 bfd_vma
6994 ppc64_elf_toc (bfd *obfd)
6995 {
6996   asection *s;
6997   bfd_vma TOCstart;
6998
6999   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
7000      order.  The TOC starts where the first of these sections starts.  */
7001   s = bfd_get_section_by_name (obfd, ".got");
7002   if (s == NULL)
7003     s = bfd_get_section_by_name (obfd, ".toc");
7004   if (s == NULL)
7005     s = bfd_get_section_by_name (obfd, ".tocbss");
7006   if (s == NULL)
7007     s = bfd_get_section_by_name (obfd, ".plt");
7008   if (s == NULL)
7009     {
7010       /* This may happen for
7011          o  references to TOC base (SYM@toc / TOC[tc0]) without a
7012          .toc directive
7013          o  bad linker script
7014          o --gc-sections and empty TOC sections
7015
7016          FIXME: Warn user?  */
7017
7018       /* Look for a likely section.  We probably won't even be
7019          using TOCstart.  */
7020       for (s = obfd->sections; s != NULL; s = s->next)
7021         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
7022             == (SEC_ALLOC | SEC_SMALL_DATA))
7023           break;
7024       if (s == NULL)
7025         for (s = obfd->sections; s != NULL; s = s->next)
7026           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
7027               == (SEC_ALLOC | SEC_SMALL_DATA))
7028             break;
7029       if (s == NULL)
7030         for (s = obfd->sections; s != NULL; s = s->next)
7031           if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
7032             break;
7033       if (s == NULL)
7034         for (s = obfd->sections; s != NULL; s = s->next)
7035           if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
7036             break;
7037     }
7038
7039   TOCstart = 0;
7040   if (s != NULL)
7041     TOCstart = s->output_section->vma + s->output_offset;
7042
7043   return TOCstart;
7044 }
7045
7046 /* Build all the stubs associated with the current output file.
7047    The stubs are kept in a hash table attached to the main linker
7048    hash table.  This function is called via gldelf64ppc_finish.  */
7049
7050 bfd_boolean
7051 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
7052                        struct bfd_link_info *info,
7053                        char **stats)
7054 {
7055   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7056   asection *stub_sec;
7057   bfd_byte *p;
7058   int stub_sec_count = 0;
7059
7060   htab->emit_stub_syms = emit_stub_syms;
7061   for (stub_sec = htab->stub_bfd->sections;
7062        stub_sec != NULL;
7063        stub_sec = stub_sec->next)
7064     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
7065       {
7066         bfd_size_type size;
7067
7068         /* Allocate memory to hold the linker stubs.  */
7069         size = stub_sec->_raw_size;
7070         if (size != 0)
7071           {
7072             stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
7073             if (stub_sec->contents == NULL)
7074               return FALSE;
7075           }
7076         stub_sec->_cooked_size = 0;
7077       }
7078
7079   if (htab->plt != NULL)
7080     {
7081       unsigned int indx;
7082       bfd_vma plt0;
7083
7084       /* Build the .glink plt call stub.  */
7085       plt0 = (htab->plt->output_section->vma
7086               + htab->plt->output_offset
7087               - (htab->glink->output_section->vma
7088                  + htab->glink->output_offset
7089                  + GLINK_CALL_STUB_SIZE));
7090       if (plt0 + 0x80008000 > 0xffffffff)
7091         {
7092           (*_bfd_error_handler) (_(".glink and .plt too far apart"));
7093           bfd_set_error (bfd_error_bad_value);
7094           return FALSE;
7095         }
7096
7097       p = htab->glink->contents;
7098       bfd_put_32 (htab->glink->owner, MFCTR_R12, p);
7099       p += 4;
7100       bfd_put_32 (htab->glink->owner, SLDI_R11_R0_3, p);
7101       p += 4;
7102       bfd_put_32 (htab->glink->owner, ADDIC_R2_R0_32K, p);
7103       p += 4;
7104       bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
7105       p += 4;
7106       bfd_put_32 (htab->glink->owner, SRADI_R2_R2_63, p);
7107       p += 4;
7108       bfd_put_32 (htab->glink->owner, SLDI_R11_R0_2, p);
7109       p += 4;
7110       bfd_put_32 (htab->glink->owner, AND_R2_R2_R11, p);
7111       p += 4;
7112       bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
7113       p += 4;
7114       bfd_put_32 (htab->glink->owner, ADD_R12_R12_R2, p);
7115       p += 4;
7116       bfd_put_32 (htab->glink->owner, ADDIS_R12_R12 | PPC_HA (plt0), p);
7117       p += 4;
7118       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | PPC_LO (plt0), p);
7119       p += 4;
7120       bfd_put_32 (htab->glink->owner, ADDI_R12_R12 | PPC_LO (plt0), p);
7121       p += 4;
7122       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
7123       p += 4;
7124       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
7125       p += 4;
7126       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
7127       p += 4;
7128       bfd_put_32 (htab->glink->owner, BCTR, p);
7129       p += 4;
7130
7131       /* Build the .glink lazy link call stubs.  */
7132       indx = 0;
7133       while (p < htab->glink->contents + htab->glink->_raw_size)
7134         {
7135           if (indx < 0x8000)
7136             {
7137               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
7138               p += 4;
7139             }
7140           else
7141             {
7142               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
7143               p += 4;
7144               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
7145               p += 4;
7146             }
7147           bfd_put_32 (htab->glink->owner,
7148                       B_DOT | ((htab->glink->contents - p) & 0x3fffffc), p);
7149           indx++;
7150           p += 4;
7151         }
7152       htab->glink->_cooked_size = p - htab->glink->contents;
7153     }
7154
7155   if (htab->brlt->_raw_size != 0)
7156     {
7157       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
7158                                          htab->brlt->_raw_size);
7159       if (htab->brlt->contents == NULL)
7160         return FALSE;
7161     }
7162
7163   /* Build the stubs as directed by the stub hash table.  */
7164   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
7165
7166   for (stub_sec = htab->stub_bfd->sections;
7167        stub_sec != NULL;
7168        stub_sec = stub_sec->next)
7169     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
7170       {
7171         stub_sec_count += 1;
7172         if (stub_sec->_raw_size != stub_sec->_cooked_size)
7173           break;
7174       }
7175
7176   if (stub_sec != NULL
7177       || htab->glink->_raw_size != htab->glink->_cooked_size)
7178     {
7179       htab->stub_error = TRUE;
7180       (*_bfd_error_handler) (_("stubs don't match calculated size"));
7181     }
7182
7183   if (htab->stub_error)
7184     return FALSE;
7185
7186   if (stats != NULL)
7187     {
7188       *stats = bfd_malloc (500);
7189       if (*stats == NULL)
7190         return FALSE;
7191
7192       sprintf (*stats, _("linker stubs in %u groups\n"
7193                          "  branch       %lu\n"
7194                          "  toc adjust   %lu\n"
7195                          "  long branch  %lu\n"
7196                          "  long toc adj %lu\n"
7197                          "  plt call     %lu"),
7198                stub_sec_count,
7199                htab->stub_count[ppc_stub_long_branch - 1],
7200                htab->stub_count[ppc_stub_long_branch_r2off - 1],
7201                htab->stub_count[ppc_stub_plt_branch - 1],
7202                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
7203                htab->stub_count[ppc_stub_plt_call - 1]);
7204     }
7205   return TRUE;
7206 }
7207
7208 /* The RELOCATE_SECTION function is called by the ELF backend linker
7209    to handle the relocations for a section.
7210
7211    The relocs are always passed as Rela structures; if the section
7212    actually uses Rel structures, the r_addend field will always be
7213    zero.
7214
7215    This function is responsible for adjust the section contents as
7216    necessary, and (if using Rela relocs and generating a
7217    relocatable output file) adjusting the reloc addend as
7218    necessary.
7219
7220    This function does not have to worry about setting the reloc
7221    address or the reloc symbol index.
7222
7223    LOCAL_SYMS is a pointer to the swapped in local symbols.
7224
7225    LOCAL_SECTIONS is an array giving the section in the input file
7226    corresponding to the st_shndx field of each local symbol.
7227
7228    The global hash table entry for the global symbols can be found
7229    via elf_sym_hashes (input_bfd).
7230
7231    When generating relocatable output, this function must handle
7232    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
7233    going to be the section symbol corresponding to the output
7234    section, which means that the addend must be adjusted
7235    accordingly.  */
7236
7237 static bfd_boolean
7238 ppc64_elf_relocate_section (bfd *output_bfd,
7239                             struct bfd_link_info *info,
7240                             bfd *input_bfd,
7241                             asection *input_section,
7242                             bfd_byte *contents,
7243                             Elf_Internal_Rela *relocs,
7244                             Elf_Internal_Sym *local_syms,
7245                             asection **local_sections)
7246 {
7247   struct ppc_link_hash_table *htab;
7248   Elf_Internal_Shdr *symtab_hdr;
7249   struct elf_link_hash_entry **sym_hashes;
7250   Elf_Internal_Rela *rel;
7251   Elf_Internal_Rela *relend;
7252   Elf_Internal_Rela outrel;
7253   bfd_byte *loc;
7254   struct got_entry **local_got_ents;
7255   bfd_vma TOCstart;
7256   bfd_boolean ret = TRUE;
7257   bfd_boolean is_opd;
7258   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
7259   bfd_boolean is_power4 = FALSE;
7260
7261   if (info->relocatable)
7262     return TRUE;
7263
7264   /* Initialize howto table if needed.  */
7265   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
7266     ppc_howto_init ();
7267
7268   htab = ppc_hash_table (info);
7269   local_got_ents = elf_local_got_ents (input_bfd);
7270   TOCstart = elf_gp (output_bfd);
7271   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
7272   sym_hashes = elf_sym_hashes (input_bfd);
7273   is_opd = ppc64_elf_section_data (input_section)->opd.adjust != NULL;
7274
7275   rel = relocs;
7276   relend = relocs + input_section->reloc_count;
7277   for (; rel < relend; rel++)
7278     {
7279       enum elf_ppc64_reloc_type r_type;
7280       bfd_vma addend;
7281       bfd_reloc_status_type r;
7282       Elf_Internal_Sym *sym;
7283       asection *sec;
7284       struct elf_link_hash_entry *h;
7285       struct elf_link_hash_entry *fdh;
7286       const char *sym_name;
7287       unsigned long r_symndx;
7288       char tls_mask, tls_gd, tls_type;
7289       bfd_vma relocation;
7290       bfd_boolean unresolved_reloc;
7291       bfd_boolean warned;
7292       unsigned long insn, mask;
7293       struct ppc_stub_hash_entry *stub_entry;
7294       bfd_vma max_br_offset;
7295       bfd_vma from;
7296
7297       r_type = ELF64_R_TYPE (rel->r_info);
7298       r_symndx = ELF64_R_SYM (rel->r_info);
7299       sym = NULL;
7300       sec = NULL;
7301       h = NULL;
7302       sym_name = NULL;
7303       unresolved_reloc = FALSE;
7304       warned = FALSE;
7305
7306       if (r_symndx < symtab_hdr->sh_info)
7307         {
7308           /* It's a local symbol.  */
7309           sym = local_syms + r_symndx;
7310           sec = local_sections[r_symndx];
7311           sym_name = bfd_elf_local_sym_name (input_bfd, sym);
7312           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
7313           if (elf_section_data (sec) != NULL)
7314             {
7315               long *opd_sym_adjust;
7316
7317               opd_sym_adjust = ppc64_elf_section_data (sec)->opd.adjust;
7318               if (opd_sym_adjust != NULL && sym->st_value % 24 == 0)
7319                 relocation += opd_sym_adjust[sym->st_value / 24];
7320             }
7321         }
7322       else
7323         {
7324           /* It's a global symbol.  */
7325           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7326           while (h->root.type == bfd_link_hash_indirect
7327                  || h->root.type == bfd_link_hash_warning)
7328             h = (struct elf_link_hash_entry *) h->root.u.i.link;
7329           sym_name = h->root.root.string;
7330           relocation = 0;
7331           if (h->root.type == bfd_link_hash_defined
7332               || h->root.type == bfd_link_hash_defweak)
7333             {
7334               sec = h->root.u.def.section;
7335               if (sec->output_section == NULL)
7336                 /* Set a flag that will be cleared later if we find a
7337                    relocation value for this symbol.  output_section
7338                    is typically NULL for symbols satisfied by a shared
7339                    library.  */
7340                 unresolved_reloc = TRUE;
7341               else
7342                 relocation = (h->root.u.def.value
7343                               + sec->output_section->vma
7344                               + sec->output_offset);
7345             }
7346           else if (h->root.type == bfd_link_hash_undefweak)
7347             ;
7348           else if (!info->executable
7349                    && !info->no_undefined
7350                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
7351             ;
7352           else
7353             {
7354               if (! ((*info->callbacks->undefined_symbol)
7355                      (info, h->root.root.string, input_bfd, input_section,
7356                       rel->r_offset, (!info->shared
7357                                       || info->no_undefined
7358                                       || ELF_ST_VISIBILITY (h->other)))))
7359                 return FALSE;
7360               warned = TRUE;
7361             }
7362         }
7363
7364       /* TLS optimizations.  Replace instruction sequences and relocs
7365          based on information we collected in tls_optimize.  We edit
7366          RELOCS so that --emit-relocs will output something sensible
7367          for the final instruction stream.  */
7368       tls_mask = 0;
7369       tls_gd = 0;
7370       if (IS_PPC64_TLS_RELOC (r_type))
7371         {
7372           if (h != NULL)
7373             tls_mask = ((struct ppc_link_hash_entry *) h)->tls_mask;
7374           else if (local_got_ents != NULL)
7375             {
7376               char *lgot_masks;
7377               lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
7378               tls_mask = lgot_masks[r_symndx];
7379             }
7380         }
7381
7382       /* Ensure reloc mapping code below stays sane.  */
7383       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
7384           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
7385           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
7386           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
7387           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
7388           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
7389           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
7390           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
7391           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
7392           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
7393         abort ();
7394       switch (r_type)
7395         {
7396         default:
7397           break;
7398
7399         case R_PPC64_TOC16:
7400         case R_PPC64_TOC16_LO:
7401         case R_PPC64_TOC16_DS:
7402         case R_PPC64_TOC16_LO_DS:
7403           {
7404             /* Check for toc tls entries.  */
7405             char *toc_tls;
7406             int retval;
7407
7408             retval = get_tls_mask (&toc_tls, &local_syms, rel, input_bfd);
7409             if (retval == 0)
7410               return FALSE;
7411
7412             if (toc_tls)
7413               {
7414                 tls_mask = *toc_tls;
7415                 if (r_type == R_PPC64_TOC16_DS
7416                     || r_type == R_PPC64_TOC16_LO_DS)
7417                   {
7418                     if (tls_mask != 0
7419                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
7420                       goto toctprel;
7421                   }
7422                 else
7423                   {
7424                     /* If we found a GD reloc pair, then we might be
7425                        doing a GD->IE transition.  */
7426                     if (retval == 2)
7427                       {
7428                         tls_gd = TLS_TPRELGD;
7429                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
7430                           goto tls_get_addr_check;
7431                       }
7432                     else if (retval == 3)
7433                       {
7434                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
7435                           goto tls_get_addr_check;
7436                       }
7437                   }
7438               }
7439           }
7440           break;
7441
7442         case R_PPC64_GOT_TPREL16_DS:
7443         case R_PPC64_GOT_TPREL16_LO_DS:
7444           if (tls_mask != 0
7445               && (tls_mask & TLS_TPREL) == 0)
7446             {
7447             toctprel:
7448               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
7449               insn &= 31 << 21;
7450               insn |= 0x3c0d0000;       /* addis 0,13,0 */
7451               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
7452               r_type = R_PPC64_TPREL16_HA;
7453               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7454             }
7455           break;
7456
7457         case R_PPC64_TLS:
7458           if (tls_mask == 0)
7459             {
7460               /* Check for toc tls entries.  */
7461               char *toc_tls;
7462
7463               if (!get_tls_mask (&toc_tls, &local_syms, rel, input_bfd))
7464                 return FALSE;
7465
7466               if (toc_tls)
7467                 tls_mask = *toc_tls;
7468             }
7469           if (tls_mask != 0
7470               && (tls_mask & TLS_TPREL) == 0)
7471             {
7472               bfd_vma rtra;
7473               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
7474               if ((insn & ((0x3f << 26) | (31 << 11)))
7475                   == ((31 << 26) | (13 << 11)))
7476                 rtra = insn & ((1 << 26) - (1 << 16));
7477               else if ((insn & ((0x3f << 26) | (31 << 16)))
7478                        == ((31 << 26) | (13 << 16)))
7479                 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
7480               else
7481                 abort ();
7482               if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
7483                 /* add -> addi.  */
7484                 insn = 14 << 26;
7485               else if ((insn & (31 << 1)) == 23 << 1
7486                        && ((insn & (31 << 6)) < 14 << 6
7487                            || ((insn & (31 << 6)) >= 16 << 6
7488                                && (insn & (31 << 6)) < 24 << 6)))
7489                 /* load and store indexed -> dform.  */
7490                 insn = (32 | ((insn >> 6) & 31)) << 26;
7491               else if ((insn & (31 << 1)) == 21 << 1
7492                        && (insn & (0x1a << 6)) == 0)
7493                 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
7494                 insn = (((58 | ((insn >> 6) & 4)) << 26)
7495                         | ((insn >> 6) & 1));
7496               else if ((insn & (31 << 1)) == 21 << 1
7497                        && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
7498                 /* lwax -> lwa.  */
7499                 insn = (58 << 26) | 2;
7500               else
7501                 abort ();
7502               insn |= rtra;
7503               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
7504               r_type = R_PPC64_TPREL16_LO;
7505               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7506               /* Was PPC64_TLS which sits on insn boundary, now
7507                  PPC64_TPREL16_LO which is at insn+2.  */
7508               rel->r_offset += 2;
7509             }
7510           break;
7511
7512         case R_PPC64_GOT_TLSGD16_HI:
7513         case R_PPC64_GOT_TLSGD16_HA:
7514           tls_gd = TLS_TPRELGD;
7515           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
7516             goto tls_gdld_hi;
7517           break;
7518
7519         case R_PPC64_GOT_TLSLD16_HI:
7520         case R_PPC64_GOT_TLSLD16_HA:
7521           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
7522             {
7523             tls_gdld_hi:
7524               if ((tls_mask & tls_gd) != 0)
7525                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
7526                           + R_PPC64_GOT_TPREL16_DS);
7527               else
7528                 {
7529                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
7530                   rel->r_offset -= 2;
7531                   r_type = R_PPC64_NONE;
7532                 }
7533               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7534             }
7535           break;
7536
7537         case R_PPC64_GOT_TLSGD16:
7538         case R_PPC64_GOT_TLSGD16_LO:
7539           tls_gd = TLS_TPRELGD;
7540           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
7541             goto tls_get_addr_check;
7542           break;
7543
7544         case R_PPC64_GOT_TLSLD16:
7545         case R_PPC64_GOT_TLSLD16_LO:
7546           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
7547             {
7548             tls_get_addr_check:
7549               if (rel + 1 < relend)
7550                 {
7551                   enum elf_ppc64_reloc_type r_type2;
7552                   unsigned long r_symndx2;
7553                   struct elf_link_hash_entry *h2;
7554                   bfd_vma insn1, insn2, insn3;
7555                   bfd_vma offset;
7556
7557                   /* The next instruction should be a call to
7558                      __tls_get_addr.  Peek at the reloc to be sure.  */
7559                   r_type2 = ELF64_R_TYPE (rel[1].r_info);
7560                   r_symndx2 = ELF64_R_SYM (rel[1].r_info);
7561                   if (r_symndx2 < symtab_hdr->sh_info
7562                       || (r_type2 != R_PPC64_REL14
7563                           && r_type2 != R_PPC64_REL14_BRTAKEN
7564                           && r_type2 != R_PPC64_REL14_BRNTAKEN
7565                           && r_type2 != R_PPC64_REL24))
7566                     break;
7567
7568                   h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
7569                   while (h2->root.type == bfd_link_hash_indirect
7570                          || h2->root.type == bfd_link_hash_warning)
7571                     h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
7572                   if (h2 == NULL || h2 != htab->tls_get_addr)
7573                     break;
7574
7575                   /* OK, it checks out.  Replace the call.  */
7576                   offset = rel[1].r_offset;
7577                   insn1 = bfd_get_32 (output_bfd,
7578                                       contents + rel->r_offset - 2);
7579                   insn3 = bfd_get_32 (output_bfd,
7580                                       contents + offset + 4);
7581                   if ((tls_mask & tls_gd) != 0)
7582                     {
7583                       /* IE */
7584                       insn1 &= (1 << 26) - (1 << 2);
7585                       insn1 |= 58 << 26;        /* ld */
7586                       insn2 = 0x7c636a14;       /* add 3,3,13 */
7587                       rel[1].r_info = ELF64_R_INFO (r_symndx2, R_PPC64_NONE);
7588                       if ((tls_mask & TLS_EXPLICIT) == 0)
7589                         r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
7590                                   + R_PPC64_GOT_TPREL16_DS);
7591                       else
7592                         r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
7593                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7594                     }
7595                   else
7596                     {
7597                       /* LE */
7598                       insn1 = 0x3c6d0000;       /* addis 3,13,0 */
7599                       insn2 = 0x38630000;       /* addi 3,3,0 */
7600                       if (tls_gd == 0)
7601                         {
7602                           /* Was an LD reloc.  */
7603                           r_symndx = 0;
7604                           rel->r_addend = htab->tls_sec->vma + DTP_OFFSET;
7605                           rel[1].r_addend = htab->tls_sec->vma + DTP_OFFSET;
7606                         }
7607                       r_type = R_PPC64_TPREL16_HA;
7608                       rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7609                       rel[1].r_info = ELF64_R_INFO (r_symndx,
7610                                                     R_PPC64_TPREL16_LO);
7611                       rel[1].r_offset += 2;
7612                     }
7613                   if (insn3 == NOP
7614                       || insn3 == CROR_151515 || insn3 == CROR_313131)
7615                     {
7616                       insn3 = insn2;
7617                       insn2 = NOP;
7618                       rel[1].r_offset += 4;
7619                     }
7620                   bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
7621                   bfd_put_32 (output_bfd, insn2, contents + offset);
7622                   bfd_put_32 (output_bfd, insn3, contents + offset + 4);
7623                   if (tls_gd == 0)
7624                     {
7625                       /* We changed the symbol on an LD reloc.  Start over
7626                          in order to get h, sym, sec etc. right.  */
7627                       rel--;
7628                       continue;
7629                     }
7630                 }
7631             }
7632           break;
7633
7634         case R_PPC64_DTPMOD64:
7635           if (rel + 1 < relend
7636               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
7637               && rel[1].r_offset == rel->r_offset + 8)
7638             {
7639               if ((tls_mask & TLS_GD) == 0)
7640                 {
7641                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
7642                   if ((tls_mask & TLS_TPRELGD) != 0)
7643                     r_type = R_PPC64_TPREL64;
7644                   else
7645                     {
7646                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
7647                       r_type = R_PPC64_NONE;
7648                     }
7649                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7650                 }
7651             }
7652           else
7653             {
7654               if ((tls_mask & TLS_LD) == 0)
7655                 {
7656                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
7657                   r_type = R_PPC64_NONE;
7658                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7659                 }
7660             }
7661           break;
7662
7663         case R_PPC64_TPREL64:
7664           if ((tls_mask & TLS_TPREL) == 0)
7665             {
7666               r_type = R_PPC64_NONE;
7667               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
7668             }
7669           break;
7670         }
7671
7672       /* Handle other relocations that tweak non-addend part of insn.  */
7673       insn = 0;
7674       switch (r_type)
7675         {
7676         default:
7677           break;
7678
7679           /* Branch taken prediction relocations.  */
7680         case R_PPC64_ADDR14_BRTAKEN:
7681         case R_PPC64_REL14_BRTAKEN:
7682           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
7683           /* Fall thru.  */
7684
7685           /* Branch not taken prediction relocations.  */
7686         case R_PPC64_ADDR14_BRNTAKEN:
7687         case R_PPC64_REL14_BRNTAKEN:
7688           insn |= bfd_get_32 (output_bfd,
7689                               contents + rel->r_offset) & ~(0x01 << 21);
7690           if (is_power4)
7691             {
7692               /* Set 'a' bit.  This is 0b00010 in BO field for branch
7693                  on CR(BI) insns (BO == 001at or 011at), and 0b01000
7694                  for branch on CTR insns (BO == 1a00t or 1a01t).  */
7695               if ((insn & (0x14 << 21)) == (0x04 << 21))
7696                 insn |= 0x02 << 21;
7697               else if ((insn & (0x14 << 21)) == (0x10 << 21))
7698                 insn |= 0x08 << 21;
7699               else
7700                 break;
7701             }
7702           else
7703             {
7704               from = (rel->r_offset
7705                       + input_section->output_offset
7706                       + input_section->output_section->vma);
7707
7708               /* Invert 'y' bit if not the default.  */
7709               if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
7710                 insn ^= 0x01 << 21;
7711             }
7712
7713           bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
7714           break;
7715
7716         case R_PPC64_REL24:
7717           /* Calls to functions with a different TOC, such as calls to
7718              shared objects, need to alter the TOC pointer.  This is
7719              done using a linkage stub.  A REL24 branching to these
7720              linkage stubs needs to be followed by a nop, as the nop
7721              will be replaced with an instruction to restore the TOC
7722              base pointer.  */
7723           if (((h != NULL
7724                 && (fdh = ((struct ppc_link_hash_entry *) h)->oh) != NULL
7725                 && fdh->plt.plist != NULL)
7726                || ((fdh = h, sec) != NULL
7727                    && sec->output_section != NULL
7728                    && (htab->stub_group[sec->id].toc_off
7729                        != htab->stub_group[input_section->id].toc_off)))
7730               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
7731                                                    rel, htab)) != NULL
7732               && (stub_entry->stub_type == ppc_stub_plt_call
7733                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
7734                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
7735             {
7736               bfd_boolean can_plt_call = 0;
7737
7738               if (rel->r_offset + 8 <= input_section->_cooked_size)
7739                 {
7740                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
7741                   if (insn == NOP
7742                       || insn == CROR_151515 || insn == CROR_313131)
7743                     {
7744                       bfd_put_32 (input_bfd, LD_R2_40R1,
7745                                   contents + rel->r_offset + 4);
7746                       can_plt_call = 1;
7747                     }
7748                 }
7749
7750               if (!can_plt_call)
7751                 {
7752                   if (stub_entry->stub_type == ppc_stub_plt_call)
7753                     {
7754                       /* If this is a plain branch rather than a branch
7755                          and link, don't require a nop.  */
7756                       insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7757                       if ((insn & 1) == 0)
7758                         can_plt_call = 1;
7759                     }
7760                   else
7761                     {
7762                       if (strcmp (input_section->output_section->name,
7763                                   ".init") == 0
7764                           || strcmp (input_section->output_section->name,
7765                                      ".fini") == 0)
7766                         (*_bfd_error_handler)
7767                           (_("%s(%s+0x%lx): automatic multiple TOCs "
7768                              "not supported using your crt files; "
7769                              "recompile with -mminimal-toc or upgrade gcc"),
7770                            bfd_archive_filename (input_bfd),
7771                            input_section->name,
7772                            (long) rel->r_offset);
7773                       else
7774                         (*_bfd_error_handler)
7775                           (_("%s(%s+0x%lx): sibling call optimization to `%s' "
7776                              "does not allow automatic multiple TOCs; "
7777                              "recompile with -mminimal-toc or "
7778                              "-fno-optimize-sibling-calls, "
7779                              "or make `%s' extern"),
7780                            bfd_archive_filename (input_bfd),
7781                            input_section->name,
7782                            (long) rel->r_offset,
7783                            sym_name,
7784                            sym_name);
7785                       bfd_set_error (bfd_error_bad_value);
7786                       ret = FALSE;
7787                     }
7788                 }
7789
7790               if (can_plt_call)
7791                 {
7792                   relocation = (stub_entry->stub_offset
7793                                 + stub_entry->stub_sec->output_offset
7794                                 + stub_entry->stub_sec->output_section->vma);
7795                   if (stub_entry->stub_type == ppc_stub_plt_call)
7796                     unresolved_reloc = FALSE;
7797                 }
7798             }
7799
7800           if (h != NULL
7801               && h->root.type == bfd_link_hash_undefweak
7802               && relocation == 0
7803               && rel->r_addend == 0)
7804             {
7805               /* Tweak calls to undefined weak functions to point at a
7806                  blr.  We can thus call a weak function without first
7807                  checking whether the function is defined.  We have a
7808                  blr at the end of .sfpr.  */
7809               BFD_ASSERT (htab->sfpr->_raw_size != 0);
7810               relocation = (htab->sfpr->_raw_size - 4
7811                             + htab->sfpr->output_offset
7812                             + htab->sfpr->output_section->vma);
7813               from = (rel->r_offset
7814                       + input_section->output_offset
7815                       + input_section->output_section->vma);
7816
7817               /* But let's not be silly about it.  If the blr isn't in
7818                  reach, just go to the next instruction.  */
7819               if (relocation - from + (1 << 25) >= (1 << 26)
7820                   || htab->sfpr->_raw_size == 0)
7821                 relocation = from + 4;
7822             }
7823           break;
7824         }
7825
7826       /* Set `addend'.  */
7827       tls_type = 0;
7828       addend = rel->r_addend;
7829       switch (r_type)
7830         {
7831         default:
7832           (*_bfd_error_handler)
7833             (_("%s: unknown relocation type %d for symbol %s"),
7834              bfd_archive_filename (input_bfd), (int) r_type, sym_name);
7835
7836           bfd_set_error (bfd_error_bad_value);
7837           ret = FALSE;
7838           continue;
7839
7840         case R_PPC64_NONE:
7841         case R_PPC64_TLS:
7842         case R_PPC64_GNU_VTINHERIT:
7843         case R_PPC64_GNU_VTENTRY:
7844           continue;
7845
7846           /* GOT16 relocations.  Like an ADDR16 using the symbol's
7847              address in the GOT as relocation value instead of the
7848              symbol's value itself.  Also, create a GOT entry for the
7849              symbol and put the symbol value there.  */
7850         case R_PPC64_GOT_TLSGD16:
7851         case R_PPC64_GOT_TLSGD16_LO:
7852         case R_PPC64_GOT_TLSGD16_HI:
7853         case R_PPC64_GOT_TLSGD16_HA:
7854           tls_type = TLS_TLS | TLS_GD;
7855           goto dogot;
7856
7857         case R_PPC64_GOT_TLSLD16:
7858         case R_PPC64_GOT_TLSLD16_LO:
7859         case R_PPC64_GOT_TLSLD16_HI:
7860         case R_PPC64_GOT_TLSLD16_HA:
7861           tls_type = TLS_TLS | TLS_LD;
7862           goto dogot;
7863
7864         case R_PPC64_GOT_TPREL16_DS:
7865         case R_PPC64_GOT_TPREL16_LO_DS:
7866         case R_PPC64_GOT_TPREL16_HI:
7867         case R_PPC64_GOT_TPREL16_HA:
7868           tls_type = TLS_TLS | TLS_TPREL;
7869           goto dogot;
7870
7871         case R_PPC64_GOT_DTPREL16_DS:
7872         case R_PPC64_GOT_DTPREL16_LO_DS:
7873         case R_PPC64_GOT_DTPREL16_HI:
7874         case R_PPC64_GOT_DTPREL16_HA:
7875           tls_type = TLS_TLS | TLS_DTPREL;
7876           goto dogot;
7877
7878         case R_PPC64_GOT16:
7879         case R_PPC64_GOT16_LO:
7880         case R_PPC64_GOT16_HI:
7881         case R_PPC64_GOT16_HA:
7882         case R_PPC64_GOT16_DS:
7883         case R_PPC64_GOT16_LO_DS:
7884         dogot:
7885           {
7886             /* Relocation is to the entry for this symbol in the global
7887                offset table.  */
7888             asection *got;
7889             bfd_vma *offp;
7890             bfd_vma off;
7891             unsigned long indx = 0;
7892
7893             if (tls_type == (TLS_TLS | TLS_LD)
7894                 && (h == NULL
7895                     || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)))
7896               offp = &ppc64_tlsld_got (input_bfd)->offset;
7897             else
7898               {
7899                 struct got_entry *ent;
7900
7901                 if (h != NULL)
7902                   {
7903                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
7904                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7905                         || (info->shared
7906                             && SYMBOL_REFERENCES_LOCAL (info, h)))
7907                       /* This is actually a static link, or it is a
7908                          -Bsymbolic link and the symbol is defined
7909                          locally, or the symbol was forced to be local
7910                          because of a version file.  */
7911                       ;
7912                     else
7913                       {
7914                         indx = h->dynindx;
7915                         unresolved_reloc = FALSE;
7916                       }
7917                     ent = h->got.glist;
7918                   }
7919                 else
7920                   {
7921                     if (local_got_ents == NULL)
7922                       abort ();
7923                     ent = local_got_ents[r_symndx];
7924                   }
7925
7926                 for (; ent != NULL; ent = ent->next)
7927                   if (ent->addend == rel->r_addend
7928                       && ent->owner == input_bfd
7929                       && ent->tls_type == tls_type)
7930                     break;
7931                 if (ent == NULL)
7932                   abort ();
7933                 offp = &ent->got.offset;
7934               }
7935
7936             got = ppc64_elf_tdata (input_bfd)->got;
7937             if (got == NULL)
7938               abort ();
7939
7940             /* The offset must always be a multiple of 8.  We use the
7941                least significant bit to record whether we have already
7942                processed this entry.  */
7943             off = *offp;
7944             if ((off & 1) != 0)
7945               off &= ~1;
7946             else
7947               {
7948                 /* Generate relocs for the dynamic linker, except in
7949                    the case of TLSLD where we'll use one entry per
7950                    module.  */
7951                 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
7952
7953                 *offp = off | 1;
7954                 if ((info->shared || indx != 0)
7955                     && (h == NULL
7956                         || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7957                         || h->root.type != bfd_link_hash_undefweak))
7958                   {
7959                     outrel.r_offset = (got->output_section->vma
7960                                        + got->output_offset
7961                                        + off);
7962                     outrel.r_addend = rel->r_addend;
7963                     if (tls_type & (TLS_LD | TLS_GD))
7964                       {
7965                         outrel.r_addend = 0;
7966                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
7967                         if (tls_type == (TLS_TLS | TLS_GD))
7968                           {
7969                             loc = relgot->contents;
7970                             loc += (relgot->reloc_count++
7971                                     * sizeof (Elf64_External_Rela));
7972                             bfd_elf64_swap_reloca_out (output_bfd,
7973                                                        &outrel, loc);
7974                             outrel.r_offset += 8;
7975                             outrel.r_addend = rel->r_addend;
7976                             outrel.r_info
7977                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
7978                           }
7979                       }
7980                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
7981                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
7982                     else if (tls_type == (TLS_TLS | TLS_TPREL))
7983                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
7984                     else if (indx == 0)
7985                       {
7986                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
7987
7988                         /* Write the .got section contents for the sake
7989                            of prelink.  */
7990                         loc = got->contents + off;
7991                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
7992                                     loc);
7993                       }
7994                     else
7995                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
7996
7997                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
7998                       {
7999                         outrel.r_addend += relocation;
8000                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
8001                           outrel.r_addend -= htab->tls_sec->vma;
8002                       }
8003                     loc = relgot->contents;
8004                     loc += (relgot->reloc_count++
8005                             * sizeof (Elf64_External_Rela));
8006                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
8007                   }
8008
8009                 /* Init the .got section contents here if we're not
8010                    emitting a reloc.  */
8011                 else
8012                   {
8013                     relocation += rel->r_addend;
8014                     if (tls_type == (TLS_TLS | TLS_LD))
8015                       relocation = 1;
8016                     else if (tls_type != 0)
8017                       {
8018                         relocation -= htab->tls_sec->vma + DTP_OFFSET;
8019                         if (tls_type == (TLS_TLS | TLS_TPREL))
8020                           relocation += DTP_OFFSET - TP_OFFSET;
8021
8022                         if (tls_type == (TLS_TLS | TLS_GD))
8023                           {
8024                             bfd_put_64 (output_bfd, relocation,
8025                                         got->contents + off + 8);
8026                             relocation = 1;
8027                           }
8028                       }
8029
8030                     bfd_put_64 (output_bfd, relocation,
8031                                 got->contents + off);
8032                   }
8033               }
8034
8035             if (off >= (bfd_vma) -2)
8036               abort ();
8037
8038             relocation = got->output_offset + off;
8039
8040             /* TOC base (r2) is TOC start plus 0x8000.  */
8041             addend = -TOC_BASE_OFF;
8042           }
8043           break;
8044
8045         case R_PPC64_PLT16_HA:
8046         case R_PPC64_PLT16_HI:
8047         case R_PPC64_PLT16_LO:
8048         case R_PPC64_PLT32:
8049         case R_PPC64_PLT64:
8050           /* Relocation is to the entry for this symbol in the
8051              procedure linkage table.  */
8052
8053           /* Resolve a PLT reloc against a local symbol directly,
8054              without using the procedure linkage table.  */
8055           if (h == NULL)
8056             break;
8057
8058           /* It's possible that we didn't make a PLT entry for this
8059              symbol.  This happens when statically linking PIC code,
8060              or when using -Bsymbolic.  Go find a match if there is a
8061              PLT entry.  */
8062           if (htab->plt != NULL)
8063             {
8064               struct plt_entry *ent;
8065               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
8066                 if (ent->addend == rel->r_addend
8067                     && ent->plt.offset != (bfd_vma) -1)
8068                   {
8069                     relocation = (htab->plt->output_section->vma
8070                                   + htab->plt->output_offset
8071                                   + ent->plt.offset);
8072                     unresolved_reloc = FALSE;
8073                   }
8074             }
8075           break;
8076
8077         case R_PPC64_TOC:
8078           /* Relocation value is TOC base.  */
8079           relocation = TOCstart;
8080           if (r_symndx == 0)
8081             relocation += htab->stub_group[input_section->id].toc_off;
8082           else if (sec != NULL && !unresolved_reloc)
8083             relocation += htab->stub_group[sec->id].toc_off;
8084           else
8085             unresolved_reloc = TRUE;
8086           goto dodyn2;
8087
8088           /* TOC16 relocs.  We want the offset relative to the TOC base,
8089              which is the address of the start of the TOC plus 0x8000.
8090              The TOC consists of sections .got, .toc, .tocbss, and .plt,
8091              in this order.  */
8092         case R_PPC64_TOC16:
8093         case R_PPC64_TOC16_LO:
8094         case R_PPC64_TOC16_HI:
8095         case R_PPC64_TOC16_DS:
8096         case R_PPC64_TOC16_LO_DS:
8097         case R_PPC64_TOC16_HA:
8098           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
8099           break;
8100
8101           /* Relocate against the beginning of the section.  */
8102         case R_PPC64_SECTOFF:
8103         case R_PPC64_SECTOFF_LO:
8104         case R_PPC64_SECTOFF_HI:
8105         case R_PPC64_SECTOFF_DS:
8106         case R_PPC64_SECTOFF_LO_DS:
8107         case R_PPC64_SECTOFF_HA:
8108           if (sec != NULL)
8109             addend -= sec->output_section->vma;
8110           break;
8111
8112         case R_PPC64_REL14:
8113         case R_PPC64_REL14_BRNTAKEN:
8114         case R_PPC64_REL14_BRTAKEN:
8115         case R_PPC64_REL24:
8116           break;
8117
8118         case R_PPC64_TPREL16:
8119         case R_PPC64_TPREL16_LO:
8120         case R_PPC64_TPREL16_HI:
8121         case R_PPC64_TPREL16_HA:
8122         case R_PPC64_TPREL16_DS:
8123         case R_PPC64_TPREL16_LO_DS:
8124         case R_PPC64_TPREL16_HIGHER:
8125         case R_PPC64_TPREL16_HIGHERA:
8126         case R_PPC64_TPREL16_HIGHEST:
8127         case R_PPC64_TPREL16_HIGHESTA:
8128           addend -= htab->tls_sec->vma + TP_OFFSET;
8129           if (info->shared)
8130             /* The TPREL16 relocs shouldn't really be used in shared
8131                libs as they will result in DT_TEXTREL being set, but
8132                support them anyway.  */
8133             goto dodyn;
8134           break;
8135
8136         case R_PPC64_DTPREL16:
8137         case R_PPC64_DTPREL16_LO:
8138         case R_PPC64_DTPREL16_HI:
8139         case R_PPC64_DTPREL16_HA:
8140         case R_PPC64_DTPREL16_DS:
8141         case R_PPC64_DTPREL16_LO_DS:
8142         case R_PPC64_DTPREL16_HIGHER:
8143         case R_PPC64_DTPREL16_HIGHERA:
8144         case R_PPC64_DTPREL16_HIGHEST:
8145         case R_PPC64_DTPREL16_HIGHESTA:
8146           addend -= htab->tls_sec->vma + DTP_OFFSET;
8147           break;
8148
8149         case R_PPC64_DTPMOD64:
8150           relocation = 1;
8151           addend = 0;
8152           goto dodyn;
8153
8154         case R_PPC64_TPREL64:
8155           addend -= htab->tls_sec->vma + TP_OFFSET;
8156           goto dodyn;
8157
8158         case R_PPC64_DTPREL64:
8159           addend -= htab->tls_sec->vma + DTP_OFFSET;
8160           /* Fall thru */
8161
8162           /* Relocations that may need to be propagated if this is a
8163              dynamic object.  */
8164         case R_PPC64_REL30:
8165         case R_PPC64_REL32:
8166         case R_PPC64_REL64:
8167         case R_PPC64_ADDR14:
8168         case R_PPC64_ADDR14_BRNTAKEN:
8169         case R_PPC64_ADDR14_BRTAKEN:
8170         case R_PPC64_ADDR16:
8171         case R_PPC64_ADDR16_DS:
8172         case R_PPC64_ADDR16_HA:
8173         case R_PPC64_ADDR16_HI:
8174         case R_PPC64_ADDR16_HIGHER:
8175         case R_PPC64_ADDR16_HIGHERA:
8176         case R_PPC64_ADDR16_HIGHEST:
8177         case R_PPC64_ADDR16_HIGHESTA:
8178         case R_PPC64_ADDR16_LO:
8179         case R_PPC64_ADDR16_LO_DS:
8180         case R_PPC64_ADDR24:
8181         case R_PPC64_ADDR32:
8182         case R_PPC64_ADDR64:
8183         case R_PPC64_UADDR16:
8184         case R_PPC64_UADDR32:
8185         case R_PPC64_UADDR64:
8186           /* r_symndx will be zero only for relocs against symbols
8187              from removed linkonce sections, or sections discarded by
8188              a linker script.  */
8189         dodyn:
8190           if (r_symndx == 0)
8191             break;
8192           /* Fall thru.  */
8193
8194         dodyn2:
8195           if ((input_section->flags & SEC_ALLOC) == 0)
8196             break;
8197
8198           if (NO_OPD_RELOCS && is_opd)
8199             break;
8200
8201           if ((info->shared
8202                && (h == NULL
8203                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8204                    || h->root.type != bfd_link_hash_undefweak)
8205                && (MUST_BE_DYN_RELOC (r_type)
8206                    || !SYMBOL_CALLS_LOCAL (info, h)))
8207               || (ELIMINATE_COPY_RELOCS
8208                   && !info->shared
8209                   && h != NULL
8210                   && h->dynindx != -1
8211                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
8212                   && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
8213                   && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0))
8214             {
8215               Elf_Internal_Rela outrel;
8216               bfd_boolean skip, relocate;
8217               asection *sreloc;
8218               bfd_byte *loc;
8219               bfd_vma out_off;
8220
8221               /* When generating a dynamic object, these relocations
8222                  are copied into the output file to be resolved at run
8223                  time.  */
8224
8225               skip = FALSE;
8226               relocate = FALSE;
8227
8228               out_off = _bfd_elf_section_offset (output_bfd, info,
8229                                                  input_section, rel->r_offset);
8230               if (out_off == (bfd_vma) -1)
8231                 skip = TRUE;
8232               else if (out_off == (bfd_vma) -2)
8233                 skip = TRUE, relocate = TRUE;
8234               out_off += (input_section->output_section->vma
8235                           + input_section->output_offset);
8236               outrel.r_offset = out_off;
8237               outrel.r_addend = rel->r_addend;
8238
8239               /* Optimize unaligned reloc use.  */
8240               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
8241                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
8242                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
8243               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
8244                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
8245                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
8246               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
8247                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
8248                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
8249
8250               if (skip)
8251                 memset (&outrel, 0, sizeof outrel);
8252               else if (!SYMBOL_REFERENCES_LOCAL (info, h)
8253                        && !is_opd
8254                        && r_type != R_PPC64_TOC)
8255                 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
8256               else
8257                 {
8258                   /* This symbol is local, or marked to become local,
8259                      or this is an opd section reloc which must point
8260                      at a local function.  */
8261                   outrel.r_addend += relocation;
8262                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
8263                     {
8264                       if (is_opd && h != NULL)
8265                         {
8266                           /* Lie about opd entries.  This case occurs
8267                              when building shared libraries and we
8268                              reference a function in another shared
8269                              lib.  The same thing happens for a weak
8270                              definition in an application that's
8271                              overridden by a strong definition in a
8272                              shared lib.  (I believe this is a generic
8273                              bug in binutils handling of weak syms.)
8274                              In these cases we won't use the opd
8275                              entry in this lib.  */
8276                           unresolved_reloc = FALSE;
8277                         }
8278                       outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8279
8280                       /* We need to relocate .opd contents for ld.so.
8281                          Prelink also wants simple and consistent rules
8282                          for relocs.  This make all RELATIVE relocs have
8283                          *r_offset equal to r_addend.  */
8284                       relocate = TRUE;
8285                     }
8286                   else
8287                     {
8288                       long indx = 0;
8289
8290                       if (bfd_is_abs_section (sec))
8291                         ;
8292                       else if (sec == NULL || sec->owner == NULL)
8293                         {
8294                           bfd_set_error (bfd_error_bad_value);
8295                           return FALSE;
8296                         }
8297                       else
8298                         {
8299                           asection *osec;
8300
8301                           osec = sec->output_section;
8302                           indx = elf_section_data (osec)->dynindx;
8303
8304                           /* We are turning this relocation into one
8305                              against a section symbol, so subtract out
8306                              the output section's address but not the
8307                              offset of the input section in the output
8308                              section.  */
8309                           outrel.r_addend -= osec->vma;
8310                         }
8311
8312                       outrel.r_info = ELF64_R_INFO (indx, r_type);
8313                     }
8314                 }
8315
8316               sreloc = elf_section_data (input_section)->sreloc;
8317               if (sreloc == NULL)
8318                 abort ();
8319
8320               loc = sreloc->contents;
8321               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
8322               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
8323
8324               /* If this reloc is against an external symbol, it will
8325                  be computed at runtime, so there's no need to do
8326                  anything now.  However, for the sake of prelink ensure
8327                  that the section contents are a known value.  */
8328               if (! relocate)
8329                 {
8330                   unresolved_reloc = FALSE;
8331                   /* The value chosen here is quite arbitrary as ld.so
8332                      ignores section contents except for the special
8333                      case of .opd where the contents might be accessed
8334                      before relocation.  Choose zero, as that won't
8335                      cause reloc overflow.  */
8336                   relocation = 0;
8337                   addend = 0;
8338                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
8339                      to improve backward compatibility with older
8340                      versions of ld.  */
8341                   if (r_type == R_PPC64_ADDR64)
8342                     addend = outrel.r_addend;
8343                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
8344                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
8345                     addend = (input_section->output_section->vma
8346                               + input_section->output_offset
8347                               + rel->r_offset);
8348                 }
8349             }
8350           break;
8351
8352         case R_PPC64_COPY:
8353         case R_PPC64_GLOB_DAT:
8354         case R_PPC64_JMP_SLOT:
8355         case R_PPC64_RELATIVE:
8356           /* We shouldn't ever see these dynamic relocs in relocatable
8357              files.  */
8358           /* Fall through.  */
8359
8360         case R_PPC64_PLTGOT16:
8361         case R_PPC64_PLTGOT16_DS:
8362         case R_PPC64_PLTGOT16_HA:
8363         case R_PPC64_PLTGOT16_HI:
8364         case R_PPC64_PLTGOT16_LO:
8365         case R_PPC64_PLTGOT16_LO_DS:
8366         case R_PPC64_PLTREL32:
8367         case R_PPC64_PLTREL64:
8368           /* These ones haven't been implemented yet.  */
8369
8370           (*_bfd_error_handler)
8371             (_("%s: relocation %s is not supported for symbol %s."),
8372              bfd_archive_filename (input_bfd),
8373              ppc64_elf_howto_table[r_type]->name, sym_name);
8374
8375           bfd_set_error (bfd_error_invalid_operation);
8376           ret = FALSE;
8377           continue;
8378         }
8379
8380       /* Do any further special processing.  */
8381       switch (r_type)
8382         {
8383         default:
8384           break;
8385
8386         case R_PPC64_ADDR16_HA:
8387         case R_PPC64_ADDR16_HIGHERA:
8388         case R_PPC64_ADDR16_HIGHESTA:
8389         case R_PPC64_GOT16_HA:
8390         case R_PPC64_PLTGOT16_HA:
8391         case R_PPC64_PLT16_HA:
8392         case R_PPC64_TOC16_HA:
8393         case R_PPC64_SECTOFF_HA:
8394         case R_PPC64_TPREL16_HA:
8395         case R_PPC64_DTPREL16_HA:
8396         case R_PPC64_GOT_TLSGD16_HA:
8397         case R_PPC64_GOT_TLSLD16_HA:
8398         case R_PPC64_GOT_TPREL16_HA:
8399         case R_PPC64_GOT_DTPREL16_HA:
8400         case R_PPC64_TPREL16_HIGHER:
8401         case R_PPC64_TPREL16_HIGHERA:
8402         case R_PPC64_TPREL16_HIGHEST:
8403         case R_PPC64_TPREL16_HIGHESTA:
8404         case R_PPC64_DTPREL16_HIGHER:
8405         case R_PPC64_DTPREL16_HIGHERA:
8406         case R_PPC64_DTPREL16_HIGHEST:
8407         case R_PPC64_DTPREL16_HIGHESTA:
8408           /* It's just possible that this symbol is a weak symbol
8409              that's not actually defined anywhere. In that case,
8410              'sec' would be NULL, and we should leave the symbol
8411              alone (it will be set to zero elsewhere in the link).  */
8412           if (sec != NULL)
8413             /* Add 0x10000 if sign bit in 0:15 is set.
8414                Bits 0:15 are not used.  */
8415             addend += 0x8000;
8416           break;
8417
8418         case R_PPC64_ADDR16_DS:
8419         case R_PPC64_ADDR16_LO_DS:
8420         case R_PPC64_GOT16_DS:
8421         case R_PPC64_GOT16_LO_DS:
8422         case R_PPC64_PLT16_LO_DS:
8423         case R_PPC64_SECTOFF_DS:
8424         case R_PPC64_SECTOFF_LO_DS:
8425         case R_PPC64_TOC16_DS:
8426         case R_PPC64_TOC16_LO_DS:
8427         case R_PPC64_PLTGOT16_DS:
8428         case R_PPC64_PLTGOT16_LO_DS:
8429         case R_PPC64_GOT_TPREL16_DS:
8430         case R_PPC64_GOT_TPREL16_LO_DS:
8431         case R_PPC64_GOT_DTPREL16_DS:
8432         case R_PPC64_GOT_DTPREL16_LO_DS:
8433         case R_PPC64_TPREL16_DS:
8434         case R_PPC64_TPREL16_LO_DS:
8435         case R_PPC64_DTPREL16_DS:
8436         case R_PPC64_DTPREL16_LO_DS:
8437           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
8438           mask = 3;
8439           /* If this reloc is against an lq insn, then the value must be
8440              a multiple of 16.  This is somewhat of a hack, but the
8441              "correct" way to do this by defining _DQ forms of all the
8442              _DS relocs bloats all reloc switches in this file.  It
8443              doesn't seem to make much sense to use any of these relocs
8444              in data, so testing the insn should be safe.  */
8445           if ((insn & (0x3f << 26)) == (56u << 26))
8446             mask = 15;
8447           if (((relocation + addend) & mask) != 0)
8448             {
8449               (*_bfd_error_handler)
8450                 (_("%s: error: relocation %s not a multiple of %d"),
8451                  bfd_archive_filename (input_bfd),
8452                  ppc64_elf_howto_table[r_type]->name,
8453                  mask + 1);
8454               bfd_set_error (bfd_error_bad_value);
8455               ret = FALSE;
8456               continue;
8457             }
8458           break;
8459
8460         case R_PPC64_REL14:
8461         case R_PPC64_REL14_BRNTAKEN:
8462         case R_PPC64_REL14_BRTAKEN:
8463           max_br_offset = 1 << 15;
8464           goto branch_check;
8465
8466         case R_PPC64_REL24:
8467           max_br_offset = 1 << 25;
8468
8469         branch_check:
8470           /* If the branch is out of reach or the TOC register needs
8471              adjusting, then redirect the call to the local stub for
8472              this function.  */
8473           from = (rel->r_offset
8474                   + input_section->output_offset
8475                   + input_section->output_section->vma);
8476           if ((relocation + addend - from + max_br_offset >= 2 * max_br_offset
8477                || (sec != NULL
8478                    && sec->output_section != NULL
8479                    && sec->id <= htab->top_id
8480                    && (htab->stub_group[sec->id].toc_off
8481                        != htab->stub_group[input_section->id].toc_off)))
8482               && (stub_entry = ppc_get_stub_entry (input_section, sec, h,
8483                                                    rel, htab)) != NULL)
8484             {
8485               /* Munge up the value and addend so that we call the stub
8486                  rather than the procedure directly.  */
8487               relocation = (stub_entry->stub_offset
8488                             + stub_entry->stub_sec->output_offset
8489                             + stub_entry->stub_sec->output_section->vma);
8490               addend = 0;
8491             }
8492           break;
8493         }
8494
8495       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
8496          because such sections are not SEC_ALLOC and thus ld.so will
8497          not process them.  */
8498       if (unresolved_reloc
8499           && !((input_section->flags & SEC_DEBUGGING) != 0
8500                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
8501         {
8502           (*_bfd_error_handler)
8503             (_("%s(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
8504              bfd_archive_filename (input_bfd),
8505              bfd_get_section_name (input_bfd, input_section),
8506              (long) rel->r_offset,
8507              ppc64_elf_howto_table[(int) r_type]->name,
8508              h->root.root.string);
8509           ret = FALSE;
8510         }
8511
8512       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
8513                                     input_bfd,
8514                                     input_section,
8515                                     contents,
8516                                     rel->r_offset,
8517                                     relocation,
8518                                     addend);
8519
8520       if (r != bfd_reloc_ok)
8521         {
8522           if (sym_name == NULL)
8523             sym_name = "(null)";
8524           if (r == bfd_reloc_overflow)
8525             {
8526               if (warned)
8527                 continue;
8528               if (h != NULL
8529                   && h->root.type == bfd_link_hash_undefweak
8530                   && ppc64_elf_howto_table[r_type]->pc_relative)
8531                 {
8532                   /* Assume this is a call protected by other code that
8533                      detects the symbol is undefined.  If this is the case,
8534                      we can safely ignore the overflow.  If not, the
8535                      program is hosed anyway, and a little warning isn't
8536                      going to help.  */
8537
8538                   continue;
8539                 }
8540
8541               if (!((*info->callbacks->reloc_overflow)
8542                     (info, sym_name, ppc64_elf_howto_table[r_type]->name,
8543                      rel->r_addend, input_bfd, input_section, rel->r_offset)))
8544                 return FALSE;
8545             }
8546           else
8547             {
8548               (*_bfd_error_handler)
8549                 (_("%s(%s+0x%lx): %s reloc against `%s': error %d"),
8550                  bfd_archive_filename (input_bfd),
8551                  bfd_get_section_name (input_bfd, input_section),
8552                  (long) rel->r_offset,
8553                  ppc64_elf_howto_table[r_type]->name,
8554                  sym_name,
8555                  (int) r);
8556               ret = FALSE;
8557             }
8558         }
8559     }
8560
8561   return ret;
8562 }
8563
8564 /* Finish up dynamic symbol handling.  We set the contents of various
8565    dynamic sections here.  */
8566
8567 static bfd_boolean
8568 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
8569                                  struct bfd_link_info *info,
8570                                  struct elf_link_hash_entry *h,
8571                                  Elf_Internal_Sym *sym)
8572 {
8573   struct ppc_link_hash_table *htab;
8574   bfd *dynobj;
8575
8576   htab = ppc_hash_table (info);
8577   dynobj = htab->elf.dynobj;
8578
8579   if (((struct ppc_link_hash_entry *) h)->is_func_descriptor)
8580     {
8581       struct plt_entry *ent;
8582       Elf_Internal_Rela rela;
8583       bfd_byte *loc;
8584
8585       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
8586         if (ent->plt.offset != (bfd_vma) -1)
8587           {
8588             /* This symbol has an entry in the procedure linkage
8589                table.  Set it up.  */
8590
8591             if (htab->plt == NULL
8592                 || htab->relplt == NULL
8593                 || htab->glink == NULL)
8594               abort ();
8595
8596             /* Create a JMP_SLOT reloc to inform the dynamic linker to
8597                fill in the PLT entry.  */
8598             rela.r_offset = (htab->plt->output_section->vma
8599                              + htab->plt->output_offset
8600                              + ent->plt.offset);
8601             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
8602             rela.r_addend = ent->addend;
8603
8604             loc = htab->relplt->contents;
8605             loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
8606                     * sizeof (Elf64_External_Rela));
8607             bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
8608           }
8609     }
8610
8611   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
8612     {
8613       Elf_Internal_Rela rela;
8614       bfd_byte *loc;
8615
8616       /* This symbol needs a copy reloc.  Set it up.  */
8617
8618       if (h->dynindx == -1
8619           || (h->root.type != bfd_link_hash_defined
8620               && h->root.type != bfd_link_hash_defweak)
8621           || htab->relbss == NULL)
8622         abort ();
8623
8624       rela.r_offset = (h->root.u.def.value
8625                        + h->root.u.def.section->output_section->vma
8626                        + h->root.u.def.section->output_offset);
8627       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
8628       rela.r_addend = 0;
8629       loc = htab->relbss->contents;
8630       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
8631       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
8632     }
8633
8634   /* Mark some specially defined symbols as absolute.  */
8635   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
8636     sym->st_shndx = SHN_ABS;
8637
8638   return TRUE;
8639 }
8640
8641 /* Used to decide how to sort relocs in an optimal manner for the
8642    dynamic linker, before writing them out.  */
8643
8644 static enum elf_reloc_type_class
8645 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
8646 {
8647   enum elf_ppc64_reloc_type r_type;
8648
8649   r_type = ELF64_R_TYPE (rela->r_info);
8650   switch (r_type)
8651     {
8652     case R_PPC64_RELATIVE:
8653       return reloc_class_relative;
8654     case R_PPC64_JMP_SLOT:
8655       return reloc_class_plt;
8656     case R_PPC64_COPY:
8657       return reloc_class_copy;
8658     default:
8659       return reloc_class_normal;
8660     }
8661 }
8662
8663 /* Finish up the dynamic sections.  */
8664
8665 static bfd_boolean
8666 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
8667                                    struct bfd_link_info *info)
8668 {
8669   struct ppc_link_hash_table *htab;
8670   bfd *dynobj;
8671   asection *sdyn;
8672
8673   htab = ppc_hash_table (info);
8674   dynobj = htab->elf.dynobj;
8675   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8676
8677   if (htab->elf.dynamic_sections_created)
8678     {
8679       Elf64_External_Dyn *dyncon, *dynconend;
8680
8681       if (sdyn == NULL || htab->got == NULL)
8682         abort ();
8683
8684       dyncon = (Elf64_External_Dyn *) sdyn->contents;
8685       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
8686       for (; dyncon < dynconend; dyncon++)
8687         {
8688           Elf_Internal_Dyn dyn;
8689           asection *s;
8690
8691           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
8692
8693           switch (dyn.d_tag)
8694             {
8695             default:
8696               continue;
8697
8698             case DT_PPC64_GLINK:
8699               s = htab->glink;
8700               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
8701               /* We stupidly defined DT_PPC64_GLINK to be the start
8702                  of glink rather than the first entry point, which is
8703                  what ld.so needs, and now have a bigger stub to
8704                  support automatic multiple TOCs.  */
8705               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
8706               break;
8707
8708             case DT_PPC64_OPD:
8709               s = bfd_get_section_by_name (output_bfd, ".opd");
8710               if (s == NULL)
8711                 continue;
8712               dyn.d_un.d_ptr = s->vma;
8713               break;
8714
8715             case DT_PPC64_OPDSZ:
8716               s = bfd_get_section_by_name (output_bfd, ".opd");
8717               if (s == NULL)
8718                 continue;
8719               dyn.d_un.d_val = s->_raw_size;
8720               break;
8721
8722             case DT_PLTGOT:
8723               s = htab->plt;
8724               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
8725               break;
8726
8727             case DT_JMPREL:
8728               s = htab->relplt;
8729               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
8730               break;
8731
8732             case DT_PLTRELSZ:
8733               dyn.d_un.d_val = htab->relplt->_raw_size;
8734               break;
8735
8736             case DT_RELASZ:
8737               /* Don't count procedure linkage table relocs in the
8738                  overall reloc count.  */
8739               s = htab->relplt;
8740               if (s == NULL)
8741                 continue;
8742               dyn.d_un.d_val -= s->_raw_size;
8743               break;
8744
8745             case DT_RELA:
8746               /* We may not be using the standard ELF linker script.
8747                  If .rela.plt is the first .rela section, we adjust
8748                  DT_RELA to not include it.  */
8749               s = htab->relplt;
8750               if (s == NULL)
8751                 continue;
8752               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
8753                 continue;
8754               dyn.d_un.d_ptr += s->_raw_size;
8755               break;
8756             }
8757
8758           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
8759         }
8760     }
8761
8762   if (htab->got != NULL && htab->got->_raw_size != 0)
8763     {
8764       /* Fill in the first entry in the global offset table.
8765          We use it to hold the link-time TOCbase.  */
8766       bfd_put_64 (output_bfd,
8767                   elf_gp (output_bfd) + TOC_BASE_OFF,
8768                   htab->got->contents);
8769
8770       /* Set .got entry size.  */
8771       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
8772     }
8773
8774   if (htab->plt != NULL && htab->plt->_raw_size != 0)
8775     {
8776       /* Set .plt entry size.  */
8777       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
8778         = PLT_ENTRY_SIZE;
8779     }
8780
8781   /* We need to handle writing out multiple GOT sections ourselves,
8782      since we didn't add them to DYNOBJ.  */
8783   while ((dynobj = dynobj->link_next) != NULL)
8784     {
8785       asection *s;
8786       s = ppc64_elf_tdata (dynobj)->got;
8787       if (s != NULL
8788           && s->_raw_size != 0
8789           && s->output_section != bfd_abs_section_ptr
8790           && !bfd_set_section_contents (output_bfd, s->output_section,
8791                                         s->contents, s->output_offset,
8792                                         s->_raw_size))
8793         return FALSE;
8794       s = ppc64_elf_tdata (dynobj)->relgot;
8795       if (s != NULL
8796           && s->_raw_size != 0
8797           && s->output_section != bfd_abs_section_ptr
8798           && !bfd_set_section_contents (output_bfd, s->output_section,
8799                                         s->contents, s->output_offset,
8800                                         s->_raw_size))
8801         return FALSE;
8802     }
8803
8804   return TRUE;
8805 }
8806
8807 #include "elf64-target.h"