bfd/elf64-ppc.c

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