bfd/elf64-ppc.c

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