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