bfd/elf32-ppc.c

   1 /* PowerPC-specific support for 32-bit ELF
   2    Copyright (C) 1994-2016 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the
  19    Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22
  23 /* This file is based on a preliminary PowerPC ELF ABI.  The
  24    information may not match the final PowerPC ELF ABI.  It includes
  25    suggestions from the in-progress Embedded PowerPC ABI, and that
  26    information may also not match.  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc.h"
  35 #include "elf32-ppc.h"
  36 #include "elf-vxworks.h"
  37 #include "dwarf2.h"
  38
  39 typedef enum split16_format_type
  40 {
  41   split16a_type = 0,
  42   split16d_type
  43 }
  44 split16_format_type;
  45
  46 /* RELA relocations are used here.  */
  47
  48 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc_elf_unhandled_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52
  53 /* Branch prediction bit for branch taken relocs.  */
  54 #define BRANCH_PREDICT_BIT 0x200000
  55 /* Mask to set RA in memory instructions.  */
  56 #define RA_REGISTER_MASK 0x001f0000
  57 /* Value to shift register by to insert RA.  */
  58 #define RA_REGISTER_SHIFT 16
  59
  60 /* The name of the dynamic interpreter.  This is put in the .interp
  61    section.  */
  62 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
  63
  64 /* For old-style PLT.  */
  65 /* The number of single-slot PLT entries (the rest use two slots).  */
  66 #define PLT_NUM_SINGLE_ENTRIES 8192
  67
  68 /* For new-style .glink and .plt.  */
  69 #define GLINK_PLTRESOLVE 16*4
  70 #define GLINK_ENTRY_SIZE 4*4
  71 #define TLS_GET_ADDR_GLINK_SIZE 12*4
  72
  73 /* VxWorks uses its own plt layout, filled in by the static linker.  */
  74
  75 /* The standard VxWorks PLT entry.  */
  76 #define VXWORKS_PLT_ENTRY_SIZE 32
  77 static const bfd_vma ppc_elf_vxworks_plt_entry
  78     [VXWORKS_PLT_ENTRY_SIZE / 4] =
  79   {
  80     0x3d800000, /* lis     r12,0                 */
  81     0x818c0000, /* lwz     r12,0(r12)            */
  82     0x7d8903a6, /* mtctr   r12                   */
  83     0x4e800420, /* bctr                          */
  84     0x39600000, /* li      r11,0                 */
  85     0x48000000, /* b       14 <.PLT0resolve+0x4> */
  86     0x60000000, /* nop                           */
  87     0x60000000, /* nop                           */
  88   };
  89 static const bfd_vma ppc_elf_vxworks_pic_plt_entry
  90     [VXWORKS_PLT_ENTRY_SIZE / 4] =
  91   {
  92     0x3d9e0000, /* addis r12,r30,0 */
  93     0x818c0000, /* lwz   r12,0(r12) */
  94     0x7d8903a6, /* mtctr r12 */
  95     0x4e800420, /* bctr */
  96     0x39600000, /* li    r11,0 */
  97     0x48000000, /* b     14 <.PLT0resolve+0x4> 14: R_PPC_REL24 .PLTresolve */
  98     0x60000000, /* nop */
  99     0x60000000, /* nop */
 100   };
 101
 102 /* The initial VxWorks PLT entry.  */
 103 #define VXWORKS_PLT_INITIAL_ENTRY_SIZE 32
 104 static const bfd_vma ppc_elf_vxworks_plt0_entry
 105     [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] =
 106   {
 107     0x3d800000, /* lis     r12,0        */
 108     0x398c0000, /* addi    r12,r12,0    */
 109     0x800c0008, /* lwz     r0,8(r12)    */
 110     0x7c0903a6, /* mtctr   r0           */
 111     0x818c0004, /* lwz     r12,4(r12)   */
 112     0x4e800420, /* bctr                 */
 113     0x60000000, /* nop                  */
 114     0x60000000, /* nop                  */
 115   };
 116 static const bfd_vma ppc_elf_vxworks_pic_plt0_entry
 117     [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] =
 118   {
 119     0x819e0008, /* lwz   r12,8(r30) */
 120     0x7d8903a6, /* mtctr r12        */
 121     0x819e0004, /* lwz   r12,4(r30) */
 122     0x4e800420, /* bctr             */
 123     0x60000000, /* nop              */
 124     0x60000000, /* nop              */
 125     0x60000000, /* nop              */
 126     0x60000000, /* nop              */
 127   };
 128
 129 /* For executables, we have some additional relocations in
 130    .rela.plt.unloaded, for the kernel loader.  */
 131
 132 /* The number of non-JMP_SLOT relocations per PLT0 slot. */
 133 #define VXWORKS_PLT_NON_JMP_SLOT_RELOCS 3
 134 /* The number of relocations in the PLTResolve slot. */
 135 #define VXWORKS_PLTRESOLVE_RELOCS 2
 136 /* The number of relocations in the PLTResolve slot when when creating
 137    a shared library. */
 138 #define VXWORKS_PLTRESOLVE_RELOCS_SHLIB 0
 139
 140 /* Some instructions.  */
 141 #define ADDIS_11_11     0x3d6b0000
 142 #define ADDIS_11_30     0x3d7e0000
 143 #define ADDIS_12_12     0x3d8c0000
 144 #define ADDI_11_11      0x396b0000
 145 #define ADD_0_11_11     0x7c0b5a14
 146 #define ADD_3_12_2      0x7c6c1214
 147 #define ADD_11_0_11     0x7d605a14
 148 #define B               0x48000000
 149 #define BA              0x48000002
 150 #define BCL_20_31       0x429f0005
 151 #define BCTR            0x4e800420
 152 #define BEQLR           0x4d820020
 153 #define CMPWI_11_0      0x2c0b0000
 154 #define LIS_11          0x3d600000
 155 #define LIS_12          0x3d800000
 156 #define LWZU_0_12       0x840c0000
 157 #define LWZ_0_12        0x800c0000
 158 #define LWZ_11_3        0x81630000
 159 #define LWZ_11_11       0x816b0000
 160 #define LWZ_11_30       0x817e0000
 161 #define LWZ_12_3        0x81830000
 162 #define LWZ_12_12       0x818c0000
 163 #define MR_0_3          0x7c601b78
 164 #define MR_3_0          0x7c030378
 165 #define MFLR_0          0x7c0802a6
 166 #define MFLR_12         0x7d8802a6
 167 #define MTCTR_0         0x7c0903a6
 168 #define MTCTR_11        0x7d6903a6
 169 #define MTLR_0          0x7c0803a6
 170 #define NOP             0x60000000
 171 #define SUB_11_11_12    0x7d6c5850
 172
 173 /* Offset of tp and dtp pointers from start of TLS block.  */
 174 #define TP_OFFSET       0x7000
 175 #define DTP_OFFSET      0x8000
 176
 177 /* The value of a defined global symbol.  */
 178 #define SYM_VAL(SYM) \
 179   ((SYM)->root.u.def.section->output_section->vma       \
 180    + (SYM)->root.u.def.section->output_offset           \
 181    + (SYM)->root.u.def.value)
 182 \f
 183 static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
 184
 185 static reloc_howto_type ppc_elf_howto_raw[] = {
 186   /* This reloc does nothing.  */
 187   HOWTO (R_PPC_NONE,            /* type */
 188          0,                     /* rightshift */
 189          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 190          0,                     /* bitsize */
 191          FALSE,                 /* pc_relative */
 192          0,                     /* bitpos */
 193          complain_overflow_dont, /* complain_on_overflow */
 194          bfd_elf_generic_reloc, /* special_function */
 195          "R_PPC_NONE",          /* name */
 196          FALSE,                 /* partial_inplace */
 197          0,                     /* src_mask */
 198          0,                     /* dst_mask */
 199          FALSE),                /* pcrel_offset */
 200
 201   /* A standard 32 bit relocation.  */
 202   HOWTO (R_PPC_ADDR32,          /* type */
 203          0,                     /* rightshift */
 204          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 205          32,                    /* bitsize */
 206          FALSE,                 /* pc_relative */
 207          0,                     /* bitpos */
 208          complain_overflow_dont, /* complain_on_overflow */
 209          bfd_elf_generic_reloc, /* special_function */
 210          "R_PPC_ADDR32",        /* name */
 211          FALSE,                 /* partial_inplace */
 212          0,                     /* src_mask */
 213          0xffffffff,            /* dst_mask */
 214          FALSE),                /* pcrel_offset */
 215
 216   /* An absolute 26 bit branch; the lower two bits must be zero.
 217      FIXME: we don't check that, we just clear them.  */
 218   HOWTO (R_PPC_ADDR24,          /* type */
 219          0,                     /* rightshift */
 220          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 221          26,                    /* bitsize */
 222          FALSE,                 /* pc_relative */
 223          0,                     /* bitpos */
 224          complain_overflow_signed, /* complain_on_overflow */
 225          bfd_elf_generic_reloc, /* special_function */
 226          "R_PPC_ADDR24",        /* name */
 227          FALSE,                 /* partial_inplace */
 228          0,                     /* src_mask */
 229          0x3fffffc,             /* dst_mask */
 230          FALSE),                /* pcrel_offset */
 231
 232   /* A standard 16 bit relocation.  */
 233   HOWTO (R_PPC_ADDR16,          /* type */
 234          0,                     /* rightshift */
 235          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 236          16,                    /* bitsize */
 237          FALSE,                 /* pc_relative */
 238          0,                     /* bitpos */
 239          complain_overflow_bitfield, /* complain_on_overflow */
 240          bfd_elf_generic_reloc, /* special_function */
 241          "R_PPC_ADDR16",        /* name */
 242          FALSE,                 /* partial_inplace */
 243          0,                     /* src_mask */
 244          0xffff,                /* dst_mask */
 245          FALSE),                /* pcrel_offset */
 246
 247   /* A 16 bit relocation without overflow.  */
 248   HOWTO (R_PPC_ADDR16_LO,       /* type */
 249          0,                     /* rightshift */
 250          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 251          16,                    /* bitsize */
 252          FALSE,                 /* pc_relative */
 253          0,                     /* bitpos */
 254          complain_overflow_dont,/* complain_on_overflow */
 255          bfd_elf_generic_reloc, /* special_function */
 256          "R_PPC_ADDR16_LO",     /* name */
 257          FALSE,                 /* partial_inplace */
 258          0,                     /* src_mask */
 259          0xffff,                /* dst_mask */
 260          FALSE),                /* pcrel_offset */
 261
 262   /* The high order 16 bits of an address.  */
 263   HOWTO (R_PPC_ADDR16_HI,       /* type */
 264          16,                    /* rightshift */
 265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 266          16,                    /* bitsize */
 267          FALSE,                 /* pc_relative */
 268          0,                     /* bitpos */
 269          complain_overflow_dont, /* complain_on_overflow */
 270          bfd_elf_generic_reloc, /* special_function */
 271          "R_PPC_ADDR16_HI",     /* name */
 272          FALSE,                 /* partial_inplace */
 273          0,                     /* src_mask */
 274          0xffff,                /* dst_mask */
 275          FALSE),                /* pcrel_offset */
 276
 277   /* The high order 16 bits of an address, plus 1 if the contents of
 278      the low 16 bits, treated as a signed number, is negative.  */
 279   HOWTO (R_PPC_ADDR16_HA,       /* type */
 280          16,                    /* rightshift */
 281          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 282          16,                    /* bitsize */
 283          FALSE,                 /* pc_relative */
 284          0,                     /* bitpos */
 285          complain_overflow_dont, /* complain_on_overflow */
 286          ppc_elf_addr16_ha_reloc, /* special_function */
 287          "R_PPC_ADDR16_HA",     /* name */
 288          FALSE,                 /* partial_inplace */
 289          0,                     /* src_mask */
 290          0xffff,                /* dst_mask */
 291          FALSE),                /* pcrel_offset */
 292
 293   /* An absolute 16 bit branch; the lower two bits must be zero.
 294      FIXME: we don't check that, we just clear them.  */
 295   HOWTO (R_PPC_ADDR14,          /* type */
 296          0,                     /* rightshift */
 297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          16,                    /* bitsize */
 299          FALSE,                 /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_signed, /* complain_on_overflow */
 302          bfd_elf_generic_reloc, /* special_function */
 303          "R_PPC_ADDR14",        /* name */
 304          FALSE,                 /* partial_inplace */
 305          0,                     /* src_mask */
 306          0xfffc,                /* dst_mask */
 307          FALSE),                /* pcrel_offset */
 308
 309   /* An absolute 16 bit branch, for which bit 10 should be set to
 310      indicate that the branch is expected to be taken.  The lower two
 311      bits must be zero.  */
 312   HOWTO (R_PPC_ADDR14_BRTAKEN,  /* type */
 313          0,                     /* rightshift */
 314          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 315          16,                    /* bitsize */
 316          FALSE,                 /* pc_relative */
 317          0,                     /* bitpos */
 318          complain_overflow_signed, /* complain_on_overflow */
 319          bfd_elf_generic_reloc, /* special_function */
 320          "R_PPC_ADDR14_BRTAKEN",/* name */
 321          FALSE,                 /* partial_inplace */
 322          0,                     /* src_mask */
 323          0xfffc,                /* dst_mask */
 324          FALSE),                /* pcrel_offset */
 325
 326   /* An absolute 16 bit branch, for which bit 10 should be set to
 327      indicate that the branch is not expected to be taken.  The lower
 328      two bits must be zero.  */
 329   HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
 330          0,                     /* rightshift */
 331          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 332          16,                    /* bitsize */
 333          FALSE,                 /* pc_relative */
 334          0,                     /* bitpos */
 335          complain_overflow_signed, /* complain_on_overflow */
 336          bfd_elf_generic_reloc, /* special_function */
 337          "R_PPC_ADDR14_BRNTAKEN",/* name */
 338          FALSE,                 /* partial_inplace */
 339          0,                     /* src_mask */
 340          0xfffc,                /* dst_mask */
 341          FALSE),                /* pcrel_offset */
 342
 343   /* A relative 26 bit branch; the lower two bits must be zero.  */
 344   HOWTO (R_PPC_REL24,           /* type */
 345          0,                     /* rightshift */
 346          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 347          26,                    /* bitsize */
 348          TRUE,                  /* pc_relative */
 349          0,                     /* bitpos */
 350          complain_overflow_signed, /* complain_on_overflow */
 351          bfd_elf_generic_reloc, /* special_function */
 352          "R_PPC_REL24",         /* name */
 353          FALSE,                 /* partial_inplace */
 354          0,                     /* src_mask */
 355          0x3fffffc,             /* dst_mask */
 356          TRUE),                 /* pcrel_offset */
 357
 358   /* A relative 16 bit branch; the lower two bits must be zero.  */
 359   HOWTO (R_PPC_REL14,           /* type */
 360          0,                     /* rightshift */
 361          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 362          16,                    /* bitsize */
 363          TRUE,                  /* pc_relative */
 364          0,                     /* bitpos */
 365          complain_overflow_signed, /* complain_on_overflow */
 366          bfd_elf_generic_reloc, /* special_function */
 367          "R_PPC_REL14",         /* name */
 368          FALSE,                 /* partial_inplace */
 369          0,                     /* src_mask */
 370          0xfffc,                /* dst_mask */
 371          TRUE),                 /* pcrel_offset */
 372
 373   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 374      the branch is expected to be taken.  The lower two bits must be
 375      zero.  */
 376   HOWTO (R_PPC_REL14_BRTAKEN,   /* type */
 377          0,                     /* rightshift */
 378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 379          16,                    /* bitsize */
 380          TRUE,                  /* pc_relative */
 381          0,                     /* bitpos */
 382          complain_overflow_signed, /* complain_on_overflow */
 383          bfd_elf_generic_reloc, /* special_function */
 384          "R_PPC_REL14_BRTAKEN", /* name */
 385          FALSE,                 /* partial_inplace */
 386          0,                     /* src_mask */
 387          0xfffc,                /* dst_mask */
 388          TRUE),                 /* pcrel_offset */
 389
 390   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 391      the branch is not expected to be taken.  The lower two bits must
 392      be zero.  */
 393   HOWTO (R_PPC_REL14_BRNTAKEN,  /* type */
 394          0,                     /* rightshift */
 395          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 396          16,                    /* bitsize */
 397          TRUE,                  /* pc_relative */
 398          0,                     /* bitpos */
 399          complain_overflow_signed, /* complain_on_overflow */
 400          bfd_elf_generic_reloc, /* special_function */
 401          "R_PPC_REL14_BRNTAKEN",/* name */
 402          FALSE,                 /* partial_inplace */
 403          0,                     /* src_mask */
 404          0xfffc,                /* dst_mask */
 405          TRUE),                 /* pcrel_offset */
 406
 407   /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
 408      symbol.  */
 409   HOWTO (R_PPC_GOT16,           /* type */
 410          0,                     /* rightshift */
 411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 412          16,                    /* bitsize */
 413          FALSE,                 /* pc_relative */
 414          0,                     /* bitpos */
 415          complain_overflow_signed, /* complain_on_overflow */
 416          bfd_elf_generic_reloc, /* special_function */
 417          "R_PPC_GOT16",         /* name */
 418          FALSE,                 /* partial_inplace */
 419          0,                     /* src_mask */
 420          0xffff,                /* dst_mask */
 421          FALSE),                /* pcrel_offset */
 422
 423   /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
 424      the symbol.  */
 425   HOWTO (R_PPC_GOT16_LO,        /* type */
 426          0,                     /* rightshift */
 427          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 428          16,                    /* bitsize */
 429          FALSE,                 /* pc_relative */
 430          0,                     /* bitpos */
 431          complain_overflow_dont, /* complain_on_overflow */
 432          bfd_elf_generic_reloc, /* special_function */
 433          "R_PPC_GOT16_LO",      /* name */
 434          FALSE,                 /* partial_inplace */
 435          0,                     /* src_mask */
 436          0xffff,                /* dst_mask */
 437          FALSE),                /* pcrel_offset */
 438
 439   /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
 440      the symbol.  */
 441   HOWTO (R_PPC_GOT16_HI,        /* type */
 442          16,                    /* rightshift */
 443          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          FALSE,                 /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_dont, /* complain_on_overflow */
 448          bfd_elf_generic_reloc, /* special_function */
 449          "R_PPC_GOT16_HI",      /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0xffff,                /* dst_mask */
 453          FALSE),                 /* pcrel_offset */
 454
 455   /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
 456      the symbol.  */
 457   HOWTO (R_PPC_GOT16_HA,        /* type */
 458          16,                    /* rightshift */
 459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_dont, /* complain_on_overflow */
 464          ppc_elf_addr16_ha_reloc, /* special_function */
 465          "R_PPC_GOT16_HA",      /* name */
 466          FALSE,                 /* partial_inplace */
 467          0,                     /* src_mask */
 468          0xffff,                /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   /* Like R_PPC_REL24, but referring to the procedure linkage table
 472      entry for the symbol.  */
 473   HOWTO (R_PPC_PLTREL24,        /* type */
 474          0,                     /* rightshift */
 475          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 476          26,                    /* bitsize */
 477          TRUE,                  /* pc_relative */
 478          0,                     /* bitpos */
 479          complain_overflow_signed,  /* complain_on_overflow */
 480          bfd_elf_generic_reloc, /* special_function */
 481          "R_PPC_PLTREL24",      /* name */
 482          FALSE,                 /* partial_inplace */
 483          0,                     /* src_mask */
 484          0x3fffffc,             /* dst_mask */
 485          TRUE),                 /* pcrel_offset */
 486
 487   /* This is used only by the dynamic linker.  The symbol should exist
 488      both in the object being run and in some shared library.  The
 489      dynamic linker copies the data addressed by the symbol from the
 490      shared library into the object, because the object being
 491      run has to have the data at some particular address.  */
 492   HOWTO (R_PPC_COPY,            /* type */
 493          0,                     /* rightshift */
 494          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          32,                    /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_dont, /* complain_on_overflow */
 499          bfd_elf_generic_reloc,  /* special_function */
 500          "R_PPC_COPY",          /* name */
 501          FALSE,                 /* partial_inplace */
 502          0,                     /* src_mask */
 503          0,                     /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505
 506   /* Like R_PPC_ADDR32, but used when setting global offset table
 507      entries.  */
 508   HOWTO (R_PPC_GLOB_DAT,        /* type */
 509          0,                     /* rightshift */
 510          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 511          32,                    /* bitsize */
 512          FALSE,                 /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_dont, /* complain_on_overflow */
 515          bfd_elf_generic_reloc,  /* special_function */
 516          "R_PPC_GLOB_DAT",      /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0xffffffff,            /* dst_mask */
 520          FALSE),                /* pcrel_offset */
 521
 522   /* Marks a procedure linkage table entry for a symbol.  */
 523   HOWTO (R_PPC_JMP_SLOT,        /* type */
 524          0,                     /* rightshift */
 525          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          32,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_dont, /* complain_on_overflow */
 530          bfd_elf_generic_reloc,  /* special_function */
 531          "R_PPC_JMP_SLOT",      /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0,                     /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Used only by the dynamic linker.  When the object is run, this
 538      longword is set to the load address of the object, plus the
 539      addend.  */
 540   HOWTO (R_PPC_RELATIVE,        /* type */
 541          0,                     /* rightshift */
 542          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          32,                    /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_dont, /* complain_on_overflow */
 547          bfd_elf_generic_reloc,  /* special_function */
 548          "R_PPC_RELATIVE",      /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0xffffffff,            /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* Like R_PPC_REL24, but uses the value of the symbol within the
 555      object rather than the final value.  Normally used for
 556      _GLOBAL_OFFSET_TABLE_.  */
 557   HOWTO (R_PPC_LOCAL24PC,       /* type */
 558          0,                     /* rightshift */
 559          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 560          26,                    /* bitsize */
 561          TRUE,                  /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_signed, /* complain_on_overflow */
 564          bfd_elf_generic_reloc, /* special_function */
 565          "R_PPC_LOCAL24PC",     /* name */
 566          FALSE,                 /* partial_inplace */
 567          0,                     /* src_mask */
 568          0x3fffffc,             /* dst_mask */
 569          TRUE),                 /* pcrel_offset */
 570
 571   /* Like R_PPC_ADDR32, but may be unaligned.  */
 572   HOWTO (R_PPC_UADDR32,         /* type */
 573          0,                     /* rightshift */
 574          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 575          32,                    /* bitsize */
 576          FALSE,                 /* pc_relative */
 577          0,                     /* bitpos */
 578          complain_overflow_dont, /* complain_on_overflow */
 579          bfd_elf_generic_reloc, /* special_function */
 580          "R_PPC_UADDR32",       /* name */
 581          FALSE,                 /* partial_inplace */
 582          0,                     /* src_mask */
 583          0xffffffff,            /* dst_mask */
 584          FALSE),                /* pcrel_offset */
 585
 586   /* Like R_PPC_ADDR16, but may be unaligned.  */
 587   HOWTO (R_PPC_UADDR16,         /* type */
 588          0,                     /* rightshift */
 589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 590          16,                    /* bitsize */
 591          FALSE,                 /* pc_relative */
 592          0,                     /* bitpos */
 593          complain_overflow_bitfield, /* complain_on_overflow */
 594          bfd_elf_generic_reloc, /* special_function */
 595          "R_PPC_UADDR16",       /* name */
 596          FALSE,                 /* partial_inplace */
 597          0,                     /* src_mask */
 598          0xffff,                /* dst_mask */
 599          FALSE),                /* pcrel_offset */
 600
 601   /* 32-bit PC relative */
 602   HOWTO (R_PPC_REL32,           /* type */
 603          0,                     /* rightshift */
 604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 605          32,                    /* bitsize */
 606          TRUE,                  /* pc_relative */
 607          0,                     /* bitpos */
 608          complain_overflow_dont, /* complain_on_overflow */
 609          bfd_elf_generic_reloc, /* special_function */
 610          "R_PPC_REL32",         /* name */
 611          FALSE,                 /* partial_inplace */
 612          0,                     /* src_mask */
 613          0xffffffff,            /* dst_mask */
 614          TRUE),                 /* pcrel_offset */
 615
 616   /* 32-bit relocation to the symbol's procedure linkage table.
 617      FIXME: not supported.  */
 618   HOWTO (R_PPC_PLT32,           /* type */
 619          0,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          32,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_dont, /* complain_on_overflow */
 625          bfd_elf_generic_reloc, /* special_function */
 626          "R_PPC_PLT32",         /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0,                     /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 633      FIXME: not supported.  */
 634   HOWTO (R_PPC_PLTREL32,        /* type */
 635          0,                     /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          32,                    /* bitsize */
 638          TRUE,                  /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_dont, /* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_PPC_PLTREL32",      /* name */
 643          FALSE,                 /* partial_inplace */
 644          0,                     /* src_mask */
 645          0,                     /* dst_mask */
 646          TRUE),                 /* pcrel_offset */
 647
 648   /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
 649      the symbol.  */
 650   HOWTO (R_PPC_PLT16_LO,        /* type */
 651          0,                     /* rightshift */
 652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          16,                    /* bitsize */
 654          FALSE,                 /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_dont, /* complain_on_overflow */
 657          bfd_elf_generic_reloc, /* special_function */
 658          "R_PPC_PLT16_LO",      /* name */
 659          FALSE,                 /* partial_inplace */
 660          0,                     /* src_mask */
 661          0xffff,                /* dst_mask */
 662          FALSE),                /* pcrel_offset */
 663
 664   /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
 665      the symbol.  */
 666   HOWTO (R_PPC_PLT16_HI,        /* type */
 667          16,                    /* rightshift */
 668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 669          16,                    /* bitsize */
 670          FALSE,                 /* pc_relative */
 671          0,                     /* bitpos */
 672          complain_overflow_dont, /* complain_on_overflow */
 673          bfd_elf_generic_reloc, /* special_function */
 674          "R_PPC_PLT16_HI",      /* name */
 675          FALSE,                 /* partial_inplace */
 676          0,                     /* src_mask */
 677          0xffff,                /* dst_mask */
 678          FALSE),                 /* pcrel_offset */
 679
 680   /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
 681      the symbol.  */
 682   HOWTO (R_PPC_PLT16_HA,        /* type */
 683          16,                    /* rightshift */
 684          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 685          16,                    /* bitsize */
 686          FALSE,                 /* pc_relative */
 687          0,                     /* bitpos */
 688          complain_overflow_dont, /* complain_on_overflow */
 689          ppc_elf_addr16_ha_reloc, /* special_function */
 690          "R_PPC_PLT16_HA",      /* name */
 691          FALSE,                 /* partial_inplace */
 692          0,                     /* src_mask */
 693          0xffff,                /* dst_mask */
 694          FALSE),                /* pcrel_offset */
 695
 696   /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
 697      small data items.  */
 698   HOWTO (R_PPC_SDAREL16,        /* type */
 699          0,                     /* rightshift */
 700          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 701          16,                    /* bitsize */
 702          FALSE,                 /* pc_relative */
 703          0,                     /* bitpos */
 704          complain_overflow_signed, /* complain_on_overflow */
 705          bfd_elf_generic_reloc, /* special_function */
 706          "R_PPC_SDAREL16",      /* name */
 707          FALSE,                 /* partial_inplace */
 708          0,                     /* src_mask */
 709          0xffff,                /* dst_mask */
 710          FALSE),                /* pcrel_offset */
 711
 712   /* 16-bit section relative relocation.  */
 713   HOWTO (R_PPC_SECTOFF,         /* type */
 714          0,                     /* rightshift */
 715          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 716          16,                    /* bitsize */
 717          FALSE,                 /* pc_relative */
 718          0,                     /* bitpos */
 719          complain_overflow_signed, /* complain_on_overflow */
 720          bfd_elf_generic_reloc, /* special_function */
 721          "R_PPC_SECTOFF",       /* name */
 722          FALSE,                 /* partial_inplace */
 723          0,                     /* src_mask */
 724          0xffff,                /* dst_mask */
 725          FALSE),                /* pcrel_offset */
 726
 727   /* 16-bit lower half section relative relocation.  */
 728   HOWTO (R_PPC_SECTOFF_LO,        /* type */
 729          0,                     /* rightshift */
 730          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 731          16,                    /* bitsize */
 732          FALSE,                 /* pc_relative */
 733          0,                     /* bitpos */
 734          complain_overflow_dont, /* complain_on_overflow */
 735          bfd_elf_generic_reloc, /* special_function */
 736          "R_PPC_SECTOFF_LO",    /* name */
 737          FALSE,                 /* partial_inplace */
 738          0,                     /* src_mask */
 739          0xffff,                /* dst_mask */
 740          FALSE),                /* pcrel_offset */
 741
 742   /* 16-bit upper half section relative relocation.  */
 743   HOWTO (R_PPC_SECTOFF_HI,      /* type */
 744          16,                    /* rightshift */
 745          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 746          16,                    /* bitsize */
 747          FALSE,                 /* pc_relative */
 748          0,                     /* bitpos */
 749          complain_overflow_dont, /* complain_on_overflow */
 750          bfd_elf_generic_reloc, /* special_function */
 751          "R_PPC_SECTOFF_HI",    /* name */
 752          FALSE,                 /* partial_inplace */
 753          0,                     /* src_mask */
 754          0xffff,                /* dst_mask */
 755          FALSE),                 /* pcrel_offset */
 756
 757   /* 16-bit upper half adjusted section relative relocation.  */
 758   HOWTO (R_PPC_SECTOFF_HA,      /* type */
 759          16,                    /* rightshift */
 760          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 761          16,                    /* bitsize */
 762          FALSE,                 /* pc_relative */
 763          0,                     /* bitpos */
 764          complain_overflow_dont, /* complain_on_overflow */
 765          ppc_elf_addr16_ha_reloc, /* special_function */
 766          "R_PPC_SECTOFF_HA",    /* name */
 767          FALSE,                 /* partial_inplace */
 768          0,                     /* src_mask */
 769          0xffff,                /* dst_mask */
 770          FALSE),                /* pcrel_offset */
 771
 772   /* Marker relocs for TLS.  */
 773   HOWTO (R_PPC_TLS,
 774          0,                     /* rightshift */
 775          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 776          32,                    /* bitsize */
 777          FALSE,                 /* pc_relative */
 778          0,                     /* bitpos */
 779          complain_overflow_dont, /* complain_on_overflow */
 780          bfd_elf_generic_reloc, /* special_function */
 781          "R_PPC_TLS",           /* name */
 782          FALSE,                 /* partial_inplace */
 783          0,                     /* src_mask */
 784          0,                     /* dst_mask */
 785          FALSE),                /* pcrel_offset */
 786
 787   HOWTO (R_PPC_TLSGD,
 788          0,                     /* rightshift */
 789          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 790          32,                    /* bitsize */
 791          FALSE,                 /* pc_relative */
 792          0,                     /* bitpos */
 793          complain_overflow_dont, /* complain_on_overflow */
 794          bfd_elf_generic_reloc, /* special_function */
 795          "R_PPC_TLSGD",         /* name */
 796          FALSE,                 /* partial_inplace */
 797          0,                     /* src_mask */
 798          0,                     /* dst_mask */
 799          FALSE),                /* pcrel_offset */
 800
 801   HOWTO (R_PPC_TLSLD,
 802          0,                     /* rightshift */
 803          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 804          32,                    /* bitsize */
 805          FALSE,                 /* pc_relative */
 806          0,                     /* bitpos */
 807          complain_overflow_dont, /* complain_on_overflow */
 808          bfd_elf_generic_reloc, /* special_function */
 809          "R_PPC_TLSLD",         /* name */
 810          FALSE,                 /* partial_inplace */
 811          0,                     /* src_mask */
 812          0,                     /* dst_mask */
 813          FALSE),                /* pcrel_offset */
 814
 815   /* Computes the load module index of the load module that contains the
 816      definition of its TLS sym.  */
 817   HOWTO (R_PPC_DTPMOD32,
 818          0,                     /* rightshift */
 819          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 820          32,                    /* bitsize */
 821          FALSE,                 /* pc_relative */
 822          0,                     /* bitpos */
 823          complain_overflow_dont, /* complain_on_overflow */
 824          ppc_elf_unhandled_reloc, /* special_function */
 825          "R_PPC_DTPMOD32",      /* name */
 826          FALSE,                 /* partial_inplace */
 827          0,                     /* src_mask */
 828          0xffffffff,            /* dst_mask */
 829          FALSE),                /* pcrel_offset */
 830
 831   /* Computes a dtv-relative displacement, the difference between the value
 832      of sym+add and the base address of the thread-local storage block that
 833      contains the definition of sym, minus 0x8000.  */
 834   HOWTO (R_PPC_DTPREL32,
 835          0,                     /* rightshift */
 836          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 837          32,                    /* bitsize */
 838          FALSE,                 /* pc_relative */
 839          0,                     /* bitpos */
 840          complain_overflow_dont, /* complain_on_overflow */
 841          ppc_elf_unhandled_reloc, /* special_function */
 842          "R_PPC_DTPREL32",      /* name */
 843          FALSE,                 /* partial_inplace */
 844          0,                     /* src_mask */
 845          0xffffffff,            /* dst_mask */
 846          FALSE),                /* pcrel_offset */
 847
 848   /* A 16 bit dtprel reloc.  */
 849   HOWTO (R_PPC_DTPREL16,
 850          0,                     /* rightshift */
 851          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 852          16,                    /* bitsize */
 853          FALSE,                 /* pc_relative */
 854          0,                     /* bitpos */
 855          complain_overflow_signed, /* complain_on_overflow */
 856          ppc_elf_unhandled_reloc, /* special_function */
 857          "R_PPC_DTPREL16",      /* name */
 858          FALSE,                 /* partial_inplace */
 859          0,                     /* src_mask */
 860          0xffff,                /* dst_mask */
 861          FALSE),                /* pcrel_offset */
 862
 863   /* Like DTPREL16, but no overflow.  */
 864   HOWTO (R_PPC_DTPREL16_LO,
 865          0,                     /* rightshift */
 866          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 867          16,                    /* bitsize */
 868          FALSE,                 /* pc_relative */
 869          0,                     /* bitpos */
 870          complain_overflow_dont, /* complain_on_overflow */
 871          ppc_elf_unhandled_reloc, /* special_function */
 872          "R_PPC_DTPREL16_LO",   /* name */
 873          FALSE,                 /* partial_inplace */
 874          0,                     /* src_mask */
 875          0xffff,                /* dst_mask */
 876          FALSE),                /* pcrel_offset */
 877
 878   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
 879   HOWTO (R_PPC_DTPREL16_HI,
 880          16,                    /* rightshift */
 881          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 882          16,                    /* bitsize */
 883          FALSE,                 /* pc_relative */
 884          0,                     /* bitpos */
 885          complain_overflow_dont, /* complain_on_overflow */
 886          ppc_elf_unhandled_reloc, /* special_function */
 887          "R_PPC_DTPREL16_HI",   /* name */
 888          FALSE,                 /* partial_inplace */
 889          0,                     /* src_mask */
 890          0xffff,                /* dst_mask */
 891          FALSE),                /* pcrel_offset */
 892
 893   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
 894   HOWTO (R_PPC_DTPREL16_HA,
 895          16,                    /* rightshift */
 896          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 897          16,                    /* bitsize */
 898          FALSE,                 /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          ppc_elf_unhandled_reloc, /* special_function */
 902          "R_PPC_DTPREL16_HA",   /* name */
 903          FALSE,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          0xffff,                /* dst_mask */
 906          FALSE),                /* pcrel_offset */
 907
 908   /* Computes a tp-relative displacement, the difference between the value of
 909      sym+add and the value of the thread pointer (r13).  */
 910   HOWTO (R_PPC_TPREL32,
 911          0,                     /* rightshift */
 912          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 913          32,                    /* bitsize */
 914          FALSE,                 /* pc_relative */
 915          0,                     /* bitpos */
 916          complain_overflow_dont, /* complain_on_overflow */
 917          ppc_elf_unhandled_reloc, /* special_function */
 918          "R_PPC_TPREL32",       /* name */
 919          FALSE,                 /* partial_inplace */
 920          0,                     /* src_mask */
 921          0xffffffff,            /* dst_mask */
 922          FALSE),                /* pcrel_offset */
 923
 924   /* A 16 bit tprel reloc.  */
 925   HOWTO (R_PPC_TPREL16,
 926          0,                     /* rightshift */
 927          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 928          16,                    /* bitsize */
 929          FALSE,                 /* pc_relative */
 930          0,                     /* bitpos */
 931          complain_overflow_signed, /* complain_on_overflow */
 932          ppc_elf_unhandled_reloc, /* special_function */
 933          "R_PPC_TPREL16",       /* name */
 934          FALSE,                 /* partial_inplace */
 935          0,                     /* src_mask */
 936          0xffff,                /* dst_mask */
 937          FALSE),                /* pcrel_offset */
 938
 939   /* Like TPREL16, but no overflow.  */
 940   HOWTO (R_PPC_TPREL16_LO,
 941          0,                     /* rightshift */
 942          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 943          16,                    /* bitsize */
 944          FALSE,                 /* pc_relative */
 945          0,                     /* bitpos */
 946          complain_overflow_dont, /* complain_on_overflow */
 947          ppc_elf_unhandled_reloc, /* special_function */
 948          "R_PPC_TPREL16_LO",    /* name */
 949          FALSE,                 /* partial_inplace */
 950          0,                     /* src_mask */
 951          0xffff,                /* dst_mask */
 952          FALSE),                /* pcrel_offset */
 953
 954   /* Like TPREL16_LO, but next higher group of 16 bits.  */
 955   HOWTO (R_PPC_TPREL16_HI,
 956          16,                    /* rightshift */
 957          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 958          16,                    /* bitsize */
 959          FALSE,                 /* pc_relative */
 960          0,                     /* bitpos */
 961          complain_overflow_dont, /* complain_on_overflow */
 962          ppc_elf_unhandled_reloc, /* special_function */
 963          "R_PPC_TPREL16_HI",    /* name */
 964          FALSE,                 /* partial_inplace */
 965          0,                     /* src_mask */
 966          0xffff,                /* dst_mask */
 967          FALSE),                /* pcrel_offset */
 968
 969   /* Like TPREL16_HI, but adjust for low 16 bits.  */
 970   HOWTO (R_PPC_TPREL16_HA,
 971          16,                    /* rightshift */
 972          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 973          16,                    /* bitsize */
 974          FALSE,                 /* pc_relative */
 975          0,                     /* bitpos */
 976          complain_overflow_dont, /* complain_on_overflow */
 977          ppc_elf_unhandled_reloc, /* special_function */
 978          "R_PPC_TPREL16_HA",    /* name */
 979          FALSE,                 /* partial_inplace */
 980          0,                     /* src_mask */
 981          0xffff,                /* dst_mask */
 982          FALSE),                /* pcrel_offset */
 983
 984   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
 985      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
 986      to the first entry.  */
 987   HOWTO (R_PPC_GOT_TLSGD16,
 988          0,                     /* rightshift */
 989          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 990          16,                    /* bitsize */
 991          FALSE,                 /* pc_relative */
 992          0,                     /* bitpos */
 993          complain_overflow_signed, /* complain_on_overflow */
 994          ppc_elf_unhandled_reloc, /* special_function */
 995          "R_PPC_GOT_TLSGD16",   /* name */
 996          FALSE,                 /* partial_inplace */
 997          0,                     /* src_mask */
 998          0xffff,                /* dst_mask */
 999          FALSE),                /* pcrel_offset */
1000
1001   /* Like GOT_TLSGD16, but no overflow.  */
1002   HOWTO (R_PPC_GOT_TLSGD16_LO,
1003          0,                     /* rightshift */
1004          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1005          16,                    /* bitsize */
1006          FALSE,                 /* pc_relative */
1007          0,                     /* bitpos */
1008          complain_overflow_dont, /* complain_on_overflow */
1009          ppc_elf_unhandled_reloc, /* special_function */
1010          "R_PPC_GOT_TLSGD16_LO", /* name */
1011          FALSE,                 /* partial_inplace */
1012          0,                     /* src_mask */
1013          0xffff,                /* dst_mask */
1014          FALSE),                /* pcrel_offset */
1015
1016   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1017   HOWTO (R_PPC_GOT_TLSGD16_HI,
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_dont, /* complain_on_overflow */
1024          ppc_elf_unhandled_reloc, /* special_function */
1025          "R_PPC_GOT_TLSGD16_HI", /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1032   HOWTO (R_PPC_GOT_TLSGD16_HA,
1033          16,                    /* rightshift */
1034          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1035          16,                    /* bitsize */
1036          FALSE,                 /* pc_relative */
1037          0,                     /* bitpos */
1038          complain_overflow_dont, /* complain_on_overflow */
1039          ppc_elf_unhandled_reloc, /* special_function */
1040          "R_PPC_GOT_TLSGD16_HA", /* name */
1041          FALSE,                 /* partial_inplace */
1042          0,                     /* src_mask */
1043          0xffff,                /* dst_mask */
1044          FALSE),                /* pcrel_offset */
1045
1046   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1047      with values (sym+add)@dtpmod and zero, and computes the offset to the
1048      first entry.  */
1049   HOWTO (R_PPC_GOT_TLSLD16,
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_signed, /* complain_on_overflow */
1056          ppc_elf_unhandled_reloc, /* special_function */
1057          "R_PPC_GOT_TLSLD16",   /* name */
1058          FALSE,                 /* partial_inplace */
1059          0,                     /* src_mask */
1060          0xffff,                /* dst_mask */
1061          FALSE),                /* pcrel_offset */
1062
1063   /* Like GOT_TLSLD16, but no overflow.  */
1064   HOWTO (R_PPC_GOT_TLSLD16_LO,
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          ppc_elf_unhandled_reloc, /* special_function */
1072          "R_PPC_GOT_TLSLD16_LO", /* name */
1073          FALSE,                 /* partial_inplace */
1074          0,                     /* src_mask */
1075          0xffff,                /* dst_mask */
1076          FALSE),                /* pcrel_offset */
1077
1078   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1079   HOWTO (R_PPC_GOT_TLSLD16_HI,
1080          16,                    /* rightshift */
1081          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1082          16,                    /* bitsize */
1083          FALSE,                 /* pc_relative */
1084          0,                     /* bitpos */
1085          complain_overflow_dont, /* complain_on_overflow */
1086          ppc_elf_unhandled_reloc, /* special_function */
1087          "R_PPC_GOT_TLSLD16_HI", /* name */
1088          FALSE,                 /* partial_inplace */
1089          0,                     /* src_mask */
1090          0xffff,                /* dst_mask */
1091          FALSE),                /* pcrel_offset */
1092
1093   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1094   HOWTO (R_PPC_GOT_TLSLD16_HA,
1095          16,                    /* 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          ppc_elf_unhandled_reloc, /* special_function */
1102          "R_PPC_GOT_TLSLD16_HA", /* name */
1103          FALSE,                 /* partial_inplace */
1104          0,                     /* src_mask */
1105          0xffff,                /* dst_mask */
1106          FALSE),                /* pcrel_offset */
1107
1108   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1109      the offset to the entry.  */
1110   HOWTO (R_PPC_GOT_DTPREL16,
1111          0,                     /* rightshift */
1112          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1113          16,                    /* bitsize */
1114          FALSE,                 /* pc_relative */
1115          0,                     /* bitpos */
1116          complain_overflow_signed, /* complain_on_overflow */
1117          ppc_elf_unhandled_reloc, /* special_function */
1118          "R_PPC_GOT_DTPREL16",  /* name */
1119          FALSE,                 /* partial_inplace */
1120          0,                     /* src_mask */
1121          0xffff,                /* dst_mask */
1122          FALSE),                /* pcrel_offset */
1123
1124   /* Like GOT_DTPREL16, but no overflow.  */
1125   HOWTO (R_PPC_GOT_DTPREL16_LO,
1126          0,                     /* rightshift */
1127          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1128          16,                    /* bitsize */
1129          FALSE,                 /* pc_relative */
1130          0,                     /* bitpos */
1131          complain_overflow_dont, /* complain_on_overflow */
1132          ppc_elf_unhandled_reloc, /* special_function */
1133          "R_PPC_GOT_DTPREL16_LO", /* name */
1134          FALSE,                 /* partial_inplace */
1135          0,                     /* src_mask */
1136          0xffff,                /* dst_mask */
1137          FALSE),                /* pcrel_offset */
1138
1139   /* Like GOT_DTPREL16_LO, but next higher group of 16 bits.  */
1140   HOWTO (R_PPC_GOT_DTPREL16_HI,
1141          16,                    /* rightshift */
1142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1143          16,                    /* bitsize */
1144          FALSE,                 /* pc_relative */
1145          0,                     /* bitpos */
1146          complain_overflow_dont, /* complain_on_overflow */
1147          ppc_elf_unhandled_reloc, /* special_function */
1148          "R_PPC_GOT_DTPREL16_HI", /* name */
1149          FALSE,                 /* partial_inplace */
1150          0,                     /* src_mask */
1151          0xffff,                /* dst_mask */
1152          FALSE),                /* pcrel_offset */
1153
1154   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1155   HOWTO (R_PPC_GOT_DTPREL16_HA,
1156          16,                    /* rightshift */
1157          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1158          16,                    /* bitsize */
1159          FALSE,                 /* pc_relative */
1160          0,                     /* bitpos */
1161          complain_overflow_dont, /* complain_on_overflow */
1162          ppc_elf_unhandled_reloc, /* special_function */
1163          "R_PPC_GOT_DTPREL16_HA", /* name */
1164          FALSE,                 /* partial_inplace */
1165          0,                     /* src_mask */
1166          0xffff,                /* dst_mask */
1167          FALSE),                /* pcrel_offset */
1168
1169   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1170      offset to the entry.  */
1171   HOWTO (R_PPC_GOT_TPREL16,
1172          0,                     /* rightshift */
1173          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1174          16,                    /* bitsize */
1175          FALSE,                 /* pc_relative */
1176          0,                     /* bitpos */
1177          complain_overflow_signed, /* complain_on_overflow */
1178          ppc_elf_unhandled_reloc, /* special_function */
1179          "R_PPC_GOT_TPREL16",   /* name */
1180          FALSE,                 /* partial_inplace */
1181          0,                     /* src_mask */
1182          0xffff,                /* dst_mask */
1183          FALSE),                /* pcrel_offset */
1184
1185   /* Like GOT_TPREL16, but no overflow.  */
1186   HOWTO (R_PPC_GOT_TPREL16_LO,
1187          0,                     /* rightshift */
1188          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1189          16,                    /* bitsize */
1190          FALSE,                 /* pc_relative */
1191          0,                     /* bitpos */
1192          complain_overflow_dont, /* complain_on_overflow */
1193          ppc_elf_unhandled_reloc, /* special_function */
1194          "R_PPC_GOT_TPREL16_LO", /* name */
1195          FALSE,                 /* partial_inplace */
1196          0,                     /* src_mask */
1197          0xffff,                /* dst_mask */
1198          FALSE),                /* pcrel_offset */
1199
1200   /* Like GOT_TPREL16_LO, but next higher group of 16 bits.  */
1201   HOWTO (R_PPC_GOT_TPREL16_HI,
1202          16,                    /* 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          ppc_elf_unhandled_reloc, /* special_function */
1209          "R_PPC_GOT_TPREL16_HI", /* name */
1210          FALSE,                 /* partial_inplace */
1211          0,                     /* src_mask */
1212          0xffff,                /* dst_mask */
1213          FALSE),                /* pcrel_offset */
1214
1215   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1216   HOWTO (R_PPC_GOT_TPREL16_HA,
1217          16,                    /* rightshift */
1218          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1219          16,                    /* bitsize */
1220          FALSE,                 /* pc_relative */
1221          0,                     /* bitpos */
1222          complain_overflow_dont, /* complain_on_overflow */
1223          ppc_elf_unhandled_reloc, /* special_function */
1224          "R_PPC_GOT_TPREL16_HA", /* name */
1225          FALSE,                 /* partial_inplace */
1226          0,                     /* src_mask */
1227          0xffff,                /* dst_mask */
1228          FALSE),                /* pcrel_offset */
1229
1230   /* The remaining relocs are from the Embedded ELF ABI, and are not
1231      in the SVR4 ELF ABI.  */
1232
1233   /* 32 bit value resulting from the addend minus the symbol.  */
1234   HOWTO (R_PPC_EMB_NADDR32,     /* type */
1235          0,                     /* rightshift */
1236          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1237          32,                    /* bitsize */
1238          FALSE,                 /* pc_relative */
1239          0,                     /* bitpos */
1240          complain_overflow_dont, /* complain_on_overflow */
1241          bfd_elf_generic_reloc, /* special_function */
1242          "R_PPC_EMB_NADDR32",   /* name */
1243          FALSE,                 /* partial_inplace */
1244          0,                     /* src_mask */
1245          0xffffffff,            /* dst_mask */
1246          FALSE),                /* pcrel_offset */
1247
1248   /* 16 bit value resulting from the addend minus the symbol.  */
1249   HOWTO (R_PPC_EMB_NADDR16,     /* type */
1250          0,                     /* rightshift */
1251          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1252          16,                    /* bitsize */
1253          FALSE,                 /* pc_relative */
1254          0,                     /* bitpos */
1255          complain_overflow_signed, /* complain_on_overflow */
1256          bfd_elf_generic_reloc, /* special_function */
1257          "R_PPC_EMB_NADDR16",   /* name */
1258          FALSE,                 /* partial_inplace */
1259          0,                     /* src_mask */
1260          0xffff,                /* dst_mask */
1261          FALSE),                /* pcrel_offset */
1262
1263   /* 16 bit value resulting from the addend minus the symbol.  */
1264   HOWTO (R_PPC_EMB_NADDR16_LO,  /* type */
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_dont,/* complain_on_overflow */
1271          bfd_elf_generic_reloc, /* special_function */
1272          "R_PPC_EMB_ADDR16_LO", /* name */
1273          FALSE,                 /* partial_inplace */
1274          0,                     /* src_mask */
1275          0xffff,                /* dst_mask */
1276          FALSE),                /* pcrel_offset */
1277
1278   /* The high order 16 bits of the addend minus the symbol.  */
1279   HOWTO (R_PPC_EMB_NADDR16_HI,  /* type */
1280          16,                    /* 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          bfd_elf_generic_reloc, /* special_function */
1287          "R_PPC_EMB_NADDR16_HI", /* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0xffff,                /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   /* The high order 16 bits of the result of the addend minus the address,
1294      plus 1 if the contents of the low 16 bits, treated as a signed number,
1295      is negative.  */
1296   HOWTO (R_PPC_EMB_NADDR16_HA,  /* type */
1297          16,                    /* rightshift */
1298          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1299          16,                    /* bitsize */
1300          FALSE,                 /* pc_relative */
1301          0,                     /* bitpos */
1302          complain_overflow_dont, /* complain_on_overflow */
1303          ppc_elf_addr16_ha_reloc, /* special_function */
1304          "R_PPC_EMB_NADDR16_HA", /* name */
1305          FALSE,                 /* partial_inplace */
1306          0,                     /* src_mask */
1307          0xffff,                /* dst_mask */
1308          FALSE),                /* pcrel_offset */
1309
1310   /* 16 bit value resulting from allocating a 4 byte word to hold an
1311      address in the .sdata section, and returning the offset from
1312      _SDA_BASE_ for that relocation.  */
1313   HOWTO (R_PPC_EMB_SDAI16,      /* type */
1314          0,                     /* rightshift */
1315          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1316          16,                    /* bitsize */
1317          FALSE,                 /* pc_relative */
1318          0,                     /* bitpos */
1319          complain_overflow_signed, /* complain_on_overflow */
1320          bfd_elf_generic_reloc, /* special_function */
1321          "R_PPC_EMB_SDAI16",    /* name */
1322          FALSE,                 /* partial_inplace */
1323          0,                     /* src_mask */
1324          0xffff,                /* dst_mask */
1325          FALSE),                /* pcrel_offset */
1326
1327   /* 16 bit value resulting from allocating a 4 byte word to hold an
1328      address in the .sdata2 section, and returning the offset from
1329      _SDA2_BASE_ for that relocation.  */
1330   HOWTO (R_PPC_EMB_SDA2I16,     /* type */
1331          0,                     /* rightshift */
1332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1333          16,                    /* bitsize */
1334          FALSE,                 /* pc_relative */
1335          0,                     /* bitpos */
1336          complain_overflow_signed, /* complain_on_overflow */
1337          bfd_elf_generic_reloc, /* special_function */
1338          "R_PPC_EMB_SDA2I16",   /* name */
1339          FALSE,                 /* partial_inplace */
1340          0,                     /* src_mask */
1341          0xffff,                /* dst_mask */
1342          FALSE),                /* pcrel_offset */
1343
1344   /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
1345      small data items.   */
1346   HOWTO (R_PPC_EMB_SDA2REL,     /* type */
1347          0,                     /* rightshift */
1348          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1349          16,                    /* bitsize */
1350          FALSE,                 /* pc_relative */
1351          0,                     /* bitpos */
1352          complain_overflow_signed, /* complain_on_overflow */
1353          bfd_elf_generic_reloc, /* special_function */
1354          "R_PPC_EMB_SDA2REL",   /* name */
1355          FALSE,                 /* partial_inplace */
1356          0,                     /* src_mask */
1357          0xffff,                /* dst_mask */
1358          FALSE),                /* pcrel_offset */
1359
1360   /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
1361      signed offset from the appropriate base, and filling in the register
1362      field with the appropriate register (0, 2, or 13).  */
1363   HOWTO (R_PPC_EMB_SDA21,       /* type */
1364          0,                     /* rightshift */
1365          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1366          16,                    /* bitsize */
1367          FALSE,                 /* pc_relative */
1368          0,                     /* bitpos */
1369          complain_overflow_signed, /* complain_on_overflow */
1370          bfd_elf_generic_reloc, /* special_function */
1371          "R_PPC_EMB_SDA21",     /* name */
1372          FALSE,                 /* partial_inplace */
1373          0,                     /* src_mask */
1374          0xffff,                /* dst_mask */
1375          FALSE),                /* pcrel_offset */
1376
1377   /* Relocation not handled: R_PPC_EMB_MRKREF */
1378   /* Relocation not handled: R_PPC_EMB_RELSEC16 */
1379   /* Relocation not handled: R_PPC_EMB_RELST_LO */
1380   /* Relocation not handled: R_PPC_EMB_RELST_HI */
1381   /* Relocation not handled: R_PPC_EMB_RELST_HA */
1382   /* Relocation not handled: R_PPC_EMB_BIT_FLD */
1383
1384   /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
1385      in the 16 bit signed offset from the appropriate base, and filling in the
1386      register field with the appropriate register (0, 2, or 13).  */
1387   HOWTO (R_PPC_EMB_RELSDA,      /* type */
1388          0,                     /* rightshift */
1389          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          16,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_signed, /* complain_on_overflow */
1394          bfd_elf_generic_reloc, /* special_function */
1395          "R_PPC_EMB_RELSDA",    /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          0xffff,                /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* A relative 8 bit branch.  */
1402   HOWTO (R_PPC_VLE_REL8,        /* type */
1403          1,                     /* rightshift */
1404          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1405          8,                     /* bitsize */
1406          TRUE,                  /* pc_relative */
1407          0,                     /* bitpos */
1408          complain_overflow_signed, /* complain_on_overflow */
1409          bfd_elf_generic_reloc, /* special_function */
1410          "R_PPC_VLE_REL8",      /* name */
1411          FALSE,                 /* partial_inplace */
1412          0,                     /* src_mask */
1413          0xff,                  /* dst_mask */
1414          TRUE),                 /* pcrel_offset */
1415
1416   /* A relative 15 bit branch.  */
1417   HOWTO (R_PPC_VLE_REL15,       /* type */
1418          1,                     /* rightshift */
1419          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1420          15,                    /* bitsize */
1421          TRUE,                  /* pc_relative */
1422          1,                     /* bitpos */
1423          complain_overflow_signed, /* complain_on_overflow */
1424          bfd_elf_generic_reloc, /* special_function */
1425          "R_PPC_VLE_REL15",     /* name */
1426          FALSE,                 /* partial_inplace */
1427          0,                     /* src_mask */
1428          0xfe,                  /* dst_mask */
1429          TRUE),                 /* pcrel_offset */
1430
1431   /* A relative 24 bit branch.  */
1432   HOWTO (R_PPC_VLE_REL24,       /* type */
1433          1,                     /* rightshift */
1434          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1435          24,                    /* bitsize */
1436          TRUE,                  /* pc_relative */
1437          1,                     /* bitpos */
1438          complain_overflow_signed, /* complain_on_overflow */
1439          bfd_elf_generic_reloc, /* special_function */
1440          "R_PPC_VLE_REL24",     /* name */
1441          FALSE,                 /* partial_inplace */
1442          0,                     /* src_mask */
1443          0x1fffffe,             /* dst_mask */
1444          TRUE),                 /* pcrel_offset */
1445
1446   /* The 16 LSBS in split16a format.  */
1447   HOWTO (R_PPC_VLE_LO16A,       /* type */
1448          0,                     /* rightshift */
1449          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1450          16,                    /* bitsize */
1451          FALSE,                 /* pc_relative */
1452          0,                     /* bitpos */
1453          complain_overflow_dont, /* complain_on_overflow */
1454          bfd_elf_generic_reloc,  /* special_function */
1455          "R_PPC_VLE_LO16A",     /* name */
1456          FALSE,                 /* partial_inplace */
1457          0,                     /* src_mask */
1458          0x1f007ff,             /* dst_mask */
1459          FALSE),                /* pcrel_offset */
1460
1461   /* The 16 LSBS in split16d format.  */
1462   HOWTO (R_PPC_VLE_LO16D,       /* type */
1463          0,                     /* rightshift */
1464          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1465          16,                    /* bitsize */
1466          FALSE,                 /* pc_relative */
1467          0,                     /* bitpos */
1468          complain_overflow_dont, /* complain_on_overflow */
1469          bfd_elf_generic_reloc,  /* special_function */
1470          "R_PPC_VLE_LO16D",             /* name */
1471          FALSE,                 /* partial_inplace */
1472          0,                     /* src_mask */
1473          0x1f07ff,              /* dst_mask */
1474          FALSE),                /* pcrel_offset */
1475
1476   /* Bits 16-31 split16a format.  */
1477   HOWTO (R_PPC_VLE_HI16A,       /* type */
1478          16,                    /* rightshift */
1479          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1480          16,                    /* bitsize */
1481          FALSE,                 /* pc_relative */
1482          0,                     /* bitpos */
1483          complain_overflow_dont, /* complain_on_overflow */
1484          bfd_elf_generic_reloc,  /* special_function */
1485          "R_PPC_VLE_HI16A",             /* name */
1486          FALSE,                 /* partial_inplace */
1487          0,                     /* src_mask */
1488          0x1f007ff,             /* dst_mask */
1489          FALSE),                /* pcrel_offset */
1490
1491   /* Bits 16-31 split16d format.  */
1492   HOWTO (R_PPC_VLE_HI16D,       /* type */
1493          16,                    /* rightshift */
1494          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1495          16,                    /* bitsize */
1496          FALSE,                 /* pc_relative */
1497          0,                     /* bitpos */
1498          complain_overflow_dont, /* complain_on_overflow */
1499          bfd_elf_generic_reloc,  /* special_function */
1500          "R_PPC_VLE_HI16D",             /* name */
1501          FALSE,                 /* partial_inplace */
1502          0,                     /* src_mask */
1503          0x1f07ff,              /* dst_mask */
1504          FALSE),                /* pcrel_offset */
1505
1506   /* Bits 16-31 (High Adjusted) in split16a format.  */
1507   HOWTO (R_PPC_VLE_HA16A,       /* type */
1508          16,                    /* rightshift */
1509          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          16,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_dont, /* complain_on_overflow */
1514          bfd_elf_generic_reloc,  /* special_function */
1515          "R_PPC_VLE_HA16A",             /* name */
1516          FALSE,                 /* partial_inplace */
1517          0,                     /* src_mask */
1518          0x1f007ff,             /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   /* Bits 16-31 (High Adjusted) in split16d format.  */
1522   HOWTO (R_PPC_VLE_HA16D,       /* type */
1523          16,                    /* rightshift */
1524          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_dont, /* complain_on_overflow */
1529          bfd_elf_generic_reloc,  /* special_function */
1530          "R_PPC_VLE_HA16D",             /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          0x1f07ff,              /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* This reloc is like R_PPC_EMB_SDA21 but only applies to e_add16i
1537      instructions.  If the register base is 0 then the linker changes
1538      the e_add16i to an e_li instruction.  */
1539   HOWTO (R_PPC_VLE_SDA21,       /* type */
1540          0,                     /* rightshift */
1541          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1542          16,                    /* bitsize */
1543          FALSE,                 /* pc_relative */
1544          0,                     /* bitpos */
1545          complain_overflow_signed, /* complain_on_overflow */
1546          bfd_elf_generic_reloc, /* special_function */
1547          "R_PPC_VLE_SDA21",             /* name */
1548          FALSE,                 /* partial_inplace */
1549          0,                     /* src_mask */
1550          0xffff,                /* dst_mask */
1551          FALSE),                /* pcrel_offset */
1552
1553   /* Like R_PPC_VLE_SDA21 but ignore overflow.  */
1554   HOWTO (R_PPC_VLE_SDA21_LO,    /* type */
1555          0,                     /* rightshift */
1556          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          16,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_dont, /* complain_on_overflow */
1561          bfd_elf_generic_reloc, /* special_function */
1562          "R_PPC_VLE_SDA21_LO",  /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0xffff,                /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   /* The 16 LSBS relative to _SDA_BASE_ in split16a format.  */
1569   HOWTO (R_PPC_VLE_SDAREL_LO16A,/* type */
1570          0,                     /* rightshift */
1571          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1572          16,                    /* bitsize */
1573          FALSE,                 /* pc_relative */
1574          0,                     /* bitpos */
1575          complain_overflow_dont,        /* complain_on_overflow */
1576          bfd_elf_generic_reloc,  /* special_function */
1577          "R_PPC_VLE_SDAREL_LO16A",      /* name */
1578          FALSE,                 /* partial_inplace */
1579          0,                     /* src_mask */
1580          0x1f007ff,             /* dst_mask */
1581          FALSE),                /* pcrel_offset */
1582
1583   /* The 16 LSBS relative to _SDA_BASE_ in split16d format.  */
1584   HOWTO (R_PPC_VLE_SDAREL_LO16D, /* type */
1585          0,                     /* rightshift */
1586          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1587          16,                    /* bitsize */
1588          FALSE,                 /* pc_relative */
1589          0,                     /* bitpos */
1590          complain_overflow_dont,        /* complain_on_overflow */
1591          bfd_elf_generic_reloc,  /* special_function */
1592          "R_PPC_VLE_SDAREL_LO16D",              /* name */
1593          FALSE,                 /* partial_inplace */
1594          0,                     /* src_mask */
1595          0x1f07ff,              /* dst_mask */
1596          FALSE),                /* pcrel_offset */
1597
1598   /* Bits 16-31 relative to _SDA_BASE_ in split16a format.  */
1599   HOWTO (R_PPC_VLE_SDAREL_HI16A,        /* type */
1600          16,                    /* rightshift */
1601          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1602          16,                    /* bitsize */
1603          FALSE,                 /* pc_relative */
1604          0,                     /* bitpos */
1605          complain_overflow_dont,        /* complain_on_overflow */
1606          bfd_elf_generic_reloc,  /* special_function */
1607          "R_PPC_VLE_SDAREL_HI16A",      /* name */
1608          FALSE,                 /* partial_inplace */
1609          0,                     /* src_mask */
1610          0x1f007ff,             /* dst_mask */
1611          FALSE),                /* pcrel_offset */
1612
1613   /* Bits 16-31 relative to _SDA_BASE_ in split16d format.  */
1614   HOWTO (R_PPC_VLE_SDAREL_HI16D,        /* type */
1615          16,                    /* rightshift */
1616          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1617          16,                    /* bitsize */
1618          FALSE,                 /* pc_relative */
1619          0,                     /* bitpos */
1620          complain_overflow_dont,        /* complain_on_overflow */
1621          bfd_elf_generic_reloc,  /* special_function */
1622          "R_PPC_VLE_SDAREL_HI16D",      /* name */
1623          FALSE,                 /* partial_inplace */
1624          0,                     /* src_mask */
1625          0x1f07ff,              /* dst_mask */
1626          FALSE),                /* pcrel_offset */
1627
1628   /* Bits 16-31 (HA) relative to _SDA_BASE split16a format.  */
1629   HOWTO (R_PPC_VLE_SDAREL_HA16A,        /* type */
1630          16,                    /* rightshift */
1631          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1632          16,                    /* bitsize */
1633          FALSE,                 /* pc_relative */
1634          0,                     /* bitpos */
1635          complain_overflow_dont,        /* complain_on_overflow */
1636          bfd_elf_generic_reloc,  /* special_function */
1637          "R_PPC_VLE_SDAREL_HA16A",      /* name */
1638          FALSE,                 /* partial_inplace */
1639          0,                     /* src_mask */
1640          0x1f007ff,             /* dst_mask */
1641          FALSE),                /* pcrel_offset */
1642
1643   /* Bits 16-31 (HA) relative to _SDA_BASE split16d format.  */
1644   HOWTO (R_PPC_VLE_SDAREL_HA16D,        /* type */
1645          16,                    /* rightshift */
1646          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1647          16,                    /* bitsize */
1648          FALSE,                 /* pc_relative */
1649          0,                     /* bitpos */
1650          complain_overflow_dont,        /* complain_on_overflow */
1651          bfd_elf_generic_reloc,  /* special_function */
1652          "R_PPC_VLE_SDAREL_HA16D",      /* name */
1653          FALSE,                 /* partial_inplace */
1654          0,                     /* src_mask */
1655          0x1f07ff,              /* dst_mask */
1656          FALSE),                /* pcrel_offset */
1657
1658   HOWTO (R_PPC_IRELATIVE,       /* type */
1659          0,                     /* rightshift */
1660          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1661          32,                    /* bitsize */
1662          FALSE,                 /* pc_relative */
1663          0,                     /* bitpos */
1664          complain_overflow_dont, /* complain_on_overflow */
1665          bfd_elf_generic_reloc,  /* special_function */
1666          "R_PPC_IRELATIVE",     /* name */
1667          FALSE,                 /* partial_inplace */
1668          0,                     /* src_mask */
1669          0xffffffff,            /* dst_mask */
1670          FALSE),                /* pcrel_offset */
1671
1672   /* A 16 bit relative relocation.  */
1673   HOWTO (R_PPC_REL16,           /* type */
1674          0,                     /* rightshift */
1675          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1676          16,                    /* bitsize */
1677          TRUE,                  /* pc_relative */
1678          0,                     /* bitpos */
1679          complain_overflow_signed, /* complain_on_overflow */
1680          bfd_elf_generic_reloc, /* special_function */
1681          "R_PPC_REL16",         /* name */
1682          FALSE,                 /* partial_inplace */
1683          0,                     /* src_mask */
1684          0xffff,                /* dst_mask */
1685          TRUE),                 /* pcrel_offset */
1686
1687   /* A 16 bit relative relocation without overflow.  */
1688   HOWTO (R_PPC_REL16_LO,        /* type */
1689          0,                     /* rightshift */
1690          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1691          16,                    /* bitsize */
1692          TRUE,                  /* pc_relative */
1693          0,                     /* bitpos */
1694          complain_overflow_dont,/* complain_on_overflow */
1695          bfd_elf_generic_reloc, /* special_function */
1696          "R_PPC_REL16_LO",      /* name */
1697          FALSE,                 /* partial_inplace */
1698          0,                     /* src_mask */
1699          0xffff,                /* dst_mask */
1700          TRUE),                 /* pcrel_offset */
1701
1702   /* The high order 16 bits of a relative address.  */
1703   HOWTO (R_PPC_REL16_HI,        /* type */
1704          16,                    /* rightshift */
1705          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1706          16,                    /* bitsize */
1707          TRUE,                  /* pc_relative */
1708          0,                     /* bitpos */
1709          complain_overflow_dont, /* complain_on_overflow */
1710          bfd_elf_generic_reloc, /* special_function */
1711          "R_PPC_REL16_HI",      /* name */
1712          FALSE,                 /* partial_inplace */
1713          0,                     /* src_mask */
1714          0xffff,                /* dst_mask */
1715          TRUE),                 /* pcrel_offset */
1716
1717   /* The high order 16 bits of a relative address, plus 1 if the contents of
1718      the low 16 bits, treated as a signed number, is negative.  */
1719   HOWTO (R_PPC_REL16_HA,        /* type */
1720          16,                    /* rightshift */
1721          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1722          16,                    /* bitsize */
1723          TRUE,                  /* pc_relative */
1724          0,                     /* bitpos */
1725          complain_overflow_dont, /* complain_on_overflow */
1726          ppc_elf_addr16_ha_reloc, /* special_function */
1727          "R_PPC_REL16_HA",      /* name */
1728          FALSE,                 /* partial_inplace */
1729          0,                     /* src_mask */
1730          0xffff,                /* dst_mask */
1731          TRUE),                 /* pcrel_offset */
1732
1733   /* Like R_PPC_REL16_HA but for split field in addpcis.  */
1734   HOWTO (R_PPC_REL16DX_HA,      /* type */
1735          16,                    /* rightshift */
1736          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1737          16,                    /* bitsize */
1738          TRUE,                  /* pc_relative */
1739          0,                     /* bitpos */
1740          complain_overflow_signed, /* complain_on_overflow */
1741          ppc_elf_addr16_ha_reloc, /* special_function */
1742          "R_PPC_REL16DX_HA",    /* name */
1743          FALSE,                 /* partial_inplace */
1744          0,                     /* src_mask */
1745          0x1fffc1,              /* dst_mask */
1746          TRUE),                 /* pcrel_offset */
1747
1748   /* GNU extension to record C++ vtable hierarchy.  */
1749   HOWTO (R_PPC_GNU_VTINHERIT,   /* type */
1750          0,                     /* rightshift */
1751          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1752          0,                     /* bitsize */
1753          FALSE,                 /* pc_relative */
1754          0,                     /* bitpos */
1755          complain_overflow_dont, /* complain_on_overflow */
1756          NULL,                  /* special_function */
1757          "R_PPC_GNU_VTINHERIT", /* name */
1758          FALSE,                 /* partial_inplace */
1759          0,                     /* src_mask */
1760          0,                     /* dst_mask */
1761          FALSE),                /* pcrel_offset */
1762
1763   /* GNU extension to record C++ vtable member usage.  */
1764   HOWTO (R_PPC_GNU_VTENTRY,     /* type */
1765          0,                     /* rightshift */
1766          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          0,                     /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_dont, /* complain_on_overflow */
1771          NULL,                  /* special_function */
1772          "R_PPC_GNU_VTENTRY",   /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0,                     /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Phony reloc to handle AIX style TOC entries.  */
1779   HOWTO (R_PPC_TOC16,           /* type */
1780          0,                     /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_signed, /* complain_on_overflow */
1786          bfd_elf_generic_reloc, /* special_function */
1787          "R_PPC_TOC16",         /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792 };
1793
1794 /* External 32-bit PPC structure for PRPSINFO.  This structure is
1795    ABI-defined, thus we choose to use char arrays here in order to
1796    avoid dealing with different types in different architectures.
1797
1798    The PPC 32-bit structure uses int for `pr_uid' and `pr_gid' while
1799    most non-PPC architectures use `short int'.
1800
1801    This structure will ultimately be written in the corefile's note
1802    section, as the PRPSINFO.  */
1803
1804 struct elf_external_ppc_linux_prpsinfo32
1805   {
1806     char pr_state;                      /* Numeric process state.  */
1807     char pr_sname;                      /* Char for pr_state.  */
1808     char pr_zomb;                       /* Zombie.  */
1809     char pr_nice;                       /* Nice val.  */
1810     char pr_flag[4];                    /* Flags.  */
1811     char pr_uid[4];
1812     char pr_gid[4];
1813     char pr_pid[4];
1814     char pr_ppid[4];
1815     char pr_pgrp[4];
1816     char pr_sid[4];
1817     char pr_fname[16];                  /* Filename of executable.  */
1818     char pr_psargs[80];                 /* Initial part of arg list.  */
1819   };
1820
1821 /* Helper macro to swap (properly handling endianess) things from the
1822    `elf_internal_prpsinfo' structure to the `elf_external_ppc_prpsinfo32'
1823    structure.
1824
1825    Note that FROM should be a pointer, and TO should be the explicit type.  */
1826
1827 #define PPC_LINUX_PRPSINFO32_SWAP_FIELDS(abfd, from, to)              \
1828   do                                                                  \
1829     {                                                                 \
1830       H_PUT_8 (abfd, from->pr_state, &to.pr_state);                   \
1831       H_PUT_8 (abfd, from->pr_sname, &to.pr_sname);                   \
1832       H_PUT_8 (abfd, from->pr_zomb, &to.pr_zomb);                     \
1833       H_PUT_8 (abfd, from->pr_nice, &to.pr_nice);                     \
1834       H_PUT_32 (abfd, from->pr_flag, to.pr_flag);                     \
1835       H_PUT_32 (abfd, from->pr_uid, to.pr_uid);                       \
1836       H_PUT_32 (abfd, from->pr_gid, to.pr_gid);                       \
1837       H_PUT_32 (abfd, from->pr_pid, to.pr_pid);                       \
1838       H_PUT_32 (abfd, from->pr_ppid, to.pr_ppid);                     \
1839       H_PUT_32 (abfd, from->pr_pgrp, to.pr_pgrp);                     \
1840       H_PUT_32 (abfd, from->pr_sid, to.pr_sid);                       \
1841       strncpy (to.pr_fname, from->pr_fname, sizeof (to.pr_fname));    \
1842       strncpy (to.pr_psargs, from->pr_psargs, sizeof (to.pr_psargs)); \
1843     } while (0)
1844
1845 \f
1846 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done.  */
1847
1848 static void
1849 ppc_elf_howto_init (void)
1850 {
1851   unsigned int i, type;
1852
1853   for (i = 0;
1854        i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]);
1855        i++)
1856     {
1857       type = ppc_elf_howto_raw[i].type;
1858       if (type >= (sizeof (ppc_elf_howto_table)
1859                    / sizeof (ppc_elf_howto_table[0])))
1860         abort ();
1861       ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
1862     }
1863 }
1864
1865 static reloc_howto_type *
1866 ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1867                            bfd_reloc_code_real_type code)
1868 {
1869   enum elf_ppc_reloc_type r;
1870
1871   /* Initialize howto table if not already done.  */
1872   if (!ppc_elf_howto_table[R_PPC_ADDR32])
1873     ppc_elf_howto_init ();
1874
1875   switch (code)
1876     {
1877     default:
1878       return NULL;
1879
1880     case BFD_RELOC_NONE:                r = R_PPC_NONE;                 break;
1881     case BFD_RELOC_32:                  r = R_PPC_ADDR32;               break;
1882     case BFD_RELOC_PPC_BA26:            r = R_PPC_ADDR24;               break;
1883     case BFD_RELOC_PPC64_ADDR16_DS:
1884     case BFD_RELOC_16:                  r = R_PPC_ADDR16;               break;
1885     case BFD_RELOC_PPC64_ADDR16_LO_DS:
1886     case BFD_RELOC_LO16:                r = R_PPC_ADDR16_LO;            break;
1887     case BFD_RELOC_HI16:                r = R_PPC_ADDR16_HI;            break;
1888     case BFD_RELOC_HI16_S:              r = R_PPC_ADDR16_HA;            break;
1889     case BFD_RELOC_PPC_BA16:            r = R_PPC_ADDR14;               break;
1890     case BFD_RELOC_PPC_BA16_BRTAKEN:    r = R_PPC_ADDR14_BRTAKEN;       break;
1891     case BFD_RELOC_PPC_BA16_BRNTAKEN:   r = R_PPC_ADDR14_BRNTAKEN;      break;
1892     case BFD_RELOC_PPC_B26:             r = R_PPC_REL24;                break;
1893     case BFD_RELOC_PPC_B16:             r = R_PPC_REL14;                break;
1894     case BFD_RELOC_PPC_B16_BRTAKEN:     r = R_PPC_REL14_BRTAKEN;        break;
1895     case BFD_RELOC_PPC_B16_BRNTAKEN:    r = R_PPC_REL14_BRNTAKEN;       break;
1896     case BFD_RELOC_PPC64_GOT16_DS:
1897     case BFD_RELOC_16_GOTOFF:           r = R_PPC_GOT16;                break;
1898     case BFD_RELOC_PPC64_GOT16_LO_DS:
1899     case BFD_RELOC_LO16_GOTOFF:         r = R_PPC_GOT16_LO;             break;
1900     case BFD_RELOC_HI16_GOTOFF:         r = R_PPC_GOT16_HI;             break;
1901     case BFD_RELOC_HI16_S_GOTOFF:       r = R_PPC_GOT16_HA;             break;
1902     case BFD_RELOC_24_PLT_PCREL:        r = R_PPC_PLTREL24;             break;
1903     case BFD_RELOC_PPC_COPY:            r = R_PPC_COPY;                 break;
1904     case BFD_RELOC_PPC_GLOB_DAT:        r = R_PPC_GLOB_DAT;             break;
1905     case BFD_RELOC_PPC_LOCAL24PC:       r = R_PPC_LOCAL24PC;            break;
1906     case BFD_RELOC_32_PCREL:            r = R_PPC_REL32;                break;
1907     case BFD_RELOC_32_PLTOFF:           r = R_PPC_PLT32;                break;
1908     case BFD_RELOC_32_PLT_PCREL:        r = R_PPC_PLTREL32;             break;
1909     case BFD_RELOC_PPC64_PLT16_LO_DS:
1910     case BFD_RELOC_LO16_PLTOFF:         r = R_PPC_PLT16_LO;             break;
1911     case BFD_RELOC_HI16_PLTOFF:         r = R_PPC_PLT16_HI;             break;
1912     case BFD_RELOC_HI16_S_PLTOFF:       r = R_PPC_PLT16_HA;             break;
1913     case BFD_RELOC_GPREL16:             r = R_PPC_SDAREL16;             break;
1914     case BFD_RELOC_PPC64_SECTOFF_DS:
1915     case BFD_RELOC_16_BASEREL:          r = R_PPC_SECTOFF;              break;
1916     case BFD_RELOC_PPC64_SECTOFF_LO_DS:
1917     case BFD_RELOC_LO16_BASEREL:        r = R_PPC_SECTOFF_LO;           break;
1918     case BFD_RELOC_HI16_BASEREL:        r = R_PPC_SECTOFF_HI;           break;
1919     case BFD_RELOC_HI16_S_BASEREL:      r = R_PPC_SECTOFF_HA;           break;
1920     case BFD_RELOC_CTOR:                r = R_PPC_ADDR32;               break;
1921     case BFD_RELOC_PPC64_TOC16_DS:
1922     case BFD_RELOC_PPC_TOC16:           r = R_PPC_TOC16;                break;
1923     case BFD_RELOC_PPC_TLS:             r = R_PPC_TLS;                  break;
1924     case BFD_RELOC_PPC_TLSGD:           r = R_PPC_TLSGD;                break;
1925     case BFD_RELOC_PPC_TLSLD:           r = R_PPC_TLSLD;                break;
1926     case BFD_RELOC_PPC_DTPMOD:          r = R_PPC_DTPMOD32;             break;
1927     case BFD_RELOC_PPC64_TPREL16_DS:
1928     case BFD_RELOC_PPC_TPREL16:         r = R_PPC_TPREL16;              break;
1929     case BFD_RELOC_PPC64_TPREL16_LO_DS:
1930     case BFD_RELOC_PPC_TPREL16_LO:      r = R_PPC_TPREL16_LO;           break;
1931     case BFD_RELOC_PPC_TPREL16_HI:      r = R_PPC_TPREL16_HI;           break;
1932     case BFD_RELOC_PPC_TPREL16_HA:      r = R_PPC_TPREL16_HA;           break;
1933     case BFD_RELOC_PPC_TPREL:           r = R_PPC_TPREL32;              break;
1934     case BFD_RELOC_PPC64_DTPREL16_DS:
1935     case BFD_RELOC_PPC_DTPREL16:        r = R_PPC_DTPREL16;             break;
1936     case BFD_RELOC_PPC64_DTPREL16_LO_DS:
1937     case BFD_RELOC_PPC_DTPREL16_LO:     r = R_PPC_DTPREL16_LO;          break;
1938     case BFD_RELOC_PPC_DTPREL16_HI:     r = R_PPC_DTPREL16_HI;          break;
1939     case BFD_RELOC_PPC_DTPREL16_HA:     r = R_PPC_DTPREL16_HA;          break;
1940     case BFD_RELOC_PPC_DTPREL:          r = R_PPC_DTPREL32;             break;
1941     case BFD_RELOC_PPC_GOT_TLSGD16:     r = R_PPC_GOT_TLSGD16;          break;
1942     case BFD_RELOC_PPC_GOT_TLSGD16_LO:  r = R_PPC_GOT_TLSGD16_LO;       break;
1943     case BFD_RELOC_PPC_GOT_TLSGD16_HI:  r = R_PPC_GOT_TLSGD16_HI;       break;
1944     case BFD_RELOC_PPC_GOT_TLSGD16_HA:  r = R_PPC_GOT_TLSGD16_HA;       break;
1945     case BFD_RELOC_PPC_GOT_TLSLD16:     r = R_PPC_GOT_TLSLD16;          break;
1946     case BFD_RELOC_PPC_GOT_TLSLD16_LO:  r = R_PPC_GOT_TLSLD16_LO;       break;
1947     case BFD_RELOC_PPC_GOT_TLSLD16_HI:  r = R_PPC_GOT_TLSLD16_HI;       break;
1948     case BFD_RELOC_PPC_GOT_TLSLD16_HA:  r = R_PPC_GOT_TLSLD16_HA;       break;
1949     case BFD_RELOC_PPC_GOT_TPREL16:     r = R_PPC_GOT_TPREL16;          break;
1950     case BFD_RELOC_PPC_GOT_TPREL16_LO:  r = R_PPC_GOT_TPREL16_LO;       break;
1951     case BFD_RELOC_PPC_GOT_TPREL16_HI:  r = R_PPC_GOT_TPREL16_HI;       break;
1952     case BFD_RELOC_PPC_GOT_TPREL16_HA:  r = R_PPC_GOT_TPREL16_HA;       break;
1953     case BFD_RELOC_PPC_GOT_DTPREL16:    r = R_PPC_GOT_DTPREL16;         break;
1954     case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC_GOT_DTPREL16_LO;      break;
1955     case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC_GOT_DTPREL16_HI;      break;
1956     case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC_GOT_DTPREL16_HA;      break;
1957     case BFD_RELOC_PPC_EMB_NADDR32:     r = R_PPC_EMB_NADDR32;          break;
1958     case BFD_RELOC_PPC_EMB_NADDR16:     r = R_PPC_EMB_NADDR16;          break;
1959     case BFD_RELOC_PPC_EMB_NADDR16_LO:  r = R_PPC_EMB_NADDR16_LO;       break;
1960     case BFD_RELOC_PPC_EMB_NADDR16_HI:  r = R_PPC_EMB_NADDR16_HI;       break;
1961     case BFD_RELOC_PPC_EMB_NADDR16_HA:  r = R_PPC_EMB_NADDR16_HA;       break;
1962     case BFD_RELOC_PPC_EMB_SDAI16:      r = R_PPC_EMB_SDAI16;           break;
1963     case BFD_RELOC_PPC_EMB_SDA2I16:     r = R_PPC_EMB_SDA2I16;          break;
1964     case BFD_RELOC_PPC_EMB_SDA2REL:     r = R_PPC_EMB_SDA2REL;          break;
1965     case BFD_RELOC_PPC_EMB_SDA21:       r = R_PPC_EMB_SDA21;            break;
1966     case BFD_RELOC_PPC_EMB_MRKREF:      r = R_PPC_EMB_MRKREF;           break;
1967     case BFD_RELOC_PPC_EMB_RELSEC16:    r = R_PPC_EMB_RELSEC16;         break;
1968     case BFD_RELOC_PPC_EMB_RELST_LO:    r = R_PPC_EMB_RELST_LO;         break;
1969     case BFD_RELOC_PPC_EMB_RELST_HI:    r = R_PPC_EMB_RELST_HI;         break;
1970     case BFD_RELOC_PPC_EMB_RELST_HA:    r = R_PPC_EMB_RELST_HA;         break;
1971     case BFD_RELOC_PPC_EMB_BIT_FLD:     r = R_PPC_EMB_BIT_FLD;          break;
1972     case BFD_RELOC_PPC_EMB_RELSDA:      r = R_PPC_EMB_RELSDA;           break;
1973     case BFD_RELOC_PPC_VLE_REL8:        r = R_PPC_VLE_REL8;             break;
1974     case BFD_RELOC_PPC_VLE_REL15:       r = R_PPC_VLE_REL15;            break;
1975     case BFD_RELOC_PPC_VLE_REL24:       r = R_PPC_VLE_REL24;            break;
1976     case BFD_RELOC_PPC_VLE_LO16A:       r = R_PPC_VLE_LO16A;            break;
1977     case BFD_RELOC_PPC_VLE_LO16D:       r = R_PPC_VLE_LO16D;            break;
1978     case BFD_RELOC_PPC_VLE_HI16A:       r = R_PPC_VLE_HI16A;            break;
1979     case BFD_RELOC_PPC_VLE_HI16D:       r = R_PPC_VLE_HI16D;            break;
1980     case BFD_RELOC_PPC_VLE_HA16A:       r = R_PPC_VLE_HA16A;            break;
1981     case BFD_RELOC_PPC_VLE_HA16D:       r = R_PPC_VLE_HA16D;            break;
1982     case BFD_RELOC_PPC_VLE_SDA21:       r = R_PPC_VLE_SDA21;            break;
1983     case BFD_RELOC_PPC_VLE_SDA21_LO:    r = R_PPC_VLE_SDA21_LO;         break;
1984     case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
1985       r = R_PPC_VLE_SDAREL_LO16A;
1986       break;
1987     case BFD_RELOC_PPC_VLE_SDAREL_LO16D:
1988       r = R_PPC_VLE_SDAREL_LO16D;
1989       break;
1990     case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
1991       r = R_PPC_VLE_SDAREL_HI16A;
1992       break;
1993     case BFD_RELOC_PPC_VLE_SDAREL_HI16D:
1994       r = R_PPC_VLE_SDAREL_HI16D;
1995       break;
1996     case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
1997       r = R_PPC_VLE_SDAREL_HA16A;
1998       break;
1999     case BFD_RELOC_PPC_VLE_SDAREL_HA16D:
2000       r = R_PPC_VLE_SDAREL_HA16D;
2001       break;
2002     case BFD_RELOC_16_PCREL:            r = R_PPC_REL16;                break;
2003     case BFD_RELOC_LO16_PCREL:          r = R_PPC_REL16_LO;             break;
2004     case BFD_RELOC_HI16_PCREL:          r = R_PPC_REL16_HI;             break;
2005     case BFD_RELOC_HI16_S_PCREL:        r = R_PPC_REL16_HA;             break;
2006     case BFD_RELOC_PPC_REL16DX_HA:      r = R_PPC_REL16DX_HA;           break;
2007     case BFD_RELOC_VTABLE_INHERIT:      r = R_PPC_GNU_VTINHERIT;        break;
2008     case BFD_RELOC_VTABLE_ENTRY:        r = R_PPC_GNU_VTENTRY;          break;
2009     }
2010
2011   return ppc_elf_howto_table[r];
2012 };
2013
2014 static reloc_howto_type *
2015 ppc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2016                            const char *r_name)
2017 {
2018   unsigned int i;
2019
2020   for (i = 0;
2021        i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]);
2022        i++)
2023     if (ppc_elf_howto_raw[i].name != NULL
2024         && strcasecmp (ppc_elf_howto_raw[i].name, r_name) == 0)
2025       return &ppc_elf_howto_raw[i];
2026
2027   return NULL;
2028 }
2029
2030 /* Set the howto pointer for a PowerPC ELF reloc.  */
2031
2032 static void
2033 ppc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
2034                        arelent *cache_ptr,
2035                        Elf_Internal_Rela *dst)
2036 {
2037   unsigned int r_type;
2038
2039   /* Initialize howto table if not already done.  */
2040   if (!ppc_elf_howto_table[R_PPC_ADDR32])
2041     ppc_elf_howto_init ();
2042
2043   r_type = ELF32_R_TYPE (dst->r_info);
2044   if (r_type >= R_PPC_max)
2045     {
2046       (*_bfd_error_handler) (_("%B: unrecognised PPC reloc number: %d"),
2047                              abfd, r_type);
2048       bfd_set_error (bfd_error_bad_value);
2049       r_type = R_PPC_NONE;
2050     }
2051   cache_ptr->howto = ppc_elf_howto_table[r_type];
2052
2053   /* Just because the above assert didn't trigger doesn't mean that
2054      ELF32_R_TYPE (dst->r_info) is necessarily a valid relocation.  */
2055   if (!cache_ptr->howto)
2056     {
2057       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2058                              abfd, r_type);
2059       bfd_set_error (bfd_error_bad_value);
2060
2061       cache_ptr->howto = ppc_elf_howto_table[R_PPC_NONE];
2062     }
2063 }
2064
2065 /* Handle the R_PPC_ADDR16_HA and R_PPC_REL16_HA relocs.  */
2066
2067 static bfd_reloc_status_type
2068 ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED,
2069                          arelent *reloc_entry,
2070                          asymbol *symbol,
2071                          void *data ATTRIBUTE_UNUSED,
2072                          asection *input_section,
2073                          bfd *output_bfd,
2074                          char **error_message ATTRIBUTE_UNUSED)
2075 {
2076   enum elf_ppc_reloc_type r_type;
2077   long insn;
2078   bfd_size_type octets;
2079   bfd_vma value;
2080
2081   if (output_bfd != NULL)
2082     {
2083       reloc_entry->address += input_section->output_offset;
2084       return bfd_reloc_ok;
2085     }
2086
2087   reloc_entry->addend += 0x8000;
2088   r_type = reloc_entry->howto->type;
2089   if (r_type != R_PPC_REL16DX_HA)
2090     return bfd_reloc_continue;
2091
2092   value = 0;
2093   if (!bfd_is_com_section (symbol->section))
2094     value = symbol->value;
2095   value += (reloc_entry->addend
2096             + symbol->section->output_offset
2097             + symbol->section->output_section->vma);
2098   value -= (reloc_entry->address
2099             + input_section->output_offset
2100             + input_section->output_section->vma);
2101   value >>= 16;
2102
2103   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2104   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2105   insn &= ~0x1fffc1;
2106   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2107   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2108   return bfd_reloc_ok;
2109 }
2110
2111 static bfd_reloc_status_type
2112 ppc_elf_unhandled_reloc (bfd *abfd,
2113                          arelent *reloc_entry,
2114                          asymbol *symbol,
2115                          void *data,
2116                          asection *input_section,
2117                          bfd *output_bfd,
2118                          char **error_message)
2119 {
2120   /* If this is a relocatable link (output_bfd test tells us), just
2121      call the generic function.  Any adjustment will be done at final
2122      link time.  */
2123   if (output_bfd != NULL)
2124     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2125                                   input_section, output_bfd, error_message);
2126
2127   if (error_message != NULL)
2128     {
2129       static char buf[60];
2130       sprintf (buf, _("generic linker can't handle %s"),
2131                reloc_entry->howto->name);
2132       *error_message = buf;
2133     }
2134   return bfd_reloc_dangerous;
2135 }
2136 \f
2137 /* Sections created by the linker.  */
2138
2139 typedef struct elf_linker_section
2140 {
2141   /* Pointer to the bfd section.  */
2142   asection *section;
2143   /* Section name.  */
2144   const char *name;
2145   /* Associated bss section name.  */
2146   const char *bss_name;
2147   /* Associated symbol name.  */
2148   const char *sym_name;
2149   /* Associated symbol.  */
2150   struct elf_link_hash_entry *sym;
2151 } elf_linker_section_t;
2152
2153 /* Linked list of allocated pointer entries.  This hangs off of the
2154    symbol lists, and provides allows us to return different pointers,
2155    based on different addend's.  */
2156
2157 typedef struct elf_linker_section_pointers
2158 {
2159   /* next allocated pointer for this symbol */
2160   struct elf_linker_section_pointers *next;
2161   /* offset of pointer from beginning of section */
2162   bfd_vma offset;
2163   /* addend used */
2164   bfd_vma addend;
2165   /* which linker section this is */
2166   elf_linker_section_t *lsect;
2167 } elf_linker_section_pointers_t;
2168
2169 struct ppc_elf_obj_tdata
2170 {
2171   struct elf_obj_tdata elf;
2172
2173   /* A mapping from local symbols to offsets into the various linker
2174      sections added.  This is index by the symbol index.  */
2175   elf_linker_section_pointers_t **linker_section_pointers;
2176
2177   /* Flags used to auto-detect plt type.  */
2178   unsigned int makes_plt_call : 1;
2179   unsigned int has_rel16 : 1;
2180 };
2181
2182 #define ppc_elf_tdata(bfd) \
2183   ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any)
2184
2185 #define elf_local_ptr_offsets(bfd) \
2186   (ppc_elf_tdata (bfd)->linker_section_pointers)
2187
2188 #define is_ppc_elf(bfd) \
2189   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2190    && elf_object_id (bfd) == PPC32_ELF_DATA)
2191
2192 /* Override the generic function because we store some extras.  */
2193
2194 static bfd_boolean
2195 ppc_elf_mkobject (bfd *abfd)
2196 {
2197   return bfd_elf_allocate_object (abfd, sizeof (struct ppc_elf_obj_tdata),
2198                                   PPC32_ELF_DATA);
2199 }
2200
2201 /* Fix bad default arch selected for a 32 bit input bfd when the
2202    default is 64 bit.  */
2203
2204 static bfd_boolean
2205 ppc_elf_object_p (bfd *abfd)
2206 {
2207   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 64)
2208     {
2209       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2210
2211       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS32)
2212         {
2213           /* Relies on arch after 64 bit default being 32 bit default.  */
2214           abfd->arch_info = abfd->arch_info->next;
2215           BFD_ASSERT (abfd->arch_info->bits_per_word == 32);
2216         }
2217     }
2218   return TRUE;
2219 }
2220
2221 /* Function to set whether a module needs the -mrelocatable bit set.  */
2222
2223 static bfd_boolean
2224 ppc_elf_set_private_flags (bfd *abfd, flagword flags)
2225 {
2226   BFD_ASSERT (!elf_flags_init (abfd)
2227               || elf_elfheader (abfd)->e_flags == flags);
2228
2229   elf_elfheader (abfd)->e_flags = flags;
2230   elf_flags_init (abfd) = TRUE;
2231   return TRUE;
2232 }
2233
2234 /* Support for core dump NOTE sections.  */
2235
2236 static bfd_boolean
2237 ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2238 {
2239   int offset;
2240   unsigned int size;
2241
2242   switch (note->descsz)
2243     {
2244     default:
2245       return FALSE;
2246
2247     case 268:           /* Linux/PPC.  */
2248       /* pr_cursig */
2249       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2250
2251       /* pr_pid */
2252       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
2253
2254       /* pr_reg */
2255       offset = 72;
2256       size = 192;
2257
2258       break;
2259     }
2260
2261   /* Make a ".reg/999" section.  */
2262   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2263                                           size, note->descpos + offset);
2264 }
2265
2266 static bfd_boolean
2267 ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2268 {
2269   switch (note->descsz)
2270     {
2271     default:
2272       return FALSE;
2273
2274     case 128:           /* Linux/PPC elf_prpsinfo.  */
2275       elf_tdata (abfd)->core->pid
2276         = bfd_get_32 (abfd, note->descdata + 16);
2277       elf_tdata (abfd)->core->program
2278         = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
2279       elf_tdata (abfd)->core->command
2280         = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
2281     }
2282
2283   /* Note that for some reason, a spurious space is tacked
2284      onto the end of the args in some (at least one anyway)
2285      implementations, so strip it off if it exists.  */
2286
2287   {
2288     char *command = elf_tdata (abfd)->core->command;
2289     int n = strlen (command);
2290
2291     if (0 < n && command[n - 1] == ' ')
2292       command[n - 1] = '\0';
2293   }
2294
2295   return TRUE;
2296 }
2297
2298 char *
2299 elfcore_write_ppc_linux_prpsinfo32 (bfd *abfd, char *buf, int *bufsiz,
2300                                       const struct elf_internal_linux_prpsinfo *prpsinfo)
2301 {
2302   struct elf_external_ppc_linux_prpsinfo32 data;
2303
2304   memset (&data, 0, sizeof (data));
2305   PPC_LINUX_PRPSINFO32_SWAP_FIELDS (abfd, prpsinfo, data);
2306
2307   return elfcore_write_note (abfd, buf, bufsiz,
2308                              "CORE", NT_PRPSINFO, &data, sizeof (data));
2309 }
2310
2311 static char *
2312 ppc_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...)
2313 {
2314   switch (note_type)
2315     {
2316     default:
2317       return NULL;
2318
2319     case NT_PRPSINFO:
2320       {
2321         char data[128];
2322         va_list ap;
2323
2324         va_start (ap, note_type);
2325         memset (data, 0, sizeof (data));
2326         strncpy (data + 32, va_arg (ap, const char *), 16);
2327         strncpy (data + 48, va_arg (ap, const char *), 80);
2328         va_end (ap);
2329         return elfcore_write_note (abfd, buf, bufsiz,
2330                                    "CORE", note_type, data, sizeof (data));
2331       }
2332
2333     case NT_PRSTATUS:
2334       {
2335         char data[268];
2336         va_list ap;
2337         long pid;
2338         int cursig;
2339         const void *greg;
2340
2341         va_start (ap, note_type);
2342         memset (data, 0, 72);
2343         pid = va_arg (ap, long);
2344         bfd_put_32 (abfd, pid, data + 24);
2345         cursig = va_arg (ap, int);
2346         bfd_put_16 (abfd, cursig, data + 12);
2347         greg = va_arg (ap, const void *);
2348         memcpy (data + 72, greg, 192);
2349         memset (data + 264, 0, 4);
2350         va_end (ap);
2351         return elfcore_write_note (abfd, buf, bufsiz,
2352                                    "CORE", note_type, data, sizeof (data));
2353       }
2354     }
2355 }
2356
2357 static flagword
2358 ppc_elf_lookup_section_flags (char *flag_name)
2359 {
2360
2361   if (!strcmp (flag_name, "SHF_PPC_VLE"))
2362     return SHF_PPC_VLE;
2363
2364   return 0;
2365 }
2366
2367 /* Add the VLE flag if required.  */
2368
2369 bfd_boolean
2370 ppc_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *shdr)
2371 {
2372   if (bfd_get_mach (abfd) == bfd_mach_ppc_vle
2373       && (shdr->sh_flags & SHF_EXECINSTR) != 0)
2374     shdr->sh_flags |= SHF_PPC_VLE;
2375
2376   return TRUE;
2377 }
2378
2379 /* Return address for Ith PLT stub in section PLT, for relocation REL
2380    or (bfd_vma) -1 if it should not be included.  */
2381
2382 static bfd_vma
2383 ppc_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
2384                      const asection *plt ATTRIBUTE_UNUSED,
2385                      const arelent *rel)
2386 {
2387   return rel->address;
2388 }
2389
2390 /* Handle a PowerPC specific section when reading an object file.  This
2391    is called when bfd_section_from_shdr finds a section with an unknown
2392    type.  */
2393
2394 static bfd_boolean
2395 ppc_elf_section_from_shdr (bfd *abfd,
2396                            Elf_Internal_Shdr *hdr,
2397                            const char *name,
2398                            int shindex)
2399 {
2400   asection *newsect;
2401   flagword flags;
2402
2403   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2404     return FALSE;
2405
2406   newsect = hdr->bfd_section;
2407   flags = bfd_get_section_flags (abfd, newsect);
2408   if (hdr->sh_flags & SHF_EXCLUDE)
2409     flags |= SEC_EXCLUDE;
2410
2411   if (hdr->sh_type == SHT_ORDERED)
2412     flags |= SEC_SORT_ENTRIES;
2413
2414   bfd_set_section_flags (abfd, newsect, flags);
2415   return TRUE;
2416 }
2417
2418 /* Set up any other section flags and such that may be necessary.  */
2419
2420 static bfd_boolean
2421 ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2422                        Elf_Internal_Shdr *shdr,
2423                        asection *asect)
2424 {
2425   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
2426     shdr->sh_type = SHT_ORDERED;
2427
2428   return TRUE;
2429 }
2430
2431 /* If we have .sbss2 or .PPC.EMB.sbss0 output sections, we
2432    need to bump up the number of section headers.  */
2433
2434 static int
2435 ppc_elf_additional_program_headers (bfd *abfd,
2436                                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
2437 {
2438   asection *s;
2439   int ret = 0;
2440
2441   s = bfd_get_section_by_name (abfd, ".sbss2");
2442   if (s != NULL && (s->flags & SEC_ALLOC) != 0)
2443     ++ret;
2444
2445   s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
2446   if (s != NULL && (s->flags & SEC_ALLOC) != 0)
2447     ++ret;
2448
2449   return ret;
2450 }
2451
2452 /* Modify the segment map for VLE executables.  */
2453
2454 bfd_boolean
2455 ppc_elf_modify_segment_map (bfd *abfd,
2456                             struct bfd_link_info *info ATTRIBUTE_UNUSED)
2457 {
2458   struct elf_segment_map *m, *n;
2459   bfd_size_type amt;
2460   unsigned int j, k;
2461   bfd_boolean sect0_vle, sectj_vle;
2462
2463   /* At this point in the link, output sections have already been sorted by
2464      LMA and assigned to segments.  All that is left to do is to ensure
2465      there is no mixing of VLE & non-VLE sections in a text segment.
2466      If we find that case, we split the segment.
2467      We maintain the original output section order.  */
2468
2469   for (m = elf_seg_map (abfd); m != NULL; m = m->next)
2470     {
2471       if (m->count == 0)
2472         continue;
2473
2474       sect0_vle = (elf_section_flags (m->sections[0]) & SHF_PPC_VLE) != 0;
2475       for (j = 1; j < m->count; ++j)
2476         {
2477           sectj_vle = (elf_section_flags (m->sections[j]) & SHF_PPC_VLE) != 0;
2478
2479           if (sectj_vle != sect0_vle)
2480             break;
2481         }
2482       if (j >= m->count)
2483         continue;
2484
2485       /* sections 0..j-1 stay in this (current) segment,
2486          the remainder are put in a new segment.
2487          The scan resumes with the new segment.  */
2488
2489       /* Fix the new segment.  */
2490       amt = sizeof (struct elf_segment_map);
2491       amt += (m->count - j - 1) * sizeof (asection *);
2492       n = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2493       if (n == NULL)
2494         return FALSE;
2495
2496       n->p_type = PT_LOAD;
2497       n->p_flags = PF_X | PF_R;
2498       if (sectj_vle)
2499         n->p_flags |= PF_PPC_VLE;
2500       n->count = m->count - j;
2501       for (k = 0; k < n->count; ++k)
2502         {
2503           n->sections[k] = m->sections[j+k];
2504           m->sections[j+k] = NULL;
2505         }
2506       n->next = m->next;
2507       m->next = n;
2508
2509       /* Fix the current segment  */
2510       m->count = j;
2511     }
2512
2513   return TRUE;
2514 }
2515
2516 /* Add extra PPC sections -- Note, for now, make .sbss2 and
2517    .PPC.EMB.sbss0 a normal section, and not a bss section so
2518    that the linker doesn't crater when trying to make more than
2519    2 sections.  */
2520
2521 static const struct bfd_elf_special_section ppc_elf_special_sections[] =
2522 {
2523   { STRING_COMMA_LEN (".plt"),             0, SHT_NOBITS,   SHF_ALLOC + SHF_EXECINSTR },
2524   { STRING_COMMA_LEN (".sbss"),           -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2525   { STRING_COMMA_LEN (".sbss2"),          -2, SHT_PROGBITS, SHF_ALLOC },
2526   { STRING_COMMA_LEN (".sdata"),          -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2527   { STRING_COMMA_LEN (".sdata2"),         -2, SHT_PROGBITS, SHF_ALLOC },
2528   { STRING_COMMA_LEN (".tags"),            0, SHT_ORDERED,  SHF_ALLOC },
2529   { STRING_COMMA_LEN (".PPC.EMB.apuinfo"), 0, SHT_NOTE,     0 },
2530   { STRING_COMMA_LEN (".PPC.EMB.sbss0"),   0, SHT_PROGBITS, SHF_ALLOC },
2531   { STRING_COMMA_LEN (".PPC.EMB.sdata0"),  0, SHT_PROGBITS, SHF_ALLOC },
2532   { NULL,                              0,  0, 0,            0 }
2533 };
2534
2535 /* This is what we want for new plt/got.  */
2536 static struct bfd_elf_special_section ppc_alt_plt =
2537   { STRING_COMMA_LEN (".plt"),             0, SHT_PROGBITS, SHF_ALLOC };
2538
2539 static const struct bfd_elf_special_section *
2540 ppc_elf_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
2541 {
2542   const struct bfd_elf_special_section *ssect;
2543
2544   /* See if this is one of the special sections.  */
2545   if (sec->name == NULL)
2546     return NULL;
2547
2548   ssect = _bfd_elf_get_special_section (sec->name, ppc_elf_special_sections,
2549                                         sec->use_rela_p);
2550   if (ssect != NULL)
2551     {
2552       if (ssect == ppc_elf_special_sections && (sec->flags & SEC_LOAD) != 0)
2553         ssect = &ppc_alt_plt;
2554       return ssect;
2555     }
2556
2557   return _bfd_elf_get_sec_type_attr (abfd, sec);
2558 }
2559 \f
2560 /* Very simple linked list structure for recording apuinfo values.  */
2561 typedef struct apuinfo_list
2562 {
2563   struct apuinfo_list *next;
2564   unsigned long value;
2565 }
2566 apuinfo_list;
2567
2568 static apuinfo_list *head;
2569 static bfd_boolean apuinfo_set;
2570
2571 static void
2572 apuinfo_list_init (void)
2573 {
2574   head = NULL;
2575   apuinfo_set = FALSE;
2576 }
2577
2578 static void
2579 apuinfo_list_add (unsigned long value)
2580 {
2581   apuinfo_list *entry = head;
2582
2583   while (entry != NULL)
2584     {
2585       if (entry->value == value)
2586         return;
2587       entry = entry->next;
2588     }
2589
2590   entry = bfd_malloc (sizeof (* entry));
2591   if (entry == NULL)
2592     return;
2593
2594   entry->value = value;
2595   entry->next  = head;
2596   head = entry;
2597 }
2598
2599 static unsigned
2600 apuinfo_list_length (void)
2601 {
2602   apuinfo_list *entry;
2603   unsigned long count;
2604
2605   for (entry = head, count = 0;
2606        entry;
2607        entry = entry->next)
2608     ++ count;
2609
2610   return count;
2611 }
2612
2613 static inline unsigned long
2614 apuinfo_list_element (unsigned long number)
2615 {
2616   apuinfo_list * entry;
2617
2618   for (entry = head;
2619        entry && number --;
2620        entry = entry->next)
2621     ;
2622
2623   return entry ? entry->value : 0;
2624 }
2625
2626 static void
2627 apuinfo_list_finish (void)
2628 {
2629   apuinfo_list *entry;
2630
2631   for (entry = head; entry;)
2632     {
2633       apuinfo_list *next = entry->next;
2634       free (entry);
2635       entry = next;
2636     }
2637
2638   head = NULL;
2639 }
2640
2641 #define APUINFO_SECTION_NAME    ".PPC.EMB.apuinfo"
2642 #define APUINFO_LABEL           "APUinfo"
2643
2644 /* Scan the input BFDs and create a linked list of
2645    the APUinfo values that will need to be emitted.  */
2646
2647 static void
2648 ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info)
2649 {
2650   bfd *ibfd;
2651   asection *asec;
2652   char *buffer = NULL;
2653   bfd_size_type largest_input_size = 0;
2654   unsigned i;
2655   unsigned long length;
2656   const char *error_message = NULL;
2657
2658   if (link_info == NULL)
2659     return;
2660
2661   apuinfo_list_init ();
2662
2663   /* Read in the input sections contents.  */
2664   for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link.next)
2665     {
2666       unsigned long datum;
2667
2668       asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
2669       if (asec == NULL)
2670         continue;
2671
2672       error_message = _("corrupt %s section in %B");
2673       length = asec->size;
2674       if (length < 20)
2675         goto fail;
2676
2677       apuinfo_set = TRUE;
2678       if (largest_input_size < asec->size)
2679         {
2680           if (buffer)
2681             free (buffer);
2682           largest_input_size = asec->size;
2683           buffer = bfd_malloc (largest_input_size);
2684           if (!buffer)
2685             return;
2686         }
2687
2688       if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0
2689           || (bfd_bread (buffer, length, ibfd) != length))
2690         {
2691           error_message = _("unable to read in %s section from %B");
2692           goto fail;
2693         }
2694
2695       /* Verify the contents of the header.  Note - we have to
2696          extract the values this way in order to allow for a
2697          host whose endian-ness is different from the target.  */
2698       datum = bfd_get_32 (ibfd, buffer);
2699       if (datum != sizeof APUINFO_LABEL)
2700         goto fail;
2701
2702       datum = bfd_get_32 (ibfd, buffer + 8);
2703       if (datum != 0x2)
2704         goto fail;
2705
2706       if (strcmp (buffer + 12, APUINFO_LABEL) != 0)
2707         goto fail;
2708
2709       /* Get the number of bytes used for apuinfo entries.  */
2710       datum = bfd_get_32 (ibfd, buffer + 4);
2711       if (datum + 20 != length)
2712         goto fail;
2713
2714       /* Scan the apuinfo section, building a list of apuinfo numbers.  */
2715       for (i = 0; i < datum; i += 4)
2716         apuinfo_list_add (bfd_get_32 (ibfd, buffer + 20 + i));
2717     }
2718
2719   error_message = NULL;
2720
2721   if (apuinfo_set)
2722     {
2723       /* Compute the size of the output section.  */
2724       unsigned num_entries = apuinfo_list_length ();
2725
2726       /* Set the output section size, if it exists.  */
2727       asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
2728
2729       if (asec && ! bfd_set_section_size (abfd, asec, 20 + num_entries * 4))
2730         {
2731           ibfd = abfd;
2732           error_message = _("warning: unable to set size of %s section in %B");
2733         }
2734     }
2735
2736  fail:
2737   if (buffer)
2738     free (buffer);
2739
2740   if (error_message)
2741     (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME);
2742 }
2743
2744 /* Prevent the output section from accumulating the input sections'
2745    contents.  We have already stored this in our linked list structure.  */
2746
2747 static bfd_boolean
2748 ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED,
2749                        struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2750                        asection *asec,
2751                        bfd_byte *contents ATTRIBUTE_UNUSED)
2752 {
2753   return apuinfo_set && strcmp (asec->name, APUINFO_SECTION_NAME) == 0;
2754 }
2755
2756 /* Finally we can generate the output section.  */
2757
2758 static void
2759 ppc_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
2760 {
2761   bfd_byte *buffer;
2762   asection *asec;
2763   unsigned i;
2764   unsigned num_entries;
2765   bfd_size_type length;
2766
2767   asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
2768   if (asec == NULL)
2769     return;
2770
2771   if (!apuinfo_set)
2772     return;
2773
2774   length = asec->size;
2775   if (length < 20)
2776     return;
2777
2778   buffer = bfd_malloc (length);
2779   if (buffer == NULL)
2780     {
2781       (*_bfd_error_handler)
2782         (_("failed to allocate space for new APUinfo section."));
2783       return;
2784     }
2785
2786   /* Create the apuinfo header.  */
2787   num_entries = apuinfo_list_length ();
2788   bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer);
2789   bfd_put_32 (abfd, num_entries * 4, buffer + 4);
2790   bfd_put_32 (abfd, 0x2, buffer + 8);
2791   strcpy ((char *) buffer + 12, APUINFO_LABEL);
2792
2793   length = 20;
2794   for (i = 0; i < num_entries; i++)
2795     {
2796       bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
2797       length += 4;
2798     }
2799
2800   if (length != asec->size)
2801     (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
2802
2803   if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
2804     (*_bfd_error_handler) (_("failed to install new APUinfo section."));
2805
2806   free (buffer);
2807
2808   apuinfo_list_finish ();
2809 }
2810 \f
2811 static bfd_boolean
2812 is_nonpic_glink_stub (bfd *abfd, asection *glink, bfd_vma off)
2813 {
2814   bfd_byte buf[GLINK_ENTRY_SIZE];
2815
2816   if (!bfd_get_section_contents (abfd, glink, buf, off, GLINK_ENTRY_SIZE))
2817     return FALSE;
2818
2819   return ((bfd_get_32 (abfd, buf + 0) & 0xffff0000) == LIS_11
2820           && (bfd_get_32 (abfd, buf + 4) & 0xffff0000) == LWZ_11_11
2821           && bfd_get_32 (abfd, buf + 8) == MTCTR_11
2822           && bfd_get_32 (abfd, buf + 12) == BCTR);
2823 }
2824
2825 static bfd_boolean
2826 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2827 {
2828   bfd_vma vma = *(bfd_vma *) ptr;
2829   return ((section->flags & SEC_ALLOC) != 0
2830           && section->vma <= vma
2831           && vma < section->vma + section->size);
2832 }
2833
2834 static long
2835 ppc_elf_get_synthetic_symtab (bfd *abfd, long symcount, asymbol **syms,
2836                               long dynsymcount, asymbol **dynsyms,
2837                               asymbol **ret)
2838 {
2839   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2840   asection *plt, *relplt, *dynamic, *glink;
2841   bfd_vma glink_vma = 0;
2842   bfd_vma resolv_vma = 0;
2843   bfd_vma stub_vma;
2844   asymbol *s;
2845   arelent *p;
2846   long count, i;
2847   size_t size;
2848   char *names;
2849   bfd_byte buf[4];
2850
2851   *ret = NULL;
2852
2853   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
2854     return 0;
2855
2856   if (dynsymcount <= 0)
2857     return 0;
2858
2859   relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2860   if (relplt == NULL)
2861     return 0;
2862
2863   plt = bfd_get_section_by_name (abfd, ".plt");
2864   if (plt == NULL)
2865     return 0;
2866
2867   /* Call common code to handle old-style executable PLTs.  */
2868   if (elf_section_flags (plt) & SHF_EXECINSTR)
2869     return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms,
2870                                           dynsymcount, dynsyms, ret);
2871
2872   /* If this object was prelinked, the prelinker stored the address
2873      of .glink at got[1].  If it wasn't prelinked, got[1] will be zero.  */
2874   dynamic = bfd_get_section_by_name (abfd, ".dynamic");
2875   if (dynamic != NULL)
2876     {
2877       bfd_byte *dynbuf, *extdyn, *extdynend;
2878       size_t extdynsize;
2879       void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
2880
2881       if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
2882         return -1;
2883
2884       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
2885       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
2886
2887       extdyn = dynbuf;
2888       extdynend = extdyn + dynamic->size;
2889       for (; extdyn < extdynend; extdyn += extdynsize)
2890         {
2891           Elf_Internal_Dyn dyn;
2892           (*swap_dyn_in) (abfd, extdyn, &dyn);
2893
2894           if (dyn.d_tag == DT_NULL)
2895             break;
2896
2897           if (dyn.d_tag == DT_PPC_GOT)
2898             {
2899               unsigned int g_o_t = dyn.d_un.d_val;
2900               asection *got = bfd_get_section_by_name (abfd, ".got");
2901               if (got != NULL
2902                   && bfd_get_section_contents (abfd, got, buf,
2903                                                g_o_t - got->vma + 4, 4))
2904                 glink_vma = bfd_get_32 (abfd, buf);
2905               break;
2906             }
2907         }
2908       free (dynbuf);
2909     }
2910
2911   /* Otherwise we read the first plt entry.  */
2912   if (glink_vma == 0)
2913     {
2914       if (bfd_get_section_contents (abfd, plt, buf, 0, 4))
2915         glink_vma = bfd_get_32 (abfd, buf);
2916     }
2917
2918   if (glink_vma == 0)
2919     return 0;
2920
2921   /* The .glink section usually does not survive the final
2922      link; search for the section (usually .text) where the
2923      glink stubs now reside.  */
2924   glink = bfd_sections_find_if (abfd, section_covers_vma, &glink_vma);
2925   if (glink == NULL)
2926     return 0;
2927
2928   /* Determine glink PLT resolver by reading the relative branch
2929      from the first glink stub.  */
2930   if (bfd_get_section_contents (abfd, glink, buf,
2931                                 glink_vma - glink->vma, 4))
2932     {
2933       unsigned int insn = bfd_get_32 (abfd, buf);
2934
2935       /* The first glink stub may either branch to the resolver ...  */
2936       insn ^= B;
2937       if ((insn & ~0x3fffffc) == 0)
2938         resolv_vma = glink_vma + (insn ^ 0x2000000) - 0x2000000;
2939
2940       /* ... or fall through a bunch of NOPs.  */
2941       else if ((insn ^ B ^ NOP) == 0)
2942         for (i = 4;
2943              bfd_get_section_contents (abfd, glink, buf,
2944                                        glink_vma - glink->vma + i, 4);
2945              i += 4)
2946           if (bfd_get_32 (abfd, buf) != NOP)
2947             {
2948               resolv_vma = glink_vma + i;
2949               break;
2950             }
2951     }
2952
2953   count = relplt->size / sizeof (Elf32_External_Rela);
2954   /* If the stubs are those for -shared/-pie then we might have
2955      multiple stubs for each plt entry.  If that is the case then
2956      there is no way to associate stubs with their plt entries short
2957      of figuring out the GOT pointer value used in the stub.  */
2958   if (!is_nonpic_glink_stub (abfd, glink,
2959                              glink_vma - GLINK_ENTRY_SIZE - glink->vma))
2960     return 0;
2961
2962   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2963   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
2964     return -1;
2965
2966   size = count * sizeof (asymbol);
2967   p = relplt->relocation;
2968   for (i = 0; i < count; i++, p++)
2969     {
2970       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2971       if (p->addend != 0)
2972         size += sizeof ("+0x") - 1 + 8;
2973     }
2974
2975   size += sizeof (asymbol) + sizeof ("__glink");
2976
2977   if (resolv_vma)
2978     size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
2979
2980   s = *ret = bfd_malloc (size);
2981   if (s == NULL)
2982     return -1;
2983
2984   stub_vma = glink_vma;
2985   names = (char *) (s + count + 1 + (resolv_vma != 0));
2986   p = relplt->relocation + count - 1;
2987   for (i = 0; i < count; i++)
2988     {
2989       size_t len;
2990
2991       *s = **p->sym_ptr_ptr;
2992       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
2993          we are defining a symbol, ensure one of them is set.  */
2994       if ((s->flags & BSF_LOCAL) == 0)
2995         s->flags |= BSF_GLOBAL;
2996       s->flags |= BSF_SYNTHETIC;
2997       s->section = glink;
2998       stub_vma -= 16;
2999       if (strcmp ((*p->sym_ptr_ptr)->name, "__tls_get_addr_opt") == 0)
3000         stub_vma -= 32;
3001       s->value = stub_vma - glink->vma;
3002       s->name = names;
3003       s->udata.p = NULL;
3004       len = strlen ((*p->sym_ptr_ptr)->name);
3005       memcpy (names, (*p->sym_ptr_ptr)->name, len);
3006       names += len;
3007       if (p->addend != 0)
3008         {
3009           memcpy (names, "+0x", sizeof ("+0x") - 1);
3010           names += sizeof ("+0x") - 1;
3011           bfd_sprintf_vma (abfd, names, p->addend);
3012           names += strlen (names);
3013         }
3014       memcpy (names, "@plt", sizeof ("@plt"));
3015       names += sizeof ("@plt");
3016       ++s;
3017       --p;
3018     }
3019
3020   /* Add a symbol at the start of the glink branch table.  */
3021   memset (s, 0, sizeof *s);
3022   s->the_bfd = abfd;
3023   s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3024   s->section = glink;
3025   s->value = glink_vma - glink->vma;
3026   s->name = names;
3027   memcpy (names, "__glink", sizeof ("__glink"));
3028   names += sizeof ("__glink");
3029   s++;
3030   count++;
3031
3032   if (resolv_vma)
3033     {
3034       /* Add a symbol for the glink PLT resolver.  */
3035       memset (s, 0, sizeof *s);
3036       s->the_bfd = abfd;
3037       s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3038       s->section = glink;
3039       s->value = resolv_vma - glink->vma;
3040       s->name = names;
3041       memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3042       names += sizeof ("__glink_PLTresolve");
3043       s++;
3044       count++;
3045     }
3046
3047   return count;
3048 }
3049 \f
3050 /* The following functions are specific to the ELF linker, while
3051    functions above are used generally.  They appear in this file more
3052    or less in the order in which they are called.  eg.
3053    ppc_elf_check_relocs is called early in the link process,
3054    ppc_elf_finish_dynamic_sections is one of the last functions
3055    called.  */
3056
3057 /* Track PLT entries needed for a given symbol.  We might need more
3058    than one glink entry per symbol when generating a pic binary.  */
3059 struct plt_entry
3060 {
3061   struct plt_entry *next;
3062
3063   /* -fPIC uses multiple GOT sections, one per file, called ".got2".
3064      This field stores the offset into .got2 used to initialise the
3065      GOT pointer reg.  It will always be at least 32768.  (Current
3066      gcc always uses an offset of 32768, but ld -r will pack .got2
3067      sections together resulting in larger offsets).  */
3068   bfd_vma addend;
3069
3070   /* The .got2 section.  */
3071   asection *sec;
3072
3073   /* PLT refcount or offset.  */
3074   union
3075     {
3076       bfd_signed_vma refcount;
3077       bfd_vma offset;
3078     } plt;
3079
3080   /* .glink stub offset.  */
3081   bfd_vma glink_offset;
3082 };
3083
3084 /* Of those relocs that might be copied as dynamic relocs, this function
3085    selects those that must be copied when linking a shared library,
3086    even when the symbol is local.  */
3087
3088 static int
3089 must_be_dyn_reloc (struct bfd_link_info *info,
3090                    enum elf_ppc_reloc_type r_type)
3091 {
3092   switch (r_type)
3093     {
3094     default:
3095       return 1;
3096
3097     case R_PPC_REL24:
3098     case R_PPC_REL14:
3099     case R_PPC_REL14_BRTAKEN:
3100     case R_PPC_REL14_BRNTAKEN:
3101     case R_PPC_REL32:
3102       return 0;
3103
3104     case R_PPC_TPREL32:
3105     case R_PPC_TPREL16:
3106     case R_PPC_TPREL16_LO:
3107     case R_PPC_TPREL16_HI:
3108     case R_PPC_TPREL16_HA:
3109       return !bfd_link_executable (info);
3110     }
3111 }
3112
3113 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3114    copying dynamic variables from a shared lib into an app's dynbss
3115    section, and instead use a dynamic relocation to point into the
3116    shared lib.  */
3117 #define ELIMINATE_COPY_RELOCS 1
3118
3119 /* Used to track dynamic relocations for local symbols.  */
3120 struct ppc_dyn_relocs
3121 {
3122   struct ppc_dyn_relocs *next;
3123
3124   /* The input section of the reloc.  */
3125   asection *sec;
3126
3127   /* Total number of relocs copied for the input section.  */
3128   unsigned int count : 31;
3129
3130   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3131   unsigned int ifunc : 1;
3132 };
3133
3134 /* PPC ELF linker hash entry.  */
3135
3136 struct ppc_elf_link_hash_entry
3137 {
3138   struct elf_link_hash_entry elf;
3139
3140   /* If this symbol is used in the linker created sections, the processor
3141      specific backend uses this field to map the field into the offset
3142      from the beginning of the section.  */
3143   elf_linker_section_pointers_t *linker_section_pointer;
3144
3145   /* Track dynamic relocs copied for this symbol.  */
3146   struct elf_dyn_relocs *dyn_relocs;
3147
3148   /* Contexts in which symbol is used in the GOT (or TOC).
3149      TLS_GD .. TLS_TLS bits are or'd into the mask as the
3150      corresponding relocs are encountered during check_relocs.
3151      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3152      indicate the corresponding GOT entry type is not needed.  */
3153 #define TLS_GD           1      /* GD reloc. */
3154 #define TLS_LD           2      /* LD reloc. */
3155 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3156 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3157 #define TLS_TLS         16      /* Any TLS reloc.  */
3158 #define TLS_TPRELGD     32      /* TPREL reloc resulting from GD->IE. */
3159 #define PLT_IFUNC       64      /* STT_GNU_IFUNC.  */
3160   char tls_mask;
3161
3162   /* Nonzero if we have seen a small data relocation referring to this
3163      symbol.  */
3164   unsigned char has_sda_refs : 1;
3165
3166   /* Flag use of given relocations.  */
3167   unsigned char has_addr16_ha : 1;
3168   unsigned char has_addr16_lo : 1;
3169 };
3170
3171 #define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent))
3172
3173 /* PPC ELF linker hash table.  */
3174
3175 struct ppc_elf_link_hash_table
3176 {
3177   struct elf_link_hash_table elf;
3178
3179   /* Various options passed from the linker.  */
3180   struct ppc_elf_params *params;
3181
3182   /* Short-cuts to get to dynamic linker sections.  */
3183   asection *got;
3184   asection *relgot;
3185   asection *glink;
3186   asection *plt;
3187   asection *relplt;
3188   asection *iplt;
3189   asection *reliplt;
3190   asection *dynbss;
3191   asection *relbss;
3192   asection *dynsbss;
3193   asection *relsbss;
3194   elf_linker_section_t sdata[2];
3195   asection *sbss;
3196   asection *glink_eh_frame;
3197
3198   /* The (unloaded but important) .rela.plt.unloaded on VxWorks.  */
3199   asection *srelplt2;
3200
3201   /* The .got.plt section (VxWorks only)*/
3202   asection *sgotplt;
3203
3204   /* Shortcut to __tls_get_addr.  */
3205   struct elf_link_hash_entry *tls_get_addr;
3206
3207   /* The bfd that forced an old-style PLT.  */
3208   bfd *old_bfd;
3209
3210   /* TLS local dynamic got entry handling.  */
3211   union {
3212     bfd_signed_vma refcount;
3213     bfd_vma offset;
3214   } tlsld_got;
3215
3216   /* Offset of branch table to PltResolve function in glink.  */
3217   bfd_vma glink_pltresolve;
3218
3219   /* Size of reserved GOT entries.  */
3220   unsigned int got_header_size;
3221   /* Non-zero if allocating the header left a gap.  */
3222   unsigned int got_gap;
3223
3224   /* The type of PLT we have chosen to use.  */
3225   enum ppc_elf_plt_type plt_type;
3226
3227   /* True if the target system is VxWorks.  */
3228   unsigned int is_vxworks:1;
3229
3230   /* The size of PLT entries.  */
3231   int plt_entry_size;
3232   /* The distance between adjacent PLT slots.  */
3233   int plt_slot_size;
3234   /* The size of the first PLT entry.  */
3235   int plt_initial_entry_size;
3236
3237   /* Small local sym cache.  */
3238   struct sym_cache sym_cache;
3239 };
3240
3241 /* Rename some of the generic section flags to better document how they
3242    are used for ppc32.  The flags are only valid for ppc32 elf objects.  */
3243
3244 /* Nonzero if this section has TLS related relocations.  */
3245 #define has_tls_reloc sec_flg0
3246
3247 /* Nonzero if this section has a call to __tls_get_addr.  */
3248 #define has_tls_get_addr_call sec_flg1
3249
3250 /* Get the PPC ELF linker hash table from a link_info structure.  */
3251
3252 #define ppc_elf_hash_table(p) \
3253   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3254   == PPC32_ELF_DATA ? ((struct ppc_elf_link_hash_table *) ((p)->hash)) : NULL)
3255
3256 /* Create an entry in a PPC ELF linker hash table.  */
3257
3258 static struct bfd_hash_entry *
3259 ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3260                            struct bfd_hash_table *table,
3261                            const char *string)
3262 {
3263   /* Allocate the structure if it has not already been allocated by a
3264      subclass.  */
3265   if (entry == NULL)
3266     {
3267       entry = bfd_hash_allocate (table,
3268                                  sizeof (struct ppc_elf_link_hash_entry));
3269       if (entry == NULL)
3270         return entry;
3271     }
3272
3273   /* Call the allocation method of the superclass.  */
3274   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3275   if (entry != NULL)
3276     {
3277       ppc_elf_hash_entry (entry)->linker_section_pointer = NULL;
3278       ppc_elf_hash_entry (entry)->dyn_relocs = NULL;
3279       ppc_elf_hash_entry (entry)->tls_mask = 0;
3280       ppc_elf_hash_entry (entry)->has_sda_refs = 0;
3281     }
3282
3283   return entry;
3284 }
3285
3286 /* Create a PPC ELF linker hash table.  */
3287
3288 static struct bfd_link_hash_table *
3289 ppc_elf_link_hash_table_create (bfd *abfd)
3290 {
3291   struct ppc_elf_link_hash_table *ret;
3292   static struct ppc_elf_params default_params = { PLT_OLD, 0, 1, 0, 0, 12, 0 };
3293
3294   ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table));
3295   if (ret == NULL)
3296     return NULL;
3297
3298   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
3299                                       ppc_elf_link_hash_newfunc,
3300                                       sizeof (struct ppc_elf_link_hash_entry),
3301                                       PPC32_ELF_DATA))
3302     {
3303       free (ret);
3304       return NULL;
3305     }
3306
3307   ret->elf.init_plt_refcount.refcount = 0;
3308   ret->elf.init_plt_refcount.glist = NULL;
3309   ret->elf.init_plt_offset.offset = 0;
3310   ret->elf.init_plt_offset.glist = NULL;
3311
3312   ret->params = &default_params;
3313
3314   ret->sdata[0].name = ".sdata";
3315   ret->sdata[0].sym_name = "_SDA_BASE_";
3316   ret->sdata[0].bss_name = ".sbss";
3317
3318   ret->sdata[1].name = ".sdata2";
3319   ret->sdata[1].sym_name = "_SDA2_BASE_";
3320   ret->sdata[1].bss_name = ".sbss2";
3321
3322   ret->plt_entry_size = 12;
3323   ret->plt_slot_size = 8;
3324   ret->plt_initial_entry_size = 72;
3325
3326   return &ret->elf.root;
3327 }
3328
3329 /* Hook linker params into hash table.  */
3330
3331 void
3332 ppc_elf_link_params (struct bfd_link_info *info, struct ppc_elf_params *params)
3333 {
3334   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
3335
3336   if (htab)
3337     htab->params = params;
3338 }
3339
3340 /* Create .got and the related sections.  */
3341
3342 static bfd_boolean
3343 ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info)
3344 {
3345   struct ppc_elf_link_hash_table *htab;
3346   asection *s;
3347   flagword flags;
3348
3349   if (!_bfd_elf_create_got_section (abfd, info))
3350     return FALSE;
3351
3352   htab = ppc_elf_hash_table (info);
3353   htab->got = s = bfd_get_linker_section (abfd, ".got");
3354   if (s == NULL)
3355     abort ();
3356
3357   if (htab->is_vxworks)
3358     {
3359       htab->sgotplt = bfd_get_linker_section (abfd, ".got.plt");
3360       if (!htab->sgotplt)
3361         abort ();
3362     }
3363   else
3364     {
3365       /* The powerpc .got has a blrl instruction in it.  Mark it
3366          executable.  */
3367       flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS
3368                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3369       if (!bfd_set_section_flags (abfd, s, flags))
3370         return FALSE;
3371     }
3372
3373   htab->relgot = bfd_get_linker_section (abfd, ".rela.got");
3374   if (!htab->relgot)
3375     abort ();
3376
3377   return TRUE;
3378 }
3379
3380 /* Create a special linker section, used for R_PPC_EMB_SDAI16 and
3381    R_PPC_EMB_SDA2I16 pointers.  These sections become part of .sdata
3382    and .sdata2.  Create _SDA_BASE_ and _SDA2_BASE too.  */
3383
3384 static bfd_boolean
3385 ppc_elf_create_linker_section (bfd *abfd,
3386                                struct bfd_link_info *info,
3387                                flagword flags,
3388                                elf_linker_section_t *lsect)
3389 {
3390   asection *s;
3391
3392   flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3393             | SEC_LINKER_CREATED);
3394
3395   s = bfd_make_section_anyway_with_flags (abfd, lsect->name, flags);
3396   if (s == NULL)
3397     return FALSE;
3398   lsect->section = s;
3399
3400   /* Define the sym on the first section of this name.  */
3401   s = bfd_get_section_by_name (abfd, lsect->name);
3402
3403   lsect->sym = _bfd_elf_define_linkage_sym (abfd, info, s, lsect->sym_name);
3404   if (lsect->sym == NULL)
3405     return FALSE;
3406   lsect->sym->root.u.def.value = 0x8000;
3407   return TRUE;
3408 }
3409
3410 static bfd_boolean
3411 ppc_elf_create_glink (bfd *abfd, struct bfd_link_info *info)
3412 {
3413   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
3414   asection *s;
3415   flagword flags;
3416
3417   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS
3418            | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3419   s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags);
3420   htab->glink = s;
3421   if (s == NULL
3422       || !bfd_set_section_alignment (abfd, s,
3423                                      htab->params->ppc476_workaround ? 6 : 4))
3424     return FALSE;
3425
3426   if (!info->no_ld_generated_unwind_info)
3427     {
3428       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
3429                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3430       s = bfd_make_section_anyway_with_flags (abfd, ".eh_frame", flags);
3431       htab->glink_eh_frame = s;
3432       if (s == NULL
3433           || !bfd_set_section_alignment (abfd, s, 2))
3434         return FALSE;
3435     }
3436
3437   flags = SEC_ALLOC | SEC_LINKER_CREATED;
3438   s = bfd_make_section_anyway_with_flags (abfd, ".iplt", flags);
3439   htab->iplt = s;
3440   if (s == NULL
3441       || !bfd_set_section_alignment (abfd, s, 4))
3442     return FALSE;
3443
3444   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
3445            | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3446   s = bfd_make_section_anyway_with_flags (abfd, ".rela.iplt", flags);
3447   htab->reliplt = s;
3448   if (s == NULL
3449       || ! bfd_set_section_alignment (abfd, s, 2))
3450     return FALSE;
3451
3452   if (!ppc_elf_create_linker_section (abfd, info, 0,
3453                                       &htab->sdata[0]))
3454     return FALSE;
3455
3456   if (!ppc_elf_create_linker_section (abfd, info, SEC_READONLY,
3457                                       &htab->sdata[1]))
3458     return FALSE;
3459
3460   return TRUE;
3461 }
3462
3463 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
3464    to output sections (just like _bfd_elf_create_dynamic_sections has
3465    to create .dynbss and .rela.bss).  */
3466
3467 static bfd_boolean
3468 ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3469 {
3470   struct ppc_elf_link_hash_table *htab;
3471   asection *s;
3472   flagword flags;
3473
3474   htab = ppc_elf_hash_table (info);
3475
3476   if (htab->got == NULL
3477       && !ppc_elf_create_got (abfd, info))
3478     return FALSE;
3479
3480   if (!_bfd_elf_create_dynamic_sections (abfd, info))
3481     return FALSE;
3482
3483   if (htab->glink == NULL
3484       && !ppc_elf_create_glink (abfd, info))
3485     return FALSE;
3486
3487   htab->dynbss = bfd_get_linker_section (abfd, ".dynbss");
3488   s = bfd_make_section_anyway_with_flags (abfd, ".dynsbss",
3489                                           SEC_ALLOC | SEC_LINKER_CREATED);
3490   htab->dynsbss = s;
3491   if (s == NULL)
3492     return FALSE;
3493
3494   if (! bfd_link_pic (info))
3495     {
3496       htab->relbss = bfd_get_linker_section (abfd, ".rela.bss");
3497       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
3498                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3499       s = bfd_make_section_anyway_with_flags (abfd, ".rela.sbss", flags);
3500       htab->relsbss = s;
3501       if (s == NULL
3502           || ! bfd_set_section_alignment (abfd, s, 2))
3503         return FALSE;
3504     }
3505
3506   if (htab->is_vxworks
3507       && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
3508     return FALSE;
3509
3510   htab->relplt = bfd_get_linker_section (abfd, ".rela.plt");
3511   htab->plt = s = bfd_get_linker_section (abfd, ".plt");
3512   if (s == NULL)
3513     abort ();
3514
3515   flags = SEC_ALLOC | SEC_CODE | SEC_LINKER_CREATED;
3516   if (htab->plt_type == PLT_VXWORKS)
3517     /* The VxWorks PLT is a loaded section with contents.  */
3518     flags |= SEC_HAS_CONTENTS | SEC_LOAD | SEC_READONLY;
3519   return bfd_set_section_flags (abfd, s, flags);
3520 }
3521
3522 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3523
3524 static void
3525 ppc_elf_copy_indirect_symbol (struct bfd_link_info *info,
3526                               struct elf_link_hash_entry *dir,
3527                               struct elf_link_hash_entry *ind)
3528 {
3529   struct ppc_elf_link_hash_entry *edir, *eind;
3530
3531   edir = (struct ppc_elf_link_hash_entry *) dir;
3532   eind = (struct ppc_elf_link_hash_entry *) ind;
3533
3534   edir->tls_mask |= eind->tls_mask;
3535   edir->has_sda_refs |= eind->has_sda_refs;
3536
3537   /* If called to transfer flags for a weakdef during processing
3538      of elf_adjust_dynamic_symbol, don't copy non_got_ref.
3539      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
3540   if (!(ELIMINATE_COPY_RELOCS
3541         && eind->elf.root.type != bfd_link_hash_indirect
3542         && edir->elf.dynamic_adjusted))
3543     edir->elf.non_got_ref |= eind->elf.non_got_ref;
3544
3545   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3546   edir->elf.ref_regular |= eind->elf.ref_regular;
3547   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3548   edir->elf.needs_plt |= eind->elf.needs_plt;
3549   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
3550
3551   if (eind->dyn_relocs != NULL)
3552     {
3553       if (edir->dyn_relocs != NULL)
3554         {
3555           struct elf_dyn_relocs **pp;
3556           struct elf_dyn_relocs *p;
3557
3558           /* Add reloc counts against the indirect sym to the direct sym
3559              list.  Merge any entries against the same section.  */
3560           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3561             {
3562               struct elf_dyn_relocs *q;
3563
3564               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3565                 if (q->sec == p->sec)
3566                   {
3567                     q->pc_count += p->pc_count;
3568                     q->count += p->count;
3569                     *pp = p->next;
3570                     break;
3571                   }
3572               if (q == NULL)
3573                 pp = &p->next;
3574             }
3575           *pp = edir->dyn_relocs;
3576         }
3577
3578       edir->dyn_relocs = eind->dyn_relocs;
3579       eind->dyn_relocs = NULL;
3580     }
3581
3582   /* If we were called to copy over info for a weak sym, that's all.
3583      You might think dyn_relocs need not be copied over;  After all,
3584      both syms will be dynamic or both non-dynamic so we're just
3585      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
3586      code in ppc_elf_adjust_dynamic_symbol needs to check for
3587      dyn_relocs in read-only sections, and it does so on what is the
3588      DIR sym here.  */
3589   if (eind->elf.root.type != bfd_link_hash_indirect)
3590     return;
3591
3592   /* Copy over the GOT refcount entries that we may have already seen to
3593      the symbol which just became indirect.  */
3594   edir->elf.got.refcount += eind->elf.got.refcount;
3595   eind->elf.got.refcount = 0;
3596
3597   /* And plt entries.  */
3598   if (eind->elf.plt.plist != NULL)
3599     {
3600       if (edir->elf.plt.plist != NULL)
3601         {
3602           struct plt_entry **entp;
3603           struct plt_entry *ent;
3604
3605           for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; )
3606             {
3607               struct plt_entry *dent;
3608
3609               for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next)
3610                 if (dent->sec == ent->sec && dent->addend == ent->addend)
3611                   {
3612                     dent->plt.refcount += ent->plt.refcount;
3613                     *entp = ent->next;
3614                     break;
3615                   }
3616               if (dent == NULL)
3617                 entp = &ent->next;
3618             }
3619           *entp = edir->elf.plt.plist;
3620         }
3621
3622       edir->elf.plt.plist = eind->elf.plt.plist;
3623       eind->elf.plt.plist = NULL;
3624     }
3625
3626   if (eind->elf.dynindx != -1)
3627     {
3628       if (edir->elf.dynindx != -1)
3629         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3630                                 edir->elf.dynstr_index);
3631       edir->elf.dynindx = eind->elf.dynindx;
3632       edir->elf.dynstr_index = eind->elf.dynstr_index;
3633       eind->elf.dynindx = -1;
3634       eind->elf.dynstr_index = 0;
3635     }
3636 }
3637
3638 /* Hook called by the linker routine which adds symbols from an object
3639    file.  We use it to put .comm items in .sbss, and not .bss.  */
3640
3641 static bfd_boolean
3642 ppc_elf_add_symbol_hook (bfd *abfd,
3643                          struct bfd_link_info *info,
3644                          Elf_Internal_Sym *sym,
3645                          const char **namep ATTRIBUTE_UNUSED,
3646                          flagword *flagsp ATTRIBUTE_UNUSED,
3647                          asection **secp,
3648                          bfd_vma *valp)
3649 {
3650   if (sym->st_shndx == SHN_COMMON
3651       && !bfd_link_relocatable (info)
3652       && is_ppc_elf (info->output_bfd)
3653       && sym->st_size <= elf_gp_size (abfd))
3654     {
3655       /* Common symbols less than or equal to -G nn bytes are automatically
3656          put into .sbss.  */
3657       struct ppc_elf_link_hash_table *htab;
3658
3659       htab = ppc_elf_hash_table (info);
3660       if (htab->sbss == NULL)
3661         {
3662           flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
3663
3664           if (!htab->elf.dynobj)
3665             htab->elf.dynobj = abfd;
3666
3667           htab->sbss = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
3668                                                            ".sbss",
3669                                                            flags);
3670           if (htab->sbss == NULL)
3671             return FALSE;
3672         }
3673
3674       *secp = htab->sbss;
3675       *valp = sym->st_size;
3676     }
3677
3678   if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
3679        || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
3680       && (abfd->flags & DYNAMIC) == 0
3681       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
3682     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
3683
3684   return TRUE;
3685 }
3686 \f
3687 /* Find a linker generated pointer with a given addend and type.  */
3688
3689 static elf_linker_section_pointers_t *
3690 elf_find_pointer_linker_section
3691   (elf_linker_section_pointers_t *linker_pointers,
3692    bfd_vma addend,
3693    elf_linker_section_t *lsect)
3694 {
3695   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
3696     if (lsect == linker_pointers->lsect && addend == linker_pointers->addend)
3697       return linker_pointers;
3698
3699   return NULL;
3700 }
3701
3702 /* Allocate a pointer to live in a linker created section.  */
3703
3704 static bfd_boolean
3705 elf_allocate_pointer_linker_section (bfd *abfd,
3706                                      elf_linker_section_t *lsect,
3707                                      struct elf_link_hash_entry *h,
3708                                      const Elf_Internal_Rela *rel)
3709 {
3710   elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
3711   elf_linker_section_pointers_t *linker_section_ptr;
3712   unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
3713   bfd_size_type amt;
3714
3715   BFD_ASSERT (lsect != NULL);
3716
3717   /* Is this a global symbol?  */
3718   if (h != NULL)
3719     {
3720       struct ppc_elf_link_hash_entry *eh;
3721
3722       /* Has this symbol already been allocated?  If so, our work is done.  */
3723       eh = (struct ppc_elf_link_hash_entry *) h;
3724       if (elf_find_pointer_linker_section (eh->linker_section_pointer,
3725                                            rel->r_addend,
3726                                            lsect))
3727         return TRUE;
3728
3729       ptr_linker_section_ptr = &eh->linker_section_pointer;
3730     }
3731   else
3732     {
3733       BFD_ASSERT (is_ppc_elf (abfd));
3734
3735       /* Allocation of a pointer to a local symbol.  */
3736       elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
3737
3738       /* Allocate a table to hold the local symbols if first time.  */
3739       if (!ptr)
3740         {
3741           unsigned int num_symbols = elf_symtab_hdr (abfd).sh_info;
3742
3743           amt = num_symbols;
3744           amt *= sizeof (elf_linker_section_pointers_t *);
3745           ptr = bfd_zalloc (abfd, amt);
3746
3747           if (!ptr)
3748             return FALSE;
3749
3750           elf_local_ptr_offsets (abfd) = ptr;
3751         }
3752
3753       /* Has this symbol already been allocated?  If so, our work is done.  */
3754       if (elf_find_pointer_linker_section (ptr[r_symndx],
3755                                            rel->r_addend,
3756                                            lsect))
3757         return TRUE;
3758
3759       ptr_linker_section_ptr = &ptr[r_symndx];
3760     }
3761
3762   /* Allocate space for a pointer in the linker section, and allocate
3763      a new pointer record from internal memory.  */
3764   BFD_ASSERT (ptr_linker_section_ptr != NULL);
3765   amt = sizeof (elf_linker_section_pointers_t);
3766   linker_section_ptr = bfd_alloc (abfd, amt);
3767
3768   if (!linker_section_ptr)
3769     return FALSE;
3770
3771   linker_section_ptr->next = *ptr_linker_section_ptr;
3772   linker_section_ptr->addend = rel->r_addend;
3773   linker_section_ptr->lsect = lsect;
3774   *ptr_linker_section_ptr = linker_section_ptr;
3775
3776   if (!bfd_set_section_alignment (lsect->section->owner, lsect->section, 2))
3777     return FALSE;
3778   linker_section_ptr->offset = lsect->section->size;
3779   lsect->section->size += 4;
3780
3781 #ifdef DEBUG
3782   fprintf (stderr,
3783            "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3784            lsect->name, (long) linker_section_ptr->offset,
3785            (long) lsect->section->size);
3786 #endif
3787
3788   return TRUE;
3789 }
3790
3791 static struct plt_entry **
3792 update_local_sym_info (bfd *abfd,
3793                        Elf_Internal_Shdr *symtab_hdr,
3794                        unsigned long r_symndx,
3795                        int tls_type)
3796 {
3797   bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
3798   struct plt_entry **local_plt;
3799   char *local_got_tls_masks;
3800
3801   if (local_got_refcounts == NULL)
3802     {
3803       bfd_size_type size = symtab_hdr->sh_info;
3804
3805       size *= (sizeof (*local_got_refcounts)
3806                + sizeof (*local_plt)
3807                + sizeof (*local_got_tls_masks));
3808       local_got_refcounts = bfd_zalloc (abfd, size);
3809       if (local_got_refcounts == NULL)
3810         return NULL;
3811       elf_local_got_refcounts (abfd) = local_got_refcounts;
3812     }
3813
3814   local_plt = (struct plt_entry **) (local_got_refcounts + symtab_hdr->sh_info);
3815   local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
3816   local_got_tls_masks[r_symndx] |= tls_type;
3817   if (tls_type != PLT_IFUNC)
3818     local_got_refcounts[r_symndx] += 1;
3819   return local_plt + r_symndx;
3820 }
3821
3822 static bfd_boolean
3823 update_plt_info (bfd *abfd, struct plt_entry **plist,
3824                  asection *sec, bfd_vma addend)
3825 {
3826   struct plt_entry *ent;
3827
3828   if (addend < 32768)
3829     sec = NULL;
3830   for (ent = *plist; ent != NULL; ent = ent->next)
3831     if (ent->sec == sec && ent->addend == addend)
3832       break;
3833   if (ent == NULL)
3834     {
3835       bfd_size_type amt = sizeof (*ent);
3836       ent = bfd_alloc (abfd, amt);
3837       if (ent == NULL)
3838         return FALSE;
3839       ent->next = *plist;
3840       ent->sec = sec;
3841       ent->addend = addend;
3842       ent->plt.refcount = 0;
3843       *plist = ent;
3844     }
3845   ent->plt.refcount += 1;
3846   return TRUE;
3847 }
3848
3849 static struct plt_entry *
3850 find_plt_ent (struct plt_entry **plist, asection *sec, bfd_vma addend)
3851 {
3852   struct plt_entry *ent;
3853
3854   if (addend < 32768)
3855     sec = NULL;
3856   for (ent = *plist; ent != NULL; ent = ent->next)
3857     if (ent->sec == sec && ent->addend == addend)
3858       break;
3859   return ent;
3860 }
3861
3862 static bfd_boolean
3863 is_branch_reloc (enum elf_ppc_reloc_type r_type)
3864 {
3865   return (r_type == R_PPC_PLTREL24
3866           || r_type == R_PPC_LOCAL24PC
3867           || r_type == R_PPC_REL24
3868           || r_type == R_PPC_REL14
3869           || r_type == R_PPC_REL14_BRTAKEN
3870           || r_type == R_PPC_REL14_BRNTAKEN
3871           || r_type == R_PPC_ADDR24
3872           || r_type == R_PPC_ADDR14
3873           || r_type == R_PPC_ADDR14_BRTAKEN
3874           || r_type == R_PPC_ADDR14_BRNTAKEN);
3875 }
3876
3877 static void
3878 bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
3879 {
3880   (*_bfd_error_handler)
3881     (_("%B: relocation %s cannot be used when making a shared object"),
3882      abfd,
3883      ppc_elf_howto_table[r_type]->name);
3884   bfd_set_error (bfd_error_bad_value);
3885 }
3886
3887 /* Look through the relocs for a section during the first phase, and
3888    allocate space in the global offset table or procedure linkage
3889    table.  */
3890
3891 static bfd_boolean
3892 ppc_elf_check_relocs (bfd *abfd,
3893                       struct bfd_link_info *info,
3894                       asection *sec,
3895                       const Elf_Internal_Rela *relocs)
3896 {
3897   struct ppc_elf_link_hash_table *htab;
3898   Elf_Internal_Shdr *symtab_hdr;
3899   struct elf_link_hash_entry **sym_hashes;
3900   const Elf_Internal_Rela *rel;
3901   const Elf_Internal_Rela *rel_end;
3902   asection *got2, *sreloc;
3903   struct elf_link_hash_entry *tga;
3904
3905   if (bfd_link_relocatable (info))
3906     return TRUE;
3907
3908   /* Don't do anything special with non-loaded, non-alloced sections.
3909      In particular, any relocs in such sections should not affect GOT
3910      and PLT reference counting (ie. we don't allow them to create GOT
3911      or PLT entries), there's no possibility or desire to optimize TLS
3912      relocs, and there's not much point in propagating relocs to shared
3913      libs that the dynamic linker won't relocate.  */
3914   if ((sec->flags & SEC_ALLOC) == 0)
3915     return TRUE;
3916
3917 #ifdef DEBUG
3918   _bfd_error_handler ("ppc_elf_check_relocs called for section %A in %B",
3919                       sec, abfd);
3920 #endif
3921
3922   BFD_ASSERT (is_ppc_elf (abfd));
3923
3924   /* Initialize howto table if not already done.  */
3925   if (!ppc_elf_howto_table[R_PPC_ADDR32])
3926     ppc_elf_howto_init ();
3927
3928   htab = ppc_elf_hash_table (info);
3929   if (htab->glink == NULL)
3930     {
3931       if (htab->elf.dynobj == NULL)
3932         htab->elf.dynobj = abfd;
3933       if (!ppc_elf_create_glink (htab->elf.dynobj, info))
3934         return FALSE;
3935     }
3936   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
3937                               FALSE, FALSE, TRUE);
3938   symtab_hdr = &elf_symtab_hdr (abfd);
3939   sym_hashes = elf_sym_hashes (abfd);
3940   got2 = bfd_get_section_by_name (abfd, ".got2");
3941   sreloc = NULL;
3942
3943   rel_end = relocs + sec->reloc_count;
3944   for (rel = relocs; rel < rel_end; rel++)
3945     {
3946       unsigned long r_symndx;
3947       enum elf_ppc_reloc_type r_type;
3948       struct elf_link_hash_entry *h;
3949       int tls_type;
3950       struct plt_entry **ifunc;
3951
3952       r_symndx = ELF32_R_SYM (rel->r_info);
3953       if (r_symndx < symtab_hdr->sh_info)
3954         h = NULL;
3955       else
3956         {
3957           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3958           while (h->root.type == bfd_link_hash_indirect
3959                  || h->root.type == bfd_link_hash_warning)
3960             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3961
3962           /* PR15323, ref flags aren't set for references in the same
3963              object.  */
3964           h->root.non_ir_ref = 1;
3965         }
3966
3967       /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
3968          This shows up in particular in an R_PPC_ADDR32 in the eabi
3969          startup code.  */
3970       if (h != NULL
3971           && htab->got == NULL
3972           && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3973         {
3974           if (htab->elf.dynobj == NULL)
3975             htab->elf.dynobj = abfd;
3976           if (!ppc_elf_create_got (htab->elf.dynobj, info))
3977             return FALSE;
3978           BFD_ASSERT (h == htab->elf.hgot);
3979         }
3980
3981       tls_type = 0;
3982       r_type = ELF32_R_TYPE (rel->r_info);
3983       ifunc = NULL;
3984       if (h == NULL && !htab->is_vxworks)
3985         {
3986           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3987                                                           abfd, r_symndx);
3988           if (isym == NULL)
3989             return FALSE;
3990
3991           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3992             {
3993               /* Set PLT_IFUNC flag for this sym, no GOT entry yet.  */
3994               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
3995                                              PLT_IFUNC);
3996               if (ifunc == NULL)
3997                 return FALSE;
3998
3999               /* STT_GNU_IFUNC symbols must have a PLT entry;
4000                  In a non-pie executable even when there are
4001                  no plt calls.  */
4002               if (!bfd_link_pic (info)
4003                   || is_branch_reloc (r_type))
4004                 {
4005                   bfd_vma addend = 0;
4006                   if (r_type == R_PPC_PLTREL24)
4007                     {
4008                       ppc_elf_tdata (abfd)->makes_plt_call = 1;
4009                       if (bfd_link_pic (info))
4010                         addend = rel->r_addend;
4011                     }
4012                   if (!update_plt_info (abfd, ifunc, got2, addend))
4013                     return FALSE;
4014                 }
4015             }
4016         }
4017
4018       if (!htab->is_vxworks
4019           && is_branch_reloc (r_type)
4020           && h != NULL
4021           && h == tga)
4022         {
4023           if (rel != relocs
4024               && (ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSGD
4025                   || ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSLD))
4026             /* We have a new-style __tls_get_addr call with a marker
4027                reloc.  */
4028             ;
4029           else
4030             /* Mark this section as having an old-style call.  */
4031             sec->has_tls_get_addr_call = 1;
4032         }
4033
4034       switch (r_type)
4035         {
4036         case R_PPC_TLSGD:
4037         case R_PPC_TLSLD:
4038           /* These special tls relocs tie a call to __tls_get_addr with
4039              its parameter symbol.  */
4040           break;
4041
4042         case R_PPC_GOT_TLSLD16:
4043         case R_PPC_GOT_TLSLD16_LO:
4044         case R_PPC_GOT_TLSLD16_HI:
4045         case R_PPC_GOT_TLSLD16_HA:
4046           tls_type = TLS_TLS | TLS_LD;
4047           goto dogottls;
4048
4049         case R_PPC_GOT_TLSGD16:
4050         case R_PPC_GOT_TLSGD16_LO:
4051         case R_PPC_GOT_TLSGD16_HI:
4052         case R_PPC_GOT_TLSGD16_HA:
4053           tls_type = TLS_TLS | TLS_GD;
4054           goto dogottls;
4055
4056         case R_PPC_GOT_TPREL16:
4057         case R_PPC_GOT_TPREL16_LO:
4058         case R_PPC_GOT_TPREL16_HI:
4059         case R_PPC_GOT_TPREL16_HA:
4060           if (bfd_link_pic (info))
4061             info->flags |= DF_STATIC_TLS;
4062           tls_type = TLS_TLS | TLS_TPREL;
4063           goto dogottls;
4064
4065         case R_PPC_GOT_DTPREL16:
4066         case R_PPC_GOT_DTPREL16_LO:
4067         case R_PPC_GOT_DTPREL16_HI:
4068         case R_PPC_GOT_DTPREL16_HA:
4069           tls_type = TLS_TLS | TLS_DTPREL;
4070         dogottls:
4071           sec->has_tls_reloc = 1;
4072           /* Fall thru */
4073
4074           /* GOT16 relocations */
4075         case R_PPC_GOT16:
4076         case R_PPC_GOT16_LO:
4077         case R_PPC_GOT16_HI:
4078         case R_PPC_GOT16_HA:
4079           /* This symbol requires a global offset table entry.  */
4080           if (htab->got == NULL)
4081             {
4082               if (htab->elf.dynobj == NULL)
4083                 htab->elf.dynobj = abfd;
4084               if (!ppc_elf_create_got (htab->elf.dynobj, info))
4085                 return FALSE;
4086             }
4087           if (h != NULL)
4088             {
4089               h->got.refcount += 1;
4090               ppc_elf_hash_entry (h)->tls_mask |= tls_type;
4091             }
4092           else
4093             /* This is a global offset table entry for a local symbol.  */
4094             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
4095               return FALSE;
4096
4097           /* We may also need a plt entry if the symbol turns out to be
4098              an ifunc.  */
4099           if (h != NULL && !bfd_link_pic (info))
4100             {
4101               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4102                 return FALSE;
4103             }
4104           break;
4105
4106           /* Indirect .sdata relocation.  */
4107         case R_PPC_EMB_SDAI16:
4108           if (bfd_link_pic (info))
4109             {
4110               bad_shared_reloc (abfd, r_type);
4111               return FALSE;
4112             }
4113           htab->sdata[0].sym->ref_regular = 1;
4114           if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[0],
4115                                                     h, rel))
4116             return FALSE;
4117           if (h != NULL)
4118             {
4119               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4120               h->non_got_ref = TRUE;
4121             }
4122           break;
4123
4124           /* Indirect .sdata2 relocation.  */
4125         case R_PPC_EMB_SDA2I16:
4126           if (bfd_link_pic (info))
4127             {
4128               bad_shared_reloc (abfd, r_type);
4129               return FALSE;
4130             }
4131           htab->sdata[1].sym->ref_regular = 1;
4132           if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[1],
4133                                                     h, rel))
4134             return FALSE;
4135           if (h != NULL)
4136             {
4137               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4138               h->non_got_ref = TRUE;
4139             }
4140           break;
4141
4142         case R_PPC_SDAREL16:
4143           htab->sdata[0].sym->ref_regular = 1;
4144           /* Fall thru */
4145
4146         case R_PPC_VLE_SDAREL_LO16A:
4147         case R_PPC_VLE_SDAREL_LO16D:
4148         case R_PPC_VLE_SDAREL_HI16A:
4149         case R_PPC_VLE_SDAREL_HI16D:
4150         case R_PPC_VLE_SDAREL_HA16A:
4151         case R_PPC_VLE_SDAREL_HA16D:
4152           if (h != NULL)
4153             {
4154               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4155               h->non_got_ref = TRUE;
4156             }
4157           break;
4158
4159         case R_PPC_VLE_REL8:
4160         case R_PPC_VLE_REL15:
4161         case R_PPC_VLE_REL24:
4162         case R_PPC_VLE_LO16A:
4163         case R_PPC_VLE_LO16D:
4164         case R_PPC_VLE_HI16A:
4165         case R_PPC_VLE_HI16D:
4166         case R_PPC_VLE_HA16A:
4167         case R_PPC_VLE_HA16D:
4168           break;
4169
4170         case R_PPC_EMB_SDA2REL:
4171           if (bfd_link_pic (info))
4172             {
4173               bad_shared_reloc (abfd, r_type);
4174               return FALSE;
4175             }
4176           htab->sdata[1].sym->ref_regular = 1;
4177           if (h != NULL)
4178             {
4179               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4180               h->non_got_ref = TRUE;
4181             }
4182           break;
4183
4184         case R_PPC_VLE_SDA21_LO:
4185         case R_PPC_VLE_SDA21:
4186         case R_PPC_EMB_SDA21:
4187         case R_PPC_EMB_RELSDA:
4188           if (bfd_link_pic (info))
4189             {
4190               bad_shared_reloc (abfd, r_type);
4191               return FALSE;
4192             }
4193           if (h != NULL)
4194             {
4195               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4196               h->non_got_ref = TRUE;
4197             }
4198           break;
4199
4200         case R_PPC_EMB_NADDR32:
4201         case R_PPC_EMB_NADDR16:
4202         case R_PPC_EMB_NADDR16_LO:
4203         case R_PPC_EMB_NADDR16_HI:
4204         case R_PPC_EMB_NADDR16_HA:
4205           if (bfd_link_pic (info))
4206             {
4207               bad_shared_reloc (abfd, r_type);
4208               return FALSE;
4209             }
4210           if (h != NULL)
4211             h->non_got_ref = TRUE;
4212           break;
4213
4214         case R_PPC_PLTREL24:
4215           if (h == NULL)
4216             break;
4217           /* Fall through */
4218         case R_PPC_PLT32:
4219         case R_PPC_PLTREL32:
4220         case R_PPC_PLT16_LO:
4221         case R_PPC_PLT16_HI:
4222         case R_PPC_PLT16_HA:
4223 #ifdef DEBUG
4224           fprintf (stderr, "Reloc requires a PLT entry\n");
4225 #endif
4226           /* This symbol requires a procedure linkage table entry.  */
4227           if (h == NULL)
4228             {
4229               if (ifunc == NULL)
4230                 {
4231                   /* It does not make sense to have a procedure linkage
4232                      table entry for a non-ifunc local symbol.  */
4233                   info->callbacks->einfo
4234                     (_("%P: %H: %s reloc against local symbol\n"),
4235                      abfd, sec, rel->r_offset,
4236                      ppc_elf_howto_table[r_type]->name);
4237                   bfd_set_error (bfd_error_bad_value);
4238                   return FALSE;
4239                 }
4240             }
4241           else
4242             {
4243               bfd_vma addend = 0;
4244
4245               if (r_type == R_PPC_PLTREL24)
4246                 {
4247                   ppc_elf_tdata (abfd)->makes_plt_call = 1;
4248                   if (bfd_link_pic (info))
4249                     addend = rel->r_addend;
4250                 }
4251               h->needs_plt = 1;
4252               if (!update_plt_info (abfd, &h->plt.plist, got2, addend))
4253                 return FALSE;
4254             }
4255           break;
4256
4257           /* The following relocations don't need to propagate the
4258              relocation if linking a shared object since they are
4259              section relative.  */
4260         case R_PPC_SECTOFF:
4261         case R_PPC_SECTOFF_LO:
4262         case R_PPC_SECTOFF_HI:
4263         case R_PPC_SECTOFF_HA:
4264         case R_PPC_DTPREL16:
4265         case R_PPC_DTPREL16_LO:
4266         case R_PPC_DTPREL16_HI:
4267         case R_PPC_DTPREL16_HA:
4268         case R_PPC_TOC16:
4269           break;
4270
4271         case R_PPC_REL16:
4272         case R_PPC_REL16_LO:
4273         case R_PPC_REL16_HI:
4274         case R_PPC_REL16_HA:
4275         case R_PPC_REL16DX_HA:
4276           ppc_elf_tdata (abfd)->has_rel16 = 1;
4277           break;
4278
4279           /* These are just markers.  */
4280         case R_PPC_TLS:
4281         case R_PPC_EMB_MRKREF:
4282         case R_PPC_NONE:
4283         case R_PPC_max:
4284         case R_PPC_RELAX:
4285         case R_PPC_RELAX_PLT:
4286         case R_PPC_RELAX_PLTREL24:
4287           break;
4288
4289           /* These should only appear in dynamic objects.  */
4290         case R_PPC_COPY:
4291         case R_PPC_GLOB_DAT:
4292         case R_PPC_JMP_SLOT:
4293         case R_PPC_RELATIVE:
4294         case R_PPC_IRELATIVE:
4295           break;
4296
4297           /* These aren't handled yet.  We'll report an error later.  */
4298         case R_PPC_ADDR30:
4299         case R_PPC_EMB_RELSEC16:
4300         case R_PPC_EMB_RELST_LO:
4301         case R_PPC_EMB_RELST_HI:
4302         case R_PPC_EMB_RELST_HA:
4303         case R_PPC_EMB_BIT_FLD:
4304           break;
4305
4306           /* This refers only to functions defined in the shared library.  */
4307         case R_PPC_LOCAL24PC:
4308           if (h != NULL && h == htab->elf.hgot && htab->plt_type == PLT_UNSET)
4309             {
4310               htab->plt_type = PLT_OLD;
4311               htab->old_bfd = abfd;
4312             }
4313           if (h != NULL && h->type == STT_GNU_IFUNC)
4314             {
4315               if (bfd_link_pic (info))
4316                 {
4317                   info->callbacks->einfo
4318                     (_("%P: %H: @local call to ifunc %s\n"),
4319                      abfd, sec, rel->r_offset,
4320                      h->root.root.string);
4321                   bfd_set_error (bfd_error_bad_value);
4322                   return FALSE;
4323                 }
4324               h->needs_plt = 1;
4325               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4326                 return FALSE;
4327             }
4328           break;
4329
4330           /* This relocation describes the C++ object vtable hierarchy.
4331              Reconstruct it for later use during GC.  */
4332         case R_PPC_GNU_VTINHERIT:
4333           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4334             return FALSE;
4335           break;
4336
4337           /* This relocation describes which C++ vtable entries are actually
4338              used.  Record for later use during GC.  */
4339         case R_PPC_GNU_VTENTRY:
4340           BFD_ASSERT (h != NULL);
4341           if (h != NULL
4342               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4343             return FALSE;
4344           break;
4345
4346           /* We shouldn't really be seeing these.  */
4347         case R_PPC_TPREL32:
4348         case R_PPC_TPREL16:
4349         case R_PPC_TPREL16_LO:
4350         case R_PPC_TPREL16_HI:
4351         case R_PPC_TPREL16_HA:
4352           if (bfd_link_pic (info))
4353             info->flags |= DF_STATIC_TLS;
4354           goto dodyn;
4355
4356           /* Nor these.  */
4357         case R_PPC_DTPMOD32:
4358         case R_PPC_DTPREL32:
4359           goto dodyn;
4360
4361         case R_PPC_REL32:
4362           if (h == NULL
4363               && got2 != NULL
4364               && (sec->flags & SEC_CODE) != 0
4365               && bfd_link_pic (info)
4366               && htab->plt_type == PLT_UNSET)
4367             {
4368               /* Old -fPIC gcc code has .long LCTOC1-LCFx just before
4369                  the start of a function, which assembles to a REL32
4370                  reference to .got2.  If we detect one of these, then
4371                  force the old PLT layout because the linker cannot
4372                  reliably deduce the GOT pointer value needed for
4373                  PLT call stubs.  */
4374               asection *s;
4375               Elf_Internal_Sym *isym;
4376
4377               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4378                                             abfd, r_symndx);
4379               if (isym == NULL)
4380                 return FALSE;
4381
4382               s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4383               if (s == got2)
4384                 {
4385                   htab->plt_type = PLT_OLD;
4386                   htab->old_bfd = abfd;
4387                 }
4388             }
4389           if (h == NULL || h == htab->elf.hgot)
4390             break;
4391           /* fall through */
4392
4393         case R_PPC_ADDR32:
4394         case R_PPC_ADDR16:
4395         case R_PPC_ADDR16_LO:
4396         case R_PPC_ADDR16_HI:
4397         case R_PPC_ADDR16_HA:
4398         case R_PPC_UADDR32:
4399         case R_PPC_UADDR16:
4400           if (h != NULL && !bfd_link_pic (info))
4401             {
4402               /* We may need a plt entry if the symbol turns out to be
4403                  a function defined in a dynamic object.  */
4404               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4405                 return FALSE;
4406
4407               /* We may need a copy reloc too.  */
4408               h->non_got_ref = 1;
4409               h->pointer_equality_needed = 1;
4410               if (r_type == R_PPC_ADDR16_HA)
4411                 ppc_elf_hash_entry (h)->has_addr16_ha = 1;
4412               if (r_type == R_PPC_ADDR16_LO)
4413                 ppc_elf_hash_entry (h)->has_addr16_lo = 1;
4414             }
4415           goto dodyn;
4416
4417         case R_PPC_REL24:
4418         case R_PPC_REL14:
4419         case R_PPC_REL14_BRTAKEN:
4420         case R_PPC_REL14_BRNTAKEN:
4421           if (h == NULL)
4422             break;
4423           if (h == htab->elf.hgot)
4424             {
4425               if (htab->plt_type == PLT_UNSET)
4426                 {
4427                   htab->plt_type = PLT_OLD;
4428                   htab->old_bfd = abfd;
4429                 }
4430               break;
4431             }
4432           /* fall through */
4433
4434         case R_PPC_ADDR24:
4435         case R_PPC_ADDR14:
4436         case R_PPC_ADDR14_BRTAKEN:
4437         case R_PPC_ADDR14_BRNTAKEN:
4438           if (h != NULL && !bfd_link_pic (info))
4439             {
4440               /* We may need a plt entry if the symbol turns out to be
4441                  a function defined in a dynamic object.  */
4442               h->needs_plt = 1;
4443               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4444                 return FALSE;
4445               break;
4446             }
4447
4448         dodyn:
4449           /* If we are creating a shared library, and this is a reloc
4450              against a global symbol, or a non PC relative reloc
4451              against a local symbol, then we need to copy the reloc
4452              into the shared library.  However, if we are linking with
4453              -Bsymbolic, we do not need to copy a reloc against a
4454              global symbol which is defined in an object we are
4455              including in the link (i.e., DEF_REGULAR is set).  At
4456              this point we have not seen all the input files, so it is
4457              possible that DEF_REGULAR is not set now but will be set
4458              later (it is never cleared).  In case of a weak definition,
4459              DEF_REGULAR may be cleared later by a strong definition in
4460              a shared library.  We account for that possibility below by
4461              storing information in the dyn_relocs field of the hash
4462              table entry.  A similar situation occurs when creating
4463              shared libraries and symbol visibility changes render the
4464              symbol local.
4465
4466              If on the other hand, we are creating an executable, we
4467              may need to keep relocations for symbols satisfied by a
4468              dynamic library if we manage to avoid copy relocs for the
4469              symbol.  */
4470           if ((bfd_link_pic (info)
4471                && (must_be_dyn_reloc (info, r_type)
4472                    || (h != NULL
4473                        && (!SYMBOLIC_BIND (info, h)
4474                            || h->root.type == bfd_link_hash_defweak
4475                            || !h->def_regular))))
4476               || (ELIMINATE_COPY_RELOCS
4477                   && !bfd_link_pic (info)
4478                   && h != NULL
4479                   && (h->root.type == bfd_link_hash_defweak
4480                       || !h->def_regular)))
4481             {
4482 #ifdef DEBUG
4483               fprintf (stderr,
4484                        "ppc_elf_check_relocs needs to "
4485                        "create relocation for %s\n",
4486                        (h && h->root.root.string
4487                         ? h->root.root.string : "<unknown>"));
4488 #endif
4489               if (sreloc == NULL)
4490                 {
4491                   if (htab->elf.dynobj == NULL)
4492                     htab->elf.dynobj = abfd;
4493
4494                   sreloc = _bfd_elf_make_dynamic_reloc_section
4495                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
4496
4497                   if (sreloc == NULL)
4498                     return FALSE;
4499                 }
4500
4501               /* If this is a global symbol, we count the number of
4502                  relocations we need for this symbol.  */
4503               if (h != NULL)
4504                 {
4505                   struct elf_dyn_relocs *p;
4506                   struct elf_dyn_relocs **rel_head;
4507
4508                   rel_head = &ppc_elf_hash_entry (h)->dyn_relocs;
4509                   p = *rel_head;
4510                   if (p == NULL || p->sec != sec)
4511                     {
4512                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4513                       if (p == NULL)
4514                         return FALSE;
4515                       p->next = *rel_head;
4516                       *rel_head = p;
4517                       p->sec = sec;
4518                       p->count = 0;
4519                       p->pc_count = 0;
4520                     }
4521                   p->count += 1;
4522                   if (!must_be_dyn_reloc (info, r_type))
4523                     p->pc_count += 1;
4524                 }
4525               else
4526                 {
4527                   /* Track dynamic relocs needed for local syms too.
4528                      We really need local syms available to do this
4529                      easily.  Oh well.  */
4530                   struct ppc_dyn_relocs *p;
4531                   struct ppc_dyn_relocs **rel_head;
4532                   bfd_boolean is_ifunc;
4533                   asection *s;
4534                   void *vpp;
4535                   Elf_Internal_Sym *isym;
4536
4537                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4538                                                 abfd, r_symndx);
4539                   if (isym == NULL)
4540                     return FALSE;
4541
4542                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4543                   if (s == NULL)
4544                     s = sec;
4545
4546                   vpp = &elf_section_data (s)->local_dynrel;
4547                   rel_head = (struct ppc_dyn_relocs **) vpp;
4548                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
4549                   p = *rel_head;
4550                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
4551                     p = p->next;
4552                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
4553                     {
4554                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4555                       if (p == NULL)
4556                         return FALSE;
4557                       p->next = *rel_head;
4558                       *rel_head = p;
4559                       p->sec = sec;
4560                       p->ifunc = is_ifunc;
4561                       p->count = 0;
4562                     }
4563                   p->count += 1;
4564                 }
4565             }
4566
4567           break;
4568         }
4569     }
4570
4571   return TRUE;
4572 }
4573 \f
4574
4575 /* Merge object attributes from IBFD into OBFD.  Raise an error if
4576    there are conflicting attributes.  */
4577 static bfd_boolean
4578 ppc_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
4579 {
4580   obj_attribute *in_attr, *in_attrs;
4581   obj_attribute *out_attr, *out_attrs;
4582
4583   if (!elf_known_obj_attributes_proc (obfd)[0].i)
4584     {
4585       /* This is the first object.  Copy the attributes.  */
4586       _bfd_elf_copy_obj_attributes (ibfd, obfd);
4587
4588       /* Use the Tag_null value to indicate the attributes have been
4589          initialized.  */
4590       elf_known_obj_attributes_proc (obfd)[0].i = 1;
4591
4592       return TRUE;
4593     }
4594
4595   in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4596   out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4597
4598   /* Check for conflicting Tag_GNU_Power_ABI_FP attributes and merge
4599      non-conflicting ones.  */
4600   in_attr = &in_attrs[Tag_GNU_Power_ABI_FP];
4601   out_attr = &out_attrs[Tag_GNU_Power_ABI_FP];
4602   if (in_attr->i != out_attr->i)
4603     {
4604       out_attr->type = 1;
4605       if (out_attr->i == 0)
4606         out_attr->i = in_attr->i;
4607       else if (in_attr->i == 0)
4608         ;
4609       else if (out_attr->i == 1 && in_attr->i == 2)
4610         _bfd_error_handler
4611           (_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd);
4612       else if (out_attr->i == 1 && in_attr->i == 3)
4613         _bfd_error_handler
4614           (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
4615           obfd, ibfd);
4616       else if (out_attr->i == 3 && in_attr->i == 1)
4617         _bfd_error_handler
4618           (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
4619           ibfd, obfd);
4620       else if (out_attr->i == 3 && in_attr->i == 2)
4621         _bfd_error_handler
4622           (_("Warning: %B uses soft float, %B uses single-precision hard float"),
4623           ibfd, obfd);
4624       else if (out_attr->i == 2 && (in_attr->i == 1 || in_attr->i == 3))
4625         _bfd_error_handler
4626           (_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd);
4627       else if (in_attr->i > 3)
4628         _bfd_error_handler
4629           (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
4630            in_attr->i);
4631       else
4632         _bfd_error_handler
4633           (_("Warning: %B uses unknown floating point ABI %d"), obfd,
4634            out_attr->i);
4635     }
4636
4637   /* Check for conflicting Tag_GNU_Power_ABI_Vector attributes and
4638      merge non-conflicting ones.  */
4639   in_attr = &in_attrs[Tag_GNU_Power_ABI_Vector];
4640   out_attr = &out_attrs[Tag_GNU_Power_ABI_Vector];
4641   if (in_attr->i != out_attr->i)
4642     {
4643       const char *in_abi = NULL, *out_abi = NULL;
4644
4645       switch (in_attr->i)
4646         {
4647         case 1: in_abi = "generic"; break;
4648         case 2: in_abi = "AltiVec"; break;
4649         case 3: in_abi = "SPE"; break;
4650         }
4651
4652       switch (out_attr->i)
4653         {
4654         case 1: out_abi = "generic"; break;
4655         case 2: out_abi = "AltiVec"; break;
4656         case 3: out_abi = "SPE"; break;
4657         }
4658
4659       out_attr->type = 1;
4660       if (out_attr->i == 0)
4661         out_attr->i = in_attr->i;
4662       else if (in_attr->i == 0)
4663         ;
4664       /* For now, allow generic to transition to AltiVec or SPE
4665          without a warning.  If GCC marked files with their stack
4666          alignment and used don't-care markings for files which are
4667          not affected by the vector ABI, we could warn about this
4668          case too.  */
4669       else if (out_attr->i == 1)
4670         out_attr->i = in_attr->i;
4671       else if (in_attr->i == 1)
4672         ;
4673       else if (in_abi == NULL)
4674         _bfd_error_handler
4675           (_("Warning: %B uses unknown vector ABI %d"), ibfd,
4676            in_attr->i);
4677       else if (out_abi == NULL)
4678         _bfd_error_handler
4679           (_("Warning: %B uses unknown vector ABI %d"), obfd,
4680            in_attr->i);
4681       else
4682         _bfd_error_handler
4683           (_("Warning: %B uses vector ABI \"%s\", %B uses \"%s\""),
4684            ibfd, obfd, in_abi, out_abi);
4685     }
4686
4687   /* Check for conflicting Tag_GNU_Power_ABI_Struct_Return attributes
4688      and merge non-conflicting ones.  */
4689   in_attr = &in_attrs[Tag_GNU_Power_ABI_Struct_Return];
4690   out_attr = &out_attrs[Tag_GNU_Power_ABI_Struct_Return];
4691   if (in_attr->i != out_attr->i)
4692     {
4693       out_attr->type = 1;
4694       if (out_attr->i == 0)
4695        out_attr->i = in_attr->i;
4696       else if (in_attr->i == 0)
4697        ;
4698       else if (out_attr->i == 1 && in_attr->i == 2)
4699        _bfd_error_handler
4700          (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), obfd, ibfd);
4701       else if (out_attr->i == 2 && in_attr->i == 1)
4702        _bfd_error_handler
4703          (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), ibfd, obfd);
4704       else if (in_attr->i > 2)
4705        _bfd_error_handler
4706          (_("Warning: %B uses unknown small structure return convention %d"), ibfd,
4707           in_attr->i);
4708       else
4709        _bfd_error_handler
4710          (_("Warning: %B uses unknown small structure return convention %d"), obfd,
4711           out_attr->i);
4712     }
4713
4714   /* Merge Tag_compatibility attributes and any common GNU ones.  */
4715   _bfd_elf_merge_object_attributes (ibfd, obfd);
4716
4717   return TRUE;
4718 }
4719
4720 /* Merge backend specific data from an object file to the output
4721    object file when linking.  */
4722
4723 static bfd_boolean
4724 ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4725 {
4726   flagword old_flags;
4727   flagword new_flags;
4728   bfd_boolean error;
4729
4730   if (!is_ppc_elf (ibfd) || !is_ppc_elf (obfd))
4731     return TRUE;
4732
4733   /* Check if we have the same endianness.  */
4734   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4735     return FALSE;
4736
4737   if (!ppc_elf_merge_obj_attributes (ibfd, obfd))
4738     return FALSE;
4739
4740   new_flags = elf_elfheader (ibfd)->e_flags;
4741   old_flags = elf_elfheader (obfd)->e_flags;
4742   if (!elf_flags_init (obfd))
4743     {
4744       /* First call, no flags set.  */
4745       elf_flags_init (obfd) = TRUE;
4746       elf_elfheader (obfd)->e_flags = new_flags;
4747     }
4748
4749   /* Compatible flags are ok.  */
4750   else if (new_flags == old_flags)
4751     ;
4752
4753   /* Incompatible flags.  */
4754   else
4755     {
4756       /* Warn about -mrelocatable mismatch.  Allow -mrelocatable-lib
4757          to be linked with either.  */
4758       error = FALSE;
4759       if ((new_flags & EF_PPC_RELOCATABLE) != 0
4760           && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
4761         {
4762           error = TRUE;
4763           (*_bfd_error_handler)
4764             (_("%B: compiled with -mrelocatable and linked with "
4765                "modules compiled normally"), ibfd);
4766         }
4767       else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
4768                && (old_flags & EF_PPC_RELOCATABLE) != 0)
4769         {
4770           error = TRUE;
4771           (*_bfd_error_handler)
4772             (_("%B: compiled normally and linked with "
4773                "modules compiled with -mrelocatable"), ibfd);
4774         }
4775
4776       /* The output is -mrelocatable-lib iff both the input files are.  */
4777       if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
4778         elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
4779
4780       /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
4781          but each input file is either -mrelocatable or -mrelocatable-lib.  */
4782       if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
4783           && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
4784           && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
4785         elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
4786
4787       /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if
4788          any module uses it.  */
4789       elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
4790
4791       new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
4792       old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
4793
4794       /* Warn about any other mismatches.  */
4795       if (new_flags != old_flags)
4796         {
4797           error = TRUE;
4798           (*_bfd_error_handler)
4799             (_("%B: uses different e_flags (0x%lx) fields "
4800                "than previous modules (0x%lx)"),
4801              ibfd, (long) new_flags, (long) old_flags);
4802         }
4803
4804       if (error)
4805         {
4806           bfd_set_error (bfd_error_bad_value);
4807           return FALSE;
4808         }
4809     }
4810
4811   return TRUE;
4812 }
4813
4814 static void
4815 ppc_elf_vle_split16 (bfd *output_bfd, bfd_byte *loc,
4816                      bfd_vma value,
4817                      split16_format_type split16_format)
4818
4819 {
4820   unsigned int insn, top5;
4821
4822   insn = bfd_get_32 (output_bfd, loc);
4823   top5 = value & 0xf800;
4824   top5 = top5 << (split16_format == split16a_type ? 9 : 5);
4825   insn |= top5;
4826   insn |= value & 0x7ff;
4827   bfd_put_32 (output_bfd, insn, loc);
4828 }
4829
4830 \f
4831 /* Choose which PLT scheme to use, and set .plt flags appropriately.
4832    Returns -1 on error, 0 for old PLT, 1 for new PLT.  */
4833 int
4834 ppc_elf_select_plt_layout (bfd *output_bfd ATTRIBUTE_UNUSED,
4835                            struct bfd_link_info *info)
4836 {
4837   struct ppc_elf_link_hash_table *htab;
4838   flagword flags;
4839
4840   htab = ppc_elf_hash_table (info);
4841
4842   if (htab->plt_type == PLT_UNSET)
4843     {
4844       struct elf_link_hash_entry *h;
4845
4846       if (htab->params->plt_style == PLT_OLD)
4847         htab->plt_type = PLT_OLD;
4848       else if (bfd_link_pic (info)
4849                && htab->elf.dynamic_sections_created
4850                && (h = elf_link_hash_lookup (&htab->elf, "_mcount",
4851                                              FALSE, FALSE, TRUE)) != NULL
4852                && (h->type == STT_FUNC
4853                    || h->needs_plt)
4854                && h->ref_regular
4855                && !(SYMBOL_CALLS_LOCAL (info, h)
4856                     || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4857                         && h->root.type == bfd_link_hash_undefweak)))
4858         {
4859           /* Profiling of shared libs (and pies) is not supported with
4860              secure plt, because ppc32 does profiling before a
4861              function prologue and a secure plt pic call stubs needs
4862              r30 to be set up.  */
4863           htab->plt_type = PLT_OLD;
4864         }
4865       else
4866         {
4867           bfd *ibfd;
4868           enum ppc_elf_plt_type plt_type = htab->params->plt_style;
4869
4870           /* Look through the reloc flags left by ppc_elf_check_relocs.
4871              Use the old style bss plt if a file makes plt calls
4872              without using the new relocs, and if ld isn't given
4873              --secure-plt and we never see REL16 relocs.  */
4874           if (plt_type == PLT_UNSET)
4875             plt_type = PLT_OLD;
4876           for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
4877             if (is_ppc_elf (ibfd))
4878               {
4879                 if (ppc_elf_tdata (ibfd)->has_rel16)
4880                   plt_type = PLT_NEW;
4881                 else if (ppc_elf_tdata (ibfd)->makes_plt_call)
4882                   {
4883                     plt_type = PLT_OLD;
4884                     htab->old_bfd = ibfd;
4885                     break;
4886                   }
4887               }
4888           htab->plt_type = plt_type;
4889         }
4890     }
4891   if (htab->plt_type == PLT_OLD && htab->params->plt_style == PLT_NEW)
4892     {
4893       if (htab->old_bfd != NULL)
4894         info->callbacks->einfo (_("%P: bss-plt forced due to %B\n"),
4895                                 htab->old_bfd);
4896       else
4897         info->callbacks->einfo (_("%P: bss-plt forced by profiling\n"));
4898     }
4899
4900   BFD_ASSERT (htab->plt_type != PLT_VXWORKS);
4901
4902   if (htab->plt_type == PLT_NEW)
4903     {
4904       flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4905                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4906
4907       /* The new PLT is a loaded section.  */
4908       if (htab->plt != NULL
4909           && !bfd_set_section_flags (htab->elf.dynobj, htab->plt, flags))
4910         return -1;
4911
4912       /* The new GOT is not executable.  */
4913       if (htab->got != NULL
4914           && !bfd_set_section_flags (htab->elf.dynobj, htab->got, flags))
4915         return -1;
4916     }
4917   else
4918     {
4919       /* Stop an unused .glink section from affecting .text alignment.  */
4920       if (htab->glink != NULL
4921           && !bfd_set_section_alignment (htab->elf.dynobj, htab->glink, 0))
4922         return -1;
4923     }
4924   return htab->plt_type == PLT_NEW;
4925 }
4926 \f
4927 /* Return the section that should be marked against GC for a given
4928    relocation.  */
4929
4930 static asection *
4931 ppc_elf_gc_mark_hook (asection *sec,
4932                       struct bfd_link_info *info,
4933                       Elf_Internal_Rela *rel,
4934                       struct elf_link_hash_entry *h,
4935                       Elf_Internal_Sym *sym)
4936 {
4937   if (h != NULL)
4938     switch (ELF32_R_TYPE (rel->r_info))
4939       {
4940       case R_PPC_GNU_VTINHERIT:
4941       case R_PPC_GNU_VTENTRY:
4942         return NULL;
4943       }
4944
4945   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4946 }
4947
4948 /* Update the got, plt and dynamic reloc reference counts for the
4949    section being removed.  */
4950
4951 static bfd_boolean
4952 ppc_elf_gc_sweep_hook (bfd *abfd,
4953                        struct bfd_link_info *info,
4954                        asection *sec,
4955                        const Elf_Internal_Rela *relocs)
4956 {
4957   struct ppc_elf_link_hash_table *htab;
4958   Elf_Internal_Shdr *symtab_hdr;
4959   struct elf_link_hash_entry **sym_hashes;
4960   bfd_signed_vma *local_got_refcounts;
4961   const Elf_Internal_Rela *rel, *relend;
4962   asection *got2;
4963
4964   if (bfd_link_relocatable (info))
4965     return TRUE;
4966
4967   if ((sec->flags & SEC_ALLOC) == 0)
4968     return TRUE;
4969
4970   elf_section_data (sec)->local_dynrel = NULL;
4971
4972   htab = ppc_elf_hash_table (info);
4973   symtab_hdr = &elf_symtab_hdr (abfd);
4974   sym_hashes = elf_sym_hashes (abfd);
4975   local_got_refcounts = elf_local_got_refcounts (abfd);
4976   got2 = bfd_get_section_by_name (abfd, ".got2");
4977
4978   relend = relocs + sec->reloc_count;
4979   for (rel = relocs; rel < relend; rel++)
4980     {
4981       unsigned long r_symndx;
4982       enum elf_ppc_reloc_type r_type;
4983       struct elf_link_hash_entry *h = NULL;
4984
4985       r_symndx = ELF32_R_SYM (rel->r_info);
4986       if (r_symndx >= symtab_hdr->sh_info)
4987         {
4988           struct elf_dyn_relocs **pp, *p;
4989           struct ppc_elf_link_hash_entry *eh;
4990
4991           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4992           while (h->root.type == bfd_link_hash_indirect
4993                  || h->root.type == bfd_link_hash_warning)
4994             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4995           eh = (struct ppc_elf_link_hash_entry *) h;
4996
4997           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
4998             if (p->sec == sec)
4999               {
5000                 /* Everything must go for SEC.  */
5001                 *pp = p->next;
5002                 break;
5003               }
5004         }
5005
5006       r_type = ELF32_R_TYPE (rel->r_info);
5007       if (!htab->is_vxworks
5008           && h == NULL
5009           && local_got_refcounts != NULL
5010           && (!bfd_link_pic (info)
5011               || is_branch_reloc (r_type)))
5012         {
5013           struct plt_entry **local_plt = (struct plt_entry **)
5014             (local_got_refcounts + symtab_hdr->sh_info);
5015           char *local_got_tls_masks = (char *)
5016             (local_plt + symtab_hdr->sh_info);
5017           if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5018             {
5019               struct plt_entry **ifunc = local_plt + r_symndx;
5020               bfd_vma addend = 0;
5021               struct plt_entry *ent;
5022
5023               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info))
5024                 addend = rel->r_addend;
5025               ent = find_plt_ent (ifunc, got2, addend);
5026               if (ent->plt.refcount > 0)
5027                 ent->plt.refcount -= 1;
5028               continue;
5029             }
5030         }
5031
5032       switch (r_type)
5033         {
5034         case R_PPC_GOT_TLSLD16:
5035         case R_PPC_GOT_TLSLD16_LO:
5036         case R_PPC_GOT_TLSLD16_HI:
5037         case R_PPC_GOT_TLSLD16_HA:
5038         case R_PPC_GOT_TLSGD16:
5039         case R_PPC_GOT_TLSGD16_LO:
5040         case R_PPC_GOT_TLSGD16_HI:
5041         case R_PPC_GOT_TLSGD16_HA:
5042         case R_PPC_GOT_TPREL16:
5043         case R_PPC_GOT_TPREL16_LO:
5044         case R_PPC_GOT_TPREL16_HI:
5045         case R_PPC_GOT_TPREL16_HA:
5046         case R_PPC_GOT_DTPREL16:
5047         case R_PPC_GOT_DTPREL16_LO:
5048         case R_PPC_GOT_DTPREL16_HI:
5049         case R_PPC_GOT_DTPREL16_HA:
5050         case R_PPC_GOT16:
5051         case R_PPC_GOT16_LO:
5052         case R_PPC_GOT16_HI:
5053         case R_PPC_GOT16_HA:
5054           if (h != NULL)
5055             {
5056               if (h->got.refcount > 0)
5057                 h->got.refcount--;
5058               if (!bfd_link_pic (info))
5059                 {
5060                   struct plt_entry *ent;
5061
5062                   ent = find_plt_ent (&h->plt.plist, NULL, 0);
5063                   if (ent != NULL && ent->plt.refcount > 0)
5064                     ent->plt.refcount -= 1;
5065                 }
5066             }
5067           else if (local_got_refcounts != NULL)
5068             {
5069               if (local_got_refcounts[r_symndx] > 0)
5070                 local_got_refcounts[r_symndx]--;
5071             }
5072           break;
5073
5074         case R_PPC_REL24:
5075         case R_PPC_REL14:
5076         case R_PPC_REL14_BRTAKEN:
5077         case R_PPC_REL14_BRNTAKEN:
5078         case R_PPC_REL32:
5079           if (h == NULL || h == htab->elf.hgot)
5080             break;
5081           /* Fall thru */
5082
5083         case R_PPC_ADDR32:
5084         case R_PPC_ADDR24:
5085         case R_PPC_ADDR16:
5086         case R_PPC_ADDR16_LO:
5087         case R_PPC_ADDR16_HI:
5088         case R_PPC_ADDR16_HA:
5089         case R_PPC_ADDR14:
5090         case R_PPC_ADDR14_BRTAKEN:
5091         case R_PPC_ADDR14_BRNTAKEN:
5092         case R_PPC_UADDR32:
5093         case R_PPC_UADDR16:
5094           if (bfd_link_pic (info))
5095             break;
5096
5097         case R_PPC_PLT32:
5098         case R_PPC_PLTREL24:
5099         case R_PPC_PLTREL32:
5100         case R_PPC_PLT16_LO:
5101         case R_PPC_PLT16_HI:
5102         case R_PPC_PLT16_HA:
5103           if (h != NULL)
5104             {
5105               bfd_vma addend = 0;
5106               struct plt_entry *ent;
5107
5108               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info))
5109                 addend = rel->r_addend;
5110               ent = find_plt_ent (&h->plt.plist, got2, addend);
5111               if (ent != NULL && ent->plt.refcount > 0)
5112                 ent->plt.refcount -= 1;
5113             }
5114           break;
5115
5116         default:
5117           break;
5118         }
5119     }
5120   return TRUE;
5121 }
5122 \f
5123 /* Set plt output section type, htab->tls_get_addr, and call the
5124    generic ELF tls_setup function.  */
5125
5126 asection *
5127 ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
5128 {
5129   struct ppc_elf_link_hash_table *htab;
5130
5131   htab = ppc_elf_hash_table (info);
5132   htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5133                                              FALSE, FALSE, TRUE);
5134   if (htab->plt_type != PLT_NEW)
5135     htab->params->no_tls_get_addr_opt = TRUE;
5136
5137   if (!htab->params->no_tls_get_addr_opt)
5138     {
5139       struct elf_link_hash_entry *opt, *tga;
5140       opt = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
5141                                   FALSE, FALSE, TRUE);
5142       if (opt != NULL
5143           && (opt->root.type == bfd_link_hash_defined
5144               || opt->root.type == bfd_link_hash_defweak))
5145         {
5146           /* If glibc supports an optimized __tls_get_addr call stub,
5147              signalled by the presence of __tls_get_addr_opt, and we'll
5148              be calling __tls_get_addr via a plt call stub, then
5149              make __tls_get_addr point to __tls_get_addr_opt.  */
5150           tga = htab->tls_get_addr;
5151           if (htab->elf.dynamic_sections_created
5152               && tga != NULL
5153               && (tga->type == STT_FUNC
5154                   || tga->needs_plt)
5155               && !(SYMBOL_CALLS_LOCAL (info, tga)
5156                    || (ELF_ST_VISIBILITY (tga->other) != STV_DEFAULT
5157                        && tga->root.type == bfd_link_hash_undefweak)))
5158             {
5159               struct plt_entry *ent;
5160               for (ent = tga->plt.plist; ent != NULL; ent = ent->next)
5161                 if (ent->plt.refcount > 0)
5162                   break;
5163               if (ent != NULL)
5164                 {
5165                   tga->root.type = bfd_link_hash_indirect;
5166                   tga->root.u.i.link = &opt->root;
5167                   ppc_elf_copy_indirect_symbol (info, opt, tga);
5168                   if (opt->dynindx != -1)
5169                     {
5170                       /* Use __tls_get_addr_opt in dynamic relocations.  */
5171                       opt->dynindx = -1;
5172                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
5173                                               opt->dynstr_index);
5174                       if (!bfd_elf_link_record_dynamic_symbol (info, opt))
5175                         return FALSE;
5176                     }
5177                   htab->tls_get_addr = opt;
5178                 }
5179             }
5180         }
5181       else
5182         htab->params->no_tls_get_addr_opt = TRUE;
5183     }
5184   if (htab->plt_type == PLT_NEW
5185       && htab->plt != NULL
5186       && htab->plt->output_section != NULL)
5187     {
5188       elf_section_type (htab->plt->output_section) = SHT_PROGBITS;
5189       elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE;
5190     }
5191
5192   return _bfd_elf_tls_setup (obfd, info);
5193 }
5194
5195 /* Return TRUE iff REL is a branch reloc with a global symbol matching
5196    HASH.  */
5197
5198 static bfd_boolean
5199 branch_reloc_hash_match (const bfd *ibfd,
5200                          const Elf_Internal_Rela *rel,
5201                          const struct elf_link_hash_entry *hash)
5202 {
5203   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
5204   enum elf_ppc_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
5205   unsigned int r_symndx = ELF32_R_SYM (rel->r_info);
5206
5207   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
5208     {
5209       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
5210       struct elf_link_hash_entry *h;
5211
5212       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5213       while (h->root.type == bfd_link_hash_indirect
5214              || h->root.type == bfd_link_hash_warning)
5215         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5216       if (h == hash)
5217         return TRUE;
5218     }
5219   return FALSE;
5220 }
5221
5222 /* Run through all the TLS relocs looking for optimization
5223    opportunities.  */
5224
5225 bfd_boolean
5226 ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED,
5227                       struct bfd_link_info *info)
5228 {
5229   bfd *ibfd;
5230   asection *sec;
5231   struct ppc_elf_link_hash_table *htab;
5232   int pass;
5233
5234   if (!bfd_link_executable (info))
5235     return TRUE;
5236
5237   htab = ppc_elf_hash_table (info);
5238   if (htab == NULL)
5239     return FALSE;
5240
5241   /* Make two passes through the relocs.  First time check that tls
5242      relocs involved in setting up a tls_get_addr call are indeed
5243      followed by such a call.  If they are not, don't do any tls
5244      optimization.  On the second pass twiddle tls_mask flags to
5245      notify relocate_section that optimization can be done, and
5246      adjust got and plt refcounts.  */
5247   for (pass = 0; pass < 2; ++pass)
5248     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5249       {
5250         Elf_Internal_Sym *locsyms = NULL;
5251         Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
5252         asection *got2 = bfd_get_section_by_name (ibfd, ".got2");
5253
5254         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5255           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
5256             {
5257               Elf_Internal_Rela *relstart, *rel, *relend;
5258               int expecting_tls_get_addr = 0;
5259
5260               /* Read the relocations.  */
5261               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
5262                                                     info->keep_memory);
5263               if (relstart == NULL)
5264                 return FALSE;
5265
5266               relend = relstart + sec->reloc_count;
5267               for (rel = relstart; rel < relend; rel++)
5268                 {
5269                   enum elf_ppc_reloc_type r_type;
5270                   unsigned long r_symndx;
5271                   struct elf_link_hash_entry *h = NULL;
5272                   char *tls_mask;
5273                   char tls_set, tls_clear;
5274                   bfd_boolean is_local;
5275                   bfd_signed_vma *got_count;
5276
5277                   r_symndx = ELF32_R_SYM (rel->r_info);
5278                   if (r_symndx >= symtab_hdr->sh_info)
5279                     {
5280                       struct elf_link_hash_entry **sym_hashes;
5281
5282                       sym_hashes = elf_sym_hashes (ibfd);
5283                       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5284                       while (h->root.type == bfd_link_hash_indirect
5285                              || h->root.type == bfd_link_hash_warning)
5286                         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5287                     }
5288
5289                   is_local = FALSE;
5290                   if (h == NULL
5291                       || !h->def_dynamic)
5292                     is_local = TRUE;
5293
5294                   r_type = ELF32_R_TYPE (rel->r_info);
5295                   /* If this section has old-style __tls_get_addr calls
5296                      without marker relocs, then check that each
5297                      __tls_get_addr call reloc is preceded by a reloc
5298                      that conceivably belongs to the __tls_get_addr arg
5299                      setup insn.  If we don't find matching arg setup
5300                      relocs, don't do any tls optimization.  */
5301                   if (pass == 0
5302                       && sec->has_tls_get_addr_call
5303                       && h != NULL
5304                       && h == htab->tls_get_addr
5305                       && !expecting_tls_get_addr
5306                       && is_branch_reloc (r_type))
5307                     {
5308                       info->callbacks->minfo ("%H __tls_get_addr lost arg, "
5309                                               "TLS optimization disabled\n",
5310                                               ibfd, sec, rel->r_offset);
5311                       if (elf_section_data (sec)->relocs != relstart)
5312                         free (relstart);
5313                       return TRUE;
5314                     }
5315
5316                   expecting_tls_get_addr = 0;
5317                   switch (r_type)
5318                     {
5319                     case R_PPC_GOT_TLSLD16:
5320                     case R_PPC_GOT_TLSLD16_LO:
5321                       expecting_tls_get_addr = 1;
5322                       /* Fall thru */
5323
5324                     case R_PPC_GOT_TLSLD16_HI:
5325                     case R_PPC_GOT_TLSLD16_HA:
5326                       /* These relocs should never be against a symbol
5327                          defined in a shared lib.  Leave them alone if
5328                          that turns out to be the case.  */
5329                       if (!is_local)
5330                         continue;
5331
5332                       /* LD -> LE */
5333                       tls_set = 0;
5334                       tls_clear = TLS_LD;
5335                       break;
5336
5337                     case R_PPC_GOT_TLSGD16:
5338                     case R_PPC_GOT_TLSGD16_LO:
5339                       expecting_tls_get_addr = 1;
5340                       /* Fall thru */
5341
5342                     case R_PPC_GOT_TLSGD16_HI:
5343                     case R_PPC_GOT_TLSGD16_HA:
5344                       if (is_local)
5345                         /* GD -> LE */
5346                         tls_set = 0;
5347                       else
5348                         /* GD -> IE */
5349                         tls_set = TLS_TLS | TLS_TPRELGD;
5350                       tls_clear = TLS_GD;
5351                       break;
5352
5353                     case R_PPC_GOT_TPREL16:
5354                     case R_PPC_GOT_TPREL16_LO:
5355                     case R_PPC_GOT_TPREL16_HI:
5356                     case R_PPC_GOT_TPREL16_HA:
5357                       if (is_local)
5358                         {
5359                           /* IE -> LE */
5360                           tls_set = 0;
5361                           tls_clear = TLS_TPREL;
5362                           break;
5363                         }
5364                       else
5365                         continue;
5366
5367                     case R_PPC_TLSGD:
5368                     case R_PPC_TLSLD:
5369                       expecting_tls_get_addr = 2;
5370                       tls_set = 0;
5371                       tls_clear = 0;
5372                       break;
5373
5374                     default:
5375                       continue;
5376                     }
5377
5378                   if (pass == 0)
5379                     {
5380                       if (!expecting_tls_get_addr
5381                           || (expecting_tls_get_addr == 1
5382                               && !sec->has_tls_get_addr_call))
5383                         continue;
5384
5385                       if (rel + 1 < relend
5386                           && branch_reloc_hash_match (ibfd, rel + 1,
5387                                                       htab->tls_get_addr))
5388                         continue;
5389
5390                       /* Uh oh, we didn't find the expected call.  We
5391                          could just mark this symbol to exclude it
5392                          from tls optimization but it's safer to skip
5393                          the entire optimization.  */
5394                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
5395                                                 "TLS optimization disabled\n"),
5396                                               ibfd, sec, rel->r_offset);
5397                       if (elf_section_data (sec)->relocs != relstart)
5398                         free (relstart);
5399                       return TRUE;
5400                     }
5401
5402                   if (expecting_tls_get_addr)
5403                     {
5404                       struct plt_entry *ent;
5405                       bfd_vma addend = 0;
5406
5407                       if (bfd_link_pic (info)
5408                           && ELF32_R_TYPE (rel[1].r_info) == R_PPC_PLTREL24)
5409                         addend = rel[1].r_addend;
5410                       ent = find_plt_ent (&htab->tls_get_addr->plt.plist,
5411                                           got2, addend);
5412                       if (ent != NULL && ent->plt.refcount > 0)
5413                         ent->plt.refcount -= 1;
5414
5415                       if (expecting_tls_get_addr == 2)
5416                         continue;
5417                     }
5418
5419                   if (h != NULL)
5420                     {
5421                       tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
5422                       got_count = &h->got.refcount;
5423                     }
5424                   else
5425                     {
5426                       bfd_signed_vma *lgot_refs;
5427                       struct plt_entry **local_plt;
5428                       char *lgot_masks;
5429
5430                       if (locsyms == NULL)
5431                         {
5432                           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
5433                           if (locsyms == NULL)
5434                             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
5435                                                             symtab_hdr->sh_info,
5436                                                             0, NULL, NULL, NULL);
5437                           if (locsyms == NULL)
5438                             {
5439                               if (elf_section_data (sec)->relocs != relstart)
5440                                 free (relstart);
5441                               return FALSE;
5442                             }
5443                         }
5444                       lgot_refs = elf_local_got_refcounts (ibfd);
5445                       if (lgot_refs == NULL)
5446                         abort ();
5447                       local_plt = (struct plt_entry **)
5448                         (lgot_refs + symtab_hdr->sh_info);
5449                       lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
5450                       tls_mask = &lgot_masks[r_symndx];
5451                       got_count = &lgot_refs[r_symndx];
5452                     }
5453
5454                   if (tls_set == 0)
5455                     {
5456                       /* We managed to get rid of a got entry.  */
5457                       if (*got_count > 0)
5458                         *got_count -= 1;
5459                     }
5460
5461                   *tls_mask |= tls_set;
5462                   *tls_mask &= ~tls_clear;
5463                 }
5464
5465               if (elf_section_data (sec)->relocs != relstart)
5466                 free (relstart);
5467             }
5468
5469         if (locsyms != NULL
5470             && (symtab_hdr->contents != (unsigned char *) locsyms))
5471           {
5472             if (!info->keep_memory)
5473               free (locsyms);
5474             else
5475               symtab_hdr->contents = (unsigned char *) locsyms;
5476           }
5477       }
5478   return TRUE;
5479 }
5480 \f
5481 /* Return true if we have dynamic relocs that apply to read-only sections.  */
5482
5483 static bfd_boolean
5484 readonly_dynrelocs (struct elf_link_hash_entry *h)
5485 {
5486   struct elf_dyn_relocs *p;
5487
5488   for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
5489     {
5490       asection *s = p->sec->output_section;
5491
5492       if (s != NULL
5493           && ((s->flags & (SEC_READONLY | SEC_ALLOC))
5494               == (SEC_READONLY | SEC_ALLOC)))
5495         return TRUE;
5496     }
5497   return FALSE;
5498 }
5499
5500 /* Adjust a symbol defined by a dynamic object and referenced by a
5501    regular object.  The current definition is in some section of the
5502    dynamic object, but we're not including those sections.  We have to
5503    change the definition to something the rest of the link can
5504    understand.  */
5505
5506 static bfd_boolean
5507 ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5508                                struct elf_link_hash_entry *h)
5509 {
5510   struct ppc_elf_link_hash_table *htab;
5511   asection *s;
5512
5513 #ifdef DEBUG
5514   fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n",
5515            h->root.root.string);
5516 #endif
5517
5518   /* Make sure we know what is going on here.  */
5519   htab = ppc_elf_hash_table (info);
5520   BFD_ASSERT (htab->elf.dynobj != NULL
5521               && (h->needs_plt
5522                   || h->type == STT_GNU_IFUNC
5523                   || h->u.weakdef != NULL
5524                   || (h->def_dynamic
5525                       && h->ref_regular
5526                       && !h->def_regular)));
5527
5528   /* Deal with function syms.  */
5529   if (h->type == STT_FUNC
5530       || h->type == STT_GNU_IFUNC
5531       || h->needs_plt)
5532     {
5533       /* Clear procedure linkage table information for any symbol that
5534          won't need a .plt entry.  */
5535       struct plt_entry *ent;
5536       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5537         if (ent->plt.refcount > 0)
5538           break;
5539       if (ent == NULL
5540           || (h->type != STT_GNU_IFUNC
5541               && (SYMBOL_CALLS_LOCAL (info, h)
5542                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5543                       && h->root.type == bfd_link_hash_undefweak))))
5544         {
5545           /* A PLT entry is not required/allowed when:
5546
5547              1. We are not using ld.so; because then the PLT entry
5548              can't be set up, so we can't use one.  In this case,
5549              ppc_elf_adjust_dynamic_symbol won't even be called.
5550
5551              2. GC has rendered the entry unused.
5552
5553              3. We know for certain that a call to this symbol
5554              will go to this object, or will remain undefined.  */
5555           h->plt.plist = NULL;
5556           h->needs_plt = 0;
5557           h->pointer_equality_needed = 0;
5558         }
5559       else
5560         {
5561           /* Taking a function's address in a read/write section
5562              doesn't require us to define the function symbol in the
5563              executable on a plt call stub.  A dynamic reloc can
5564              be used instead.  */
5565           if (h->pointer_equality_needed
5566               && h->type != STT_GNU_IFUNC
5567               && !htab->is_vxworks
5568               && !ppc_elf_hash_entry (h)->has_sda_refs
5569               && !readonly_dynrelocs (h))
5570             {
5571               h->pointer_equality_needed = 0;
5572               h->non_got_ref = 0;
5573             }
5574
5575           /* After adjust_dynamic_symbol, non_got_ref set in the
5576              non-shared case means that we have allocated space in
5577              .dynbss for the symbol and thus dyn_relocs for this
5578              symbol should be discarded.
5579              If we get here we know we are making a PLT entry for this
5580              symbol, and in an executable we'd normally resolve
5581              relocations against this symbol to the PLT entry.  Allow
5582              dynamic relocs if the reference is weak, and the dynamic
5583              relocs will not cause text relocation.  */
5584           else if (!h->ref_regular_nonweak
5585                    && h->non_got_ref
5586                    && h->type != STT_GNU_IFUNC
5587                    && !htab->is_vxworks
5588                    && !ppc_elf_hash_entry (h)->has_sda_refs
5589                    && !readonly_dynrelocs (h))
5590             h->non_got_ref = 0;
5591         }
5592       h->protected_def = 0;
5593       return TRUE;
5594     }
5595   else
5596     h->plt.plist = NULL;
5597
5598   /* If this is a weak symbol, and there is a real definition, the
5599      processor independent code will have arranged for us to see the
5600      real definition first, and we can just use the same value.  */
5601   if (h->u.weakdef != NULL)
5602     {
5603       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5604                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5605       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5606       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5607       if (ELIMINATE_COPY_RELOCS)
5608         h->non_got_ref = h->u.weakdef->non_got_ref;
5609       return TRUE;
5610     }
5611
5612   /* This is a reference to a symbol defined by a dynamic object which
5613      is not a function.  */
5614
5615   /* If we are creating a shared library, we must presume that the
5616      only references to the symbol are via the global offset table.
5617      For such cases we need not do anything here; the relocations will
5618      be handled correctly by relocate_section.  */
5619   if (bfd_link_pic (info))
5620     {
5621       h->protected_def = 0;
5622       return TRUE;
5623     }
5624
5625   /* If there are no references to this symbol that do not use the
5626      GOT, we don't need to generate a copy reloc.  */
5627   if (!h->non_got_ref)
5628     {
5629       h->protected_def = 0;
5630       return TRUE;
5631     }
5632
5633   /* Protected variables do not work with .dynbss.  The copy in
5634      .dynbss won't be used by the shared library with the protected
5635      definition for the variable.  Editing to PIC, or text relocations
5636      are preferable to an incorrect program.  */
5637   if (h->protected_def)
5638     {
5639       if (ELIMINATE_COPY_RELOCS
5640           && ppc_elf_hash_entry (h)->has_addr16_ha
5641           && ppc_elf_hash_entry (h)->has_addr16_lo
5642           && htab->params->pic_fixup == 0
5643           && info->disable_target_specific_optimizations <= 1)
5644         htab->params->pic_fixup = 1;
5645       h->non_got_ref = 0;
5646       return TRUE;
5647     }
5648
5649   /* If -z nocopyreloc was given, we won't generate them either.  */
5650   if (info->nocopyreloc)
5651     {
5652       h->non_got_ref = 0;
5653       return TRUE;
5654     }
5655
5656    /* If we didn't find any dynamic relocs in read-only sections, then
5657       we'll be keeping the dynamic relocs and avoiding the copy reloc.
5658       We can't do this if there are any small data relocations.  This
5659       doesn't work on VxWorks, where we can not have dynamic
5660       relocations (other than copy and jump slot relocations) in an
5661       executable.  */
5662   if (ELIMINATE_COPY_RELOCS
5663       && !ppc_elf_hash_entry (h)->has_sda_refs
5664       && !htab->is_vxworks
5665       && !h->def_regular
5666       && !readonly_dynrelocs (h))
5667     {
5668       h->non_got_ref = 0;
5669       return TRUE;
5670     }
5671
5672   /* We must allocate the symbol in our .dynbss section, which will
5673      become part of the .bss section of the executable.  There will be
5674      an entry for this symbol in the .dynsym section.  The dynamic
5675      object will contain position independent code, so all references
5676      from the dynamic object to this symbol will go through the global
5677      offset table.  The dynamic linker will use the .dynsym entry to
5678      determine the address it must put in the global offset table, so
5679      both the dynamic object and the regular object will refer to the
5680      same memory location for the variable.
5681
5682      Of course, if the symbol is referenced using SDAREL relocs, we
5683      must instead allocate it in .sbss.  */
5684
5685   if (ppc_elf_hash_entry (h)->has_sda_refs)
5686     s = htab->dynsbss;
5687   else
5688     s = htab->dynbss;
5689   BFD_ASSERT (s != NULL);
5690
5691   /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
5692      copy the initial value out of the dynamic object and into the
5693      runtime process image.  We need to remember the offset into the
5694      .rela.bss section we are going to use.  */
5695   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5696     {
5697       asection *srel;
5698
5699       if (ppc_elf_hash_entry (h)->has_sda_refs)
5700         srel = htab->relsbss;
5701       else
5702         srel = htab->relbss;
5703       BFD_ASSERT (srel != NULL);
5704       srel->size += sizeof (Elf32_External_Rela);
5705       h->needs_copy = 1;
5706     }
5707
5708   return _bfd_elf_adjust_dynamic_copy (info, h, s);
5709 }
5710 \f
5711 /* Generate a symbol to mark plt call stubs.  For non-PIC code the sym is
5712    xxxxxxxx.plt_call32.<callee> where xxxxxxxx is a hex number, usually 0,
5713    specifying the addend on the plt relocation.  For -fpic code, the sym
5714    is xxxxxxxx.plt_pic32.<callee>, and for -fPIC
5715    xxxxxxxx.got2.plt_pic32.<callee>.  */
5716
5717 static bfd_boolean
5718 add_stub_sym (struct plt_entry *ent,
5719               struct elf_link_hash_entry *h,
5720               struct bfd_link_info *info)
5721 {
5722   struct elf_link_hash_entry *sh;
5723   size_t len1, len2, len3;
5724   char *name;
5725   const char *stub;
5726   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
5727
5728   if (bfd_link_pic (info))
5729     stub = ".plt_pic32.";
5730   else
5731     stub = ".plt_call32.";
5732
5733   len1 = strlen (h->root.root.string);
5734   len2 = strlen (stub);
5735   len3 = 0;
5736   if (ent->sec)
5737     len3 = strlen (ent->sec->name);
5738   name = bfd_malloc (len1 + len2 + len3 + 9);
5739   if (name == NULL)
5740     return FALSE;
5741   sprintf (name, "%08x", (unsigned) ent->addend & 0xffffffff);
5742   if (ent->sec)
5743     memcpy (name + 8, ent->sec->name, len3);
5744   memcpy (name + 8 + len3, stub, len2);
5745   memcpy (name + 8 + len3 + len2, h->root.root.string, len1 + 1);
5746   sh = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
5747   if (sh == NULL)
5748     return FALSE;
5749   if (sh->root.type == bfd_link_hash_new)
5750     {
5751       sh->root.type = bfd_link_hash_defined;
5752       sh->root.u.def.section = htab->glink;
5753       sh->root.u.def.value = ent->glink_offset;
5754       sh->ref_regular = 1;
5755       sh->def_regular = 1;
5756       sh->ref_regular_nonweak = 1;
5757       sh->forced_local = 1;
5758       sh->non_elf = 0;
5759       sh->root.linker_def = 1;
5760     }
5761   return TRUE;
5762 }
5763
5764 /* Allocate NEED contiguous space in .got, and return the offset.
5765    Handles allocation of the got header when crossing 32k.  */
5766
5767 static bfd_vma
5768 allocate_got (struct ppc_elf_link_hash_table *htab, unsigned int need)
5769 {
5770   bfd_vma where;
5771   unsigned int max_before_header;
5772
5773   if (htab->plt_type == PLT_VXWORKS)
5774     {
5775       where = htab->got->size;
5776       htab->got->size += need;
5777     }
5778   else
5779     {
5780       max_before_header = htab->plt_type == PLT_NEW ? 32768 : 32764;
5781       if (need <= htab->got_gap)
5782         {
5783           where = max_before_header - htab->got_gap;
5784           htab->got_gap -= need;
5785         }
5786       else
5787         {
5788           if (htab->got->size + need > max_before_header
5789               && htab->got->size <= max_before_header)
5790             {
5791               htab->got_gap = max_before_header - htab->got->size;
5792               htab->got->size = max_before_header + htab->got_header_size;
5793             }
5794           where = htab->got->size;
5795           htab->got->size += need;
5796         }
5797     }
5798   return where;
5799 }
5800
5801 /* Allocate space in associated reloc sections for dynamic relocs.  */
5802
5803 static bfd_boolean
5804 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5805 {
5806   struct bfd_link_info *info = inf;
5807   struct ppc_elf_link_hash_entry *eh;
5808   struct ppc_elf_link_hash_table *htab;
5809   struct elf_dyn_relocs *p;
5810
5811   if (h->root.type == bfd_link_hash_indirect)
5812     return TRUE;
5813
5814   htab = ppc_elf_hash_table (info);
5815   if (htab->elf.dynamic_sections_created
5816       || h->type == STT_GNU_IFUNC)
5817     {
5818       struct plt_entry *ent;
5819       bfd_boolean doneone = FALSE;
5820       bfd_vma plt_offset = 0, glink_offset = 0;
5821       bfd_boolean dyn;
5822
5823       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5824         if (ent->plt.refcount > 0)
5825           {
5826             /* Make sure this symbol is output as a dynamic symbol.  */
5827             if (h->dynindx == -1
5828                 && !h->forced_local
5829                 && !h->def_regular
5830                 && htab->elf.dynamic_sections_created)
5831               {
5832                 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5833                   return FALSE;
5834               }
5835
5836             dyn = htab->elf.dynamic_sections_created;
5837             if (bfd_link_pic (info)
5838                 || h->type == STT_GNU_IFUNC
5839                 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
5840               {
5841                 asection *s = htab->plt;
5842                 if (!dyn || h->dynindx == -1)
5843                   s = htab->iplt;
5844
5845                 if (htab->plt_type == PLT_NEW || !dyn || h->dynindx == -1)
5846                   {
5847                     if (!doneone)
5848                       {
5849                         plt_offset = s->size;
5850                         s->size += 4;
5851                       }
5852                     ent->plt.offset = plt_offset;
5853
5854                     s = htab->glink;
5855                     if (!doneone || bfd_link_pic (info))
5856                       {
5857                         glink_offset = s->size;
5858                         s->size += GLINK_ENTRY_SIZE;
5859                         if (h == htab->tls_get_addr
5860                             && !htab->params->no_tls_get_addr_opt)
5861                           s->size += TLS_GET_ADDR_GLINK_SIZE - GLINK_ENTRY_SIZE;
5862                       }
5863                     if (!doneone
5864                         && !bfd_link_pic (info)
5865                         && h->def_dynamic
5866                         && !h->def_regular)
5867                       {
5868                         h->root.u.def.section = s;
5869                         h->root.u.def.value = glink_offset;
5870                       }
5871                     ent->glink_offset = glink_offset;
5872
5873                     if (htab->params->emit_stub_syms
5874                         && !add_stub_sym (ent, h, info))
5875                       return FALSE;
5876                   }
5877                 else
5878                   {
5879                     if (!doneone)
5880                       {
5881                         /* If this is the first .plt entry, make room
5882                            for the special first entry.  */
5883                         if (s->size == 0)
5884                           s->size += htab->plt_initial_entry_size;
5885
5886                         /* The PowerPC PLT is actually composed of two
5887                            parts, the first part is 2 words (for a load
5888                            and a jump), and then there is a remaining
5889                            word available at the end.  */
5890                         plt_offset = (htab->plt_initial_entry_size
5891                                       + (htab->plt_slot_size
5892                                          * ((s->size
5893                                              - htab->plt_initial_entry_size)
5894                                             / htab->plt_entry_size)));
5895
5896                         /* If this symbol is not defined in a regular
5897                            file, and we are not generating a shared
5898                            library, then set the symbol to this location
5899                            in the .plt.  This is to avoid text
5900                            relocations, and is required to make
5901                            function pointers compare as equal between
5902                            the normal executable and the shared library.  */
5903                         if (! bfd_link_pic (info)
5904                             && h->def_dynamic
5905                             && !h->def_regular)
5906                           {
5907                             h->root.u.def.section = s;
5908                             h->root.u.def.value = plt_offset;
5909                           }
5910
5911                         /* Make room for this entry.  */
5912                         s->size += htab->plt_entry_size;
5913                         /* After the 8192nd entry, room for two entries
5914                            is allocated.  */
5915                         if (htab->plt_type == PLT_OLD
5916                             && (s->size - htab->plt_initial_entry_size)
5917                                 / htab->plt_entry_size
5918                                > PLT_NUM_SINGLE_ENTRIES)
5919                           s->size += htab->plt_entry_size;
5920                       }
5921                     ent->plt.offset = plt_offset;
5922                   }
5923
5924                 /* We also need to make an entry in the .rela.plt section.  */
5925                 if (!doneone)
5926                   {
5927                     if (!htab->elf.dynamic_sections_created
5928                         || h->dynindx == -1)
5929                       htab->reliplt->size += sizeof (Elf32_External_Rela);
5930                     else
5931                       {
5932                         htab->relplt->size += sizeof (Elf32_External_Rela);
5933
5934                         if (htab->plt_type == PLT_VXWORKS)
5935                           {
5936                             /* Allocate space for the unloaded relocations.  */
5937                             if (!bfd_link_pic (info)
5938                                 && htab->elf.dynamic_sections_created)
5939                               {
5940                                 if (ent->plt.offset
5941                                     == (bfd_vma) htab->plt_initial_entry_size)
5942                                   {
5943                                     htab->srelplt2->size
5944                                       += (sizeof (Elf32_External_Rela)
5945                                           * VXWORKS_PLTRESOLVE_RELOCS);
5946                                   }
5947
5948                                 htab->srelplt2->size
5949                                   += (sizeof (Elf32_External_Rela)
5950                                       * VXWORKS_PLT_NON_JMP_SLOT_RELOCS);
5951                               }
5952
5953                             /* Every PLT entry has an associated GOT entry in
5954                                .got.plt.  */
5955                             htab->sgotplt->size += 4;
5956                           }
5957                       }
5958                     doneone = TRUE;
5959                   }
5960               }
5961             else
5962               ent->plt.offset = (bfd_vma) -1;
5963           }
5964         else
5965           ent->plt.offset = (bfd_vma) -1;
5966
5967       if (!doneone)
5968         {
5969           h->plt.plist = NULL;
5970           h->needs_plt = 0;
5971         }
5972     }
5973   else
5974     {
5975       h->plt.plist = NULL;
5976       h->needs_plt = 0;
5977     }
5978
5979   eh = (struct ppc_elf_link_hash_entry *) h;
5980   if (eh->elf.got.refcount > 0
5981       || (ELIMINATE_COPY_RELOCS
5982           && !eh->elf.def_regular
5983           && eh->elf.protected_def
5984           && eh->has_addr16_ha
5985           && eh->has_addr16_lo
5986           && htab->params->pic_fixup > 0))
5987     {
5988       bfd_boolean dyn;
5989       unsigned int need;
5990
5991       /* Make sure this symbol is output as a dynamic symbol.  */
5992       if (eh->elf.dynindx == -1
5993           && !eh->elf.forced_local
5994           && eh->elf.type != STT_GNU_IFUNC
5995           && htab->elf.dynamic_sections_created)
5996         {
5997           if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf))
5998             return FALSE;
5999         }
6000
6001       need = 0;
6002       if ((eh->tls_mask & TLS_TLS) != 0)
6003         {
6004           if ((eh->tls_mask & TLS_LD) != 0)
6005             {
6006               if (!eh->elf.def_dynamic)
6007                 /* We'll just use htab->tlsld_got.offset.  This should
6008                    always be the case.  It's a little odd if we have
6009                    a local dynamic reloc against a non-local symbol.  */
6010                 htab->tlsld_got.refcount += 1;
6011               else
6012                 need += 8;
6013             }
6014           if ((eh->tls_mask & TLS_GD) != 0)
6015             need += 8;
6016           if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
6017             need += 4;
6018           if ((eh->tls_mask & TLS_DTPREL) != 0)
6019             need += 4;
6020         }
6021       else
6022         need += 4;
6023       if (need == 0)
6024         eh->elf.got.offset = (bfd_vma) -1;
6025       else
6026         {
6027           eh->elf.got.offset = allocate_got (htab, need);
6028           dyn = htab->elf.dynamic_sections_created;
6029           if ((bfd_link_pic (info)
6030                || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf))
6031               && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT
6032                   || eh->elf.root.type != bfd_link_hash_undefweak))
6033             {
6034               asection *rsec = htab->relgot;
6035
6036               if (eh->elf.type == STT_GNU_IFUNC)
6037                 rsec = htab->reliplt;
6038               /* All the entries we allocated need relocs.
6039                  Except LD only needs one.  */
6040               if ((eh->tls_mask & TLS_LD) != 0
6041                   && eh->elf.def_dynamic)
6042                 need -= 4;
6043               rsec->size += need * (sizeof (Elf32_External_Rela) / 4);
6044             }
6045         }
6046     }
6047   else
6048     eh->elf.got.offset = (bfd_vma) -1;
6049
6050   if (eh->dyn_relocs == NULL
6051       || !htab->elf.dynamic_sections_created)
6052     return TRUE;
6053
6054   /* In the shared -Bsymbolic case, discard space allocated for
6055      dynamic pc-relative relocs against symbols which turn out to be
6056      defined in regular objects.  For the normal shared case, discard
6057      space for relocs that have become local due to symbol visibility
6058      changes.  */
6059
6060   if (bfd_link_pic (info))
6061     {
6062       /* Relocs that use pc_count are those that appear on a call insn,
6063          or certain REL relocs (see must_be_dyn_reloc) that can be
6064          generated via assembly.  We want calls to protected symbols to
6065          resolve directly to the function rather than going via the plt.
6066          If people want function pointer comparisons to work as expected
6067          then they should avoid writing weird assembly.  */
6068       if (SYMBOL_CALLS_LOCAL (info, h))
6069         {
6070           struct elf_dyn_relocs **pp;
6071
6072           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
6073             {
6074               p->count -= p->pc_count;
6075               p->pc_count = 0;
6076               if (p->count == 0)
6077                 *pp = p->next;
6078               else
6079                 pp = &p->next;
6080             }
6081         }
6082
6083       if (htab->is_vxworks)
6084         {
6085           struct elf_dyn_relocs **pp;
6086
6087           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
6088             {
6089               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
6090                 *pp = p->next;
6091               else
6092                 pp = &p->next;
6093             }
6094         }
6095
6096       /* Discard relocs on undefined symbols that must be local.  */
6097       if (eh->dyn_relocs != NULL
6098           && h->root.type == bfd_link_hash_undefined
6099           && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
6100               || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
6101         eh->dyn_relocs = NULL;
6102
6103       /* Also discard relocs on undefined weak syms with non-default
6104          visibility.  */
6105       if (eh->dyn_relocs != NULL
6106           && h->root.type == bfd_link_hash_undefweak)
6107         {
6108           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
6109             eh->dyn_relocs = NULL;
6110
6111           /* Make sure undefined weak symbols are output as a dynamic
6112              symbol in PIEs.  */
6113           else if (h->dynindx == -1
6114                    && !h->forced_local
6115                    && !h->def_regular)
6116             {
6117               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6118                 return FALSE;
6119             }
6120         }
6121     }
6122   else if (ELIMINATE_COPY_RELOCS)
6123     {
6124       /* For the non-shared case, discard space for relocs against
6125          symbols which turn out to need copy relocs or are not
6126          dynamic.  */
6127
6128       if (!h->non_got_ref
6129           && !h->def_regular
6130           && !(h->protected_def
6131                && eh->has_addr16_ha
6132                && eh->has_addr16_lo
6133                && htab->params->pic_fixup > 0))
6134         {
6135           /* Make sure this symbol is output as a dynamic symbol.
6136              Undefined weak syms won't yet be marked as dynamic.  */
6137           if (h->dynindx == -1
6138               && !h->forced_local)
6139             {
6140               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6141                 return FALSE;
6142             }
6143
6144           /* If that succeeded, we know we'll be keeping all the
6145              relocs.  */
6146           if (h->dynindx != -1)
6147             goto keep;
6148         }
6149
6150       eh->dyn_relocs = NULL;
6151
6152     keep: ;
6153     }
6154
6155   /* Finally, allocate space.  */
6156   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6157     {
6158       asection *sreloc = elf_section_data (p->sec)->sreloc;
6159       if (eh->elf.type == STT_GNU_IFUNC)
6160         sreloc = htab->reliplt;
6161       sreloc->size += p->count * sizeof (Elf32_External_Rela);
6162     }
6163
6164   return TRUE;
6165 }
6166
6167 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
6168    read-only sections.  */
6169
6170 static bfd_boolean
6171 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
6172 {
6173   if (h->root.type == bfd_link_hash_indirect)
6174     return TRUE;
6175
6176   if (readonly_dynrelocs (h))
6177     {
6178       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
6179
6180       /* Not an error, just cut short the traversal.  */
6181       return FALSE;
6182     }
6183   return TRUE;
6184 }
6185
6186 static const unsigned char glink_eh_frame_cie[] =
6187 {
6188   0, 0, 0, 16,                          /* length.  */
6189   0, 0, 0, 0,                           /* id.  */
6190   1,                                    /* CIE version.  */
6191   'z', 'R', 0,                          /* Augmentation string.  */
6192   4,                                    /* Code alignment.  */
6193   0x7c,                                 /* Data alignment.  */
6194   65,                                   /* RA reg.  */
6195   1,                                    /* Augmentation size.  */
6196   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
6197   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
6198 };
6199
6200 /* Set the sizes of the dynamic sections.  */
6201
6202 static bfd_boolean
6203 ppc_elf_size_dynamic_sections (bfd *output_bfd,
6204                                struct bfd_link_info *info)
6205 {
6206   struct ppc_elf_link_hash_table *htab;
6207   asection *s;
6208   bfd_boolean relocs;
6209   bfd *ibfd;
6210
6211 #ifdef DEBUG
6212   fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
6213 #endif
6214
6215   htab = ppc_elf_hash_table (info);
6216   BFD_ASSERT (htab->elf.dynobj != NULL);
6217
6218   if (elf_hash_table (info)->dynamic_sections_created)
6219     {
6220       /* Set the contents of the .interp section to the interpreter.  */
6221       if (bfd_link_executable (info) && !info->nointerp)
6222         {
6223           s = bfd_get_linker_section (htab->elf.dynobj, ".interp");
6224           BFD_ASSERT (s != NULL);
6225           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6226           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6227         }
6228     }
6229
6230   if (htab->plt_type == PLT_OLD)
6231     htab->got_header_size = 16;
6232   else if (htab->plt_type == PLT_NEW)
6233     htab->got_header_size = 12;
6234
6235   /* Set up .got offsets for local syms, and space for local dynamic
6236      relocs.  */
6237   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6238     {
6239       bfd_signed_vma *local_got;
6240       bfd_signed_vma *end_local_got;
6241       struct plt_entry **local_plt;
6242       struct plt_entry **end_local_plt;
6243       char *lgot_masks;
6244       bfd_size_type locsymcount;
6245       Elf_Internal_Shdr *symtab_hdr;
6246
6247       if (!is_ppc_elf (ibfd))
6248         continue;
6249
6250       for (s = ibfd->sections; s != NULL; s = s->next)
6251         {
6252           struct ppc_dyn_relocs *p;
6253
6254           for (p = ((struct ppc_dyn_relocs *)
6255                     elf_section_data (s)->local_dynrel);
6256                p != NULL;
6257                p = p->next)
6258             {
6259               if (!bfd_is_abs_section (p->sec)
6260                   && bfd_is_abs_section (p->sec->output_section))
6261                 {
6262                   /* Input section has been discarded, either because
6263                      it is a copy of a linkonce section or due to
6264                      linker script /DISCARD/, so we'll be discarding
6265                      the relocs too.  */
6266                 }
6267               else if (htab->is_vxworks
6268                        && strcmp (p->sec->output_section->name,
6269                                   ".tls_vars") == 0)
6270                 {
6271                   /* Relocations in vxworks .tls_vars sections are
6272                      handled specially by the loader.  */
6273                 }
6274               else if (p->count != 0)
6275                 {
6276                   asection *sreloc = elf_section_data (p->sec)->sreloc;
6277                   if (p->ifunc)
6278                     sreloc = htab->reliplt;
6279                   sreloc->size += p->count * sizeof (Elf32_External_Rela);
6280                   if ((p->sec->output_section->flags
6281                        & (SEC_READONLY | SEC_ALLOC))
6282                       == (SEC_READONLY | SEC_ALLOC))
6283                     info->flags |= DF_TEXTREL;
6284                 }
6285             }
6286         }
6287
6288       local_got = elf_local_got_refcounts (ibfd);
6289       if (!local_got)
6290         continue;
6291
6292       symtab_hdr = &elf_symtab_hdr (ibfd);
6293       locsymcount = symtab_hdr->sh_info;
6294       end_local_got = local_got + locsymcount;
6295       local_plt = (struct plt_entry **) end_local_got;
6296       end_local_plt = local_plt + locsymcount;
6297       lgot_masks = (char *) end_local_plt;
6298
6299       for (; local_got < end_local_got; ++local_got, ++lgot_masks)
6300         if (*local_got > 0)
6301           {
6302             unsigned int need = 0;
6303             if ((*lgot_masks & TLS_TLS) != 0)
6304               {
6305                 if ((*lgot_masks & TLS_GD) != 0)
6306                   need += 8;
6307                 if ((*lgot_masks & TLS_LD) != 0)
6308                   htab->tlsld_got.refcount += 1;
6309                 if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
6310                   need += 4;
6311                 if ((*lgot_masks & TLS_DTPREL) != 0)
6312                   need += 4;
6313               }
6314             else
6315               need += 4;
6316             if (need == 0)
6317               *local_got = (bfd_vma) -1;
6318             else
6319               {
6320                 *local_got = allocate_got (htab, need);
6321                 if (bfd_link_pic (info))
6322                   {
6323                     asection *srel = htab->relgot;
6324                     if ((*lgot_masks & PLT_IFUNC) != 0)
6325                       srel = htab->reliplt;
6326                     srel->size += need * (sizeof (Elf32_External_Rela) / 4);
6327                   }
6328               }
6329           }
6330         else
6331           *local_got = (bfd_vma) -1;
6332
6333       if (htab->is_vxworks)
6334         continue;
6335
6336       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
6337       for (; local_plt < end_local_plt; ++local_plt)
6338         {
6339           struct plt_entry *ent;
6340           bfd_boolean doneone = FALSE;
6341           bfd_vma plt_offset = 0, glink_offset = 0;
6342
6343           for (ent = *local_plt; ent != NULL; ent = ent->next)
6344             if (ent->plt.refcount > 0)
6345               {
6346                 s = htab->iplt;
6347
6348                 if (!doneone)
6349                   {
6350                     plt_offset = s->size;
6351                     s->size += 4;
6352                   }
6353                 ent->plt.offset = plt_offset;
6354
6355                 s = htab->glink;
6356                 if (!doneone || bfd_link_pic (info))
6357                   {
6358                     glink_offset = s->size;
6359                     s->size += GLINK_ENTRY_SIZE;
6360                   }
6361                 ent->glink_offset = glink_offset;
6362
6363                 if (!doneone)
6364                   {
6365                     htab->reliplt->size += sizeof (Elf32_External_Rela);
6366                     doneone = TRUE;
6367                   }
6368               }
6369             else
6370               ent->plt.offset = (bfd_vma) -1;
6371         }
6372     }
6373
6374   /* Allocate space for global sym dynamic relocs.  */
6375   elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
6376
6377   if (htab->tlsld_got.refcount > 0)
6378     {
6379       htab->tlsld_got.offset = allocate_got (htab, 8);
6380       if (bfd_link_pic (info))
6381         htab->relgot->size += sizeof (Elf32_External_Rela);
6382     }
6383   else
6384     htab->tlsld_got.offset = (bfd_vma) -1;
6385
6386   if (htab->got != NULL && htab->plt_type != PLT_VXWORKS)
6387     {
6388       unsigned int g_o_t = 32768;
6389
6390       /* If we haven't allocated the header, do so now.  When we get here,
6391          for old plt/got the got size will be 0 to 32764 (not allocated),
6392          or 32780 to 65536 (header allocated).  For new plt/got, the
6393          corresponding ranges are 0 to 32768 and 32780 to 65536.  */
6394       if (htab->got->size <= 32768)
6395         {
6396           g_o_t = htab->got->size;
6397           if (htab->plt_type == PLT_OLD)
6398             g_o_t += 4;
6399           htab->got->size += htab->got_header_size;
6400         }
6401
6402       htab->elf.hgot->root.u.def.value = g_o_t;
6403     }
6404   if (bfd_link_pic (info))
6405     {
6406       struct elf_link_hash_entry *sda = htab->sdata[0].sym;
6407
6408       sda->root.u.def.section = htab->elf.hgot->root.u.def.section;
6409       sda->root.u.def.value = htab->elf.hgot->root.u.def.value;
6410     }
6411   if (info->emitrelocations)
6412     {
6413       struct elf_link_hash_entry *sda = htab->sdata[0].sym;
6414
6415       if (sda != NULL && sda->ref_regular)
6416         sda->root.u.def.section->flags |= SEC_KEEP;
6417       sda = htab->sdata[1].sym;
6418       if (sda != NULL && sda->ref_regular)
6419         sda->root.u.def.section->flags |= SEC_KEEP;
6420     }
6421
6422   if (htab->glink != NULL
6423       && htab->glink->size != 0
6424       && htab->elf.dynamic_sections_created)
6425     {
6426       htab->glink_pltresolve = htab->glink->size;
6427       /* Space for the branch table.  */
6428       htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4;
6429       /* Pad out to align the start of PLTresolve.  */
6430       htab->glink->size += -htab->glink->size & (htab->params->ppc476_workaround
6431                                                  ? 63 : 15);
6432       htab->glink->size += GLINK_PLTRESOLVE;
6433
6434       if (htab->params->emit_stub_syms)
6435         {
6436           struct elf_link_hash_entry *sh;
6437           sh = elf_link_hash_lookup (&htab->elf, "__glink",
6438                                      TRUE, FALSE, FALSE);
6439           if (sh == NULL)
6440             return FALSE;
6441           if (sh->root.type == bfd_link_hash_new)
6442             {
6443               sh->root.type = bfd_link_hash_defined;
6444               sh->root.u.def.section = htab->glink;
6445               sh->root.u.def.value = htab->glink_pltresolve;
6446               sh->ref_regular = 1;
6447               sh->def_regular = 1;
6448               sh->ref_regular_nonweak = 1;
6449               sh->forced_local = 1;
6450               sh->non_elf = 0;
6451               sh->root.linker_def = 1;
6452             }
6453           sh = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
6454                                      TRUE, FALSE, FALSE);
6455           if (sh == NULL)
6456             return FALSE;
6457           if (sh->root.type == bfd_link_hash_new)
6458             {
6459               sh->root.type = bfd_link_hash_defined;
6460               sh->root.u.def.section = htab->glink;
6461               sh->root.u.def.value = htab->glink->size - GLINK_PLTRESOLVE;
6462               sh->ref_regular = 1;
6463               sh->def_regular = 1;
6464               sh->ref_regular_nonweak = 1;
6465               sh->forced_local = 1;
6466               sh->non_elf = 0;
6467               sh->root.linker_def = 1;
6468             }
6469         }
6470     }
6471
6472   if (htab->glink != NULL
6473       && htab->glink->size != 0
6474       && htab->glink_eh_frame != NULL
6475       && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
6476       && _bfd_elf_eh_frame_present (info))
6477     {
6478       s = htab->glink_eh_frame;
6479       s->size = sizeof (glink_eh_frame_cie) + 20;
6480       if (bfd_link_pic (info))
6481         {
6482           s->size += 4;
6483           if (htab->glink->size - GLINK_PLTRESOLVE + 8 >= 256)
6484             s->size += 4;
6485         }
6486     }
6487
6488   /* We've now determined the sizes of the various dynamic sections.
6489      Allocate memory for them.  */
6490   relocs = FALSE;
6491   for (s = htab->elf.dynobj->sections; s != NULL; s = s->next)
6492     {
6493       bfd_boolean strip_section = TRUE;
6494
6495       if ((s->flags & SEC_LINKER_CREATED) == 0)
6496         continue;
6497
6498       if (s == htab->plt
6499           || s == htab->got)
6500         {
6501           /* We'd like to strip these sections if they aren't needed, but if
6502              we've exported dynamic symbols from them we must leave them.
6503              It's too late to tell BFD to get rid of the symbols.  */
6504           if (htab->elf.hplt != NULL)
6505             strip_section = FALSE;
6506           /* Strip this section if we don't need it; see the
6507              comment below.  */
6508         }
6509       else if (s == htab->iplt
6510                || s == htab->glink
6511                || s == htab->glink_eh_frame
6512                || s == htab->sgotplt
6513                || s == htab->sbss
6514                || s == htab->dynbss
6515                || s == htab->dynsbss)
6516         {
6517           /* Strip these too.  */
6518         }
6519       else if (s == htab->sdata[0].section
6520                || s == htab->sdata[1].section)
6521         {
6522           strip_section = (s->flags & SEC_KEEP) == 0;
6523         }
6524       else if (CONST_STRNEQ (bfd_get_section_name (htab->elf.dynobj, s),
6525                              ".rela"))
6526         {
6527           if (s->size != 0)
6528             {
6529               /* Remember whether there are any relocation sections.  */
6530               relocs = TRUE;
6531
6532               /* We use the reloc_count field as a counter if we need
6533                  to copy relocs into the output file.  */
6534               s->reloc_count = 0;
6535             }
6536         }
6537       else
6538         {
6539           /* It's not one of our sections, so don't allocate space.  */
6540           continue;
6541         }
6542
6543       if (s->size == 0 && strip_section)
6544         {
6545           /* If we don't need this section, strip it from the
6546              output file.  This is mostly to handle .rela.bss and
6547              .rela.plt.  We must create both sections in
6548              create_dynamic_sections, because they must be created
6549              before the linker maps input sections to output
6550              sections.  The linker does that before
6551              adjust_dynamic_symbol is called, and it is that
6552              function which decides whether anything needs to go
6553              into these sections.  */
6554           s->flags |= SEC_EXCLUDE;
6555           continue;
6556         }
6557
6558       if ((s->flags & SEC_HAS_CONTENTS) == 0)
6559         continue;
6560
6561       /* Allocate memory for the section contents.  */
6562       s->contents = bfd_zalloc (htab->elf.dynobj, s->size);
6563       if (s->contents == NULL)
6564         return FALSE;
6565     }
6566
6567   if (htab->elf.dynamic_sections_created)
6568     {
6569       /* Add some entries to the .dynamic section.  We fill in the
6570          values later, in ppc_elf_finish_dynamic_sections, but we
6571          must add the entries now so that we get the correct size for
6572          the .dynamic section.  The DT_DEBUG entry is filled in by the
6573          dynamic linker and used by the debugger.  */
6574 #define add_dynamic_entry(TAG, VAL) \
6575   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6576
6577       if (bfd_link_executable (info))
6578         {
6579           if (!add_dynamic_entry (DT_DEBUG, 0))
6580             return FALSE;
6581         }
6582
6583       if (htab->plt != NULL && htab->plt->size != 0)
6584         {
6585           if (!add_dynamic_entry (DT_PLTGOT, 0)
6586               || !add_dynamic_entry (DT_PLTRELSZ, 0)
6587               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
6588               || !add_dynamic_entry (DT_JMPREL, 0))
6589             return FALSE;
6590         }
6591
6592       if (htab->plt_type == PLT_NEW
6593           && htab->glink != NULL
6594           && htab->glink->size != 0)
6595         {
6596           if (!add_dynamic_entry (DT_PPC_GOT, 0))
6597             return FALSE;
6598           if (!htab->params->no_tls_get_addr_opt
6599               && htab->tls_get_addr != NULL
6600               && htab->tls_get_addr->plt.plist != NULL
6601               && !add_dynamic_entry (DT_PPC_OPT, PPC_OPT_TLS))
6602             return FALSE;
6603         }
6604
6605       if (relocs)
6606         {
6607           if (!add_dynamic_entry (DT_RELA, 0)
6608               || !add_dynamic_entry (DT_RELASZ, 0)
6609               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
6610             return FALSE;
6611         }
6612
6613       /* If any dynamic relocs apply to a read-only section, then we
6614          need a DT_TEXTREL entry.  */
6615       if ((info->flags & DF_TEXTREL) == 0)
6616         elf_link_hash_traverse (elf_hash_table (info), maybe_set_textrel,
6617                                 info);
6618
6619       if ((info->flags & DF_TEXTREL) != 0)
6620         {
6621           if (!add_dynamic_entry (DT_TEXTREL, 0))
6622             return FALSE;
6623         }
6624       if (htab->is_vxworks
6625           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
6626         return FALSE;
6627    }
6628 #undef add_dynamic_entry
6629
6630   if (htab->glink_eh_frame != NULL
6631       && htab->glink_eh_frame->contents != NULL)
6632     {
6633       unsigned char *p = htab->glink_eh_frame->contents;
6634       bfd_vma val;
6635
6636       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
6637       /* CIE length (rewrite in case little-endian).  */
6638       bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
6639       p += sizeof (glink_eh_frame_cie);
6640       /* FDE length.  */
6641       val = htab->glink_eh_frame->size - 4 - sizeof (glink_eh_frame_cie);
6642       bfd_put_32 (htab->elf.dynobj, val, p);
6643       p += 4;
6644       /* CIE pointer.  */
6645       val = p - htab->glink_eh_frame->contents;
6646       bfd_put_32 (htab->elf.dynobj, val, p);
6647       p += 4;
6648       /* Offset to .glink.  Set later.  */
6649       p += 4;
6650       /* .glink size.  */
6651       bfd_put_32 (htab->elf.dynobj, htab->glink->size, p);
6652       p += 4;
6653       /* Augmentation.  */
6654       p += 1;
6655
6656       if (bfd_link_pic (info)
6657           && htab->elf.dynamic_sections_created)
6658         {
6659           bfd_vma adv = (htab->glink->size - GLINK_PLTRESOLVE + 8) >> 2;
6660           if (adv < 64)
6661             *p++ = DW_CFA_advance_loc + adv;
6662           else if (adv < 256)
6663             {
6664               *p++ = DW_CFA_advance_loc1;
6665               *p++ = adv;
6666             }
6667           else if (adv < 65536)
6668             {
6669               *p++ = DW_CFA_advance_loc2;
6670               bfd_put_16 (htab->elf.dynobj, adv, p);
6671               p += 2;
6672             }
6673           else
6674             {
6675               *p++ = DW_CFA_advance_loc4;
6676               bfd_put_32 (htab->elf.dynobj, adv, p);
6677               p += 4;
6678             }
6679           *p++ = DW_CFA_register;
6680           *p++ = 65;
6681           p++;
6682           *p++ = DW_CFA_advance_loc + 4;
6683           *p++ = DW_CFA_restore_extended;
6684           *p++ = 65;
6685         }
6686       BFD_ASSERT ((bfd_vma) ((p + 3 - htab->glink_eh_frame->contents) & -4)
6687                   == htab->glink_eh_frame->size);
6688     }
6689
6690   return TRUE;
6691 }
6692
6693 /* Arrange to have _SDA_BASE_ or _SDA2_BASE_ stripped from the output
6694    if it looks like nothing is using them.  */
6695
6696 static void
6697 maybe_strip_sdasym (bfd *output_bfd, elf_linker_section_t *lsect)
6698 {
6699   struct elf_link_hash_entry *sda = lsect->sym;
6700
6701   if (sda != NULL && !sda->ref_regular && sda->dynindx == -1)
6702     {
6703       asection *s;
6704
6705       s = bfd_get_section_by_name (output_bfd, lsect->name);
6706       if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
6707         {
6708           s = bfd_get_section_by_name (output_bfd, lsect->bss_name);
6709           if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
6710             {
6711               sda->def_regular = 0;
6712               /* This is somewhat magic.  See elf_link_output_extsym.  */
6713               sda->ref_dynamic = 1;
6714               sda->forced_local = 0;
6715             }
6716         }
6717     }
6718 }
6719
6720 void
6721 ppc_elf_maybe_strip_sdata_syms (struct bfd_link_info *info)
6722 {
6723   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
6724
6725   if (htab != NULL)
6726     {
6727       maybe_strip_sdasym (info->output_bfd, &htab->sdata[0]);
6728       maybe_strip_sdasym (info->output_bfd, &htab->sdata[1]);
6729     }
6730 }
6731
6732
6733 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
6734
6735 static bfd_boolean
6736 ppc_elf_hash_symbol (struct elf_link_hash_entry *h)
6737 {
6738   if (h->plt.plist != NULL
6739       && !h->def_regular
6740       && (!h->pointer_equality_needed
6741           || !h->ref_regular_nonweak))
6742     return FALSE;
6743
6744   return _bfd_elf_hash_symbol (h);
6745 }
6746 \f
6747 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
6748
6749 /* Relaxation trampolines.  r12 is available for clobbering (r11, is
6750    used for some functions that are allowed to break the ABI).  */
6751 static const int shared_stub_entry[] =
6752   {
6753     0x7c0802a6, /* mflr 0 */
6754     0x429f0005, /* bcl 20, 31, .Lxxx */
6755     0x7d8802a6, /* mflr 12 */
6756     0x3d8c0000, /* addis 12, 12, (xxx-.Lxxx)@ha */
6757     0x398c0000, /* addi 12, 12, (xxx-.Lxxx)@l */
6758     0x7c0803a6, /* mtlr 0 */
6759     0x7d8903a6, /* mtctr 12 */
6760     0x4e800420, /* bctr */
6761   };
6762
6763 static const int stub_entry[] =
6764   {
6765     0x3d800000, /* lis 12,xxx@ha */
6766     0x398c0000, /* addi 12,12,xxx@l */
6767     0x7d8903a6, /* mtctr 12 */
6768     0x4e800420, /* bctr */
6769   };
6770
6771 struct ppc_elf_relax_info
6772 {
6773   unsigned int workaround_size;
6774   unsigned int picfixup_size;
6775 };
6776
6777 /* This function implements long branch trampolines, and the ppc476
6778    icache bug workaround.  Any section needing trampolines or patch
6779    space for the workaround has its size extended so that we can
6780    add trampolines at the end of the section.  */
6781
6782 static bfd_boolean
6783 ppc_elf_relax_section (bfd *abfd,
6784                        asection *isec,
6785                        struct bfd_link_info *link_info,
6786                        bfd_boolean *again)
6787 {
6788   struct one_branch_fixup
6789   {
6790     struct one_branch_fixup *next;
6791     asection *tsec;
6792     /* Final link, can use the symbol offset.  For a
6793        relocatable link we use the symbol's index.  */
6794     bfd_vma toff;
6795     bfd_vma trampoff;
6796   };
6797
6798   Elf_Internal_Shdr *symtab_hdr;
6799   bfd_byte *contents = NULL;
6800   Elf_Internal_Sym *isymbuf = NULL;
6801   Elf_Internal_Rela *internal_relocs = NULL;
6802   Elf_Internal_Rela *irel, *irelend = NULL;
6803   struct one_branch_fixup *branch_fixups = NULL;
6804   struct ppc_elf_relax_info *relax_info = NULL;
6805   unsigned changes = 0;
6806   bfd_boolean workaround_change;
6807   struct ppc_elf_link_hash_table *htab;
6808   bfd_size_type trampbase, trampoff, newsize, picfixup_size;
6809   asection *got2;
6810   bfd_boolean maybe_pasted;
6811
6812   *again = FALSE;
6813
6814   /* No need to do anything with non-alloc or non-code sections.  */
6815   if ((isec->flags & SEC_ALLOC) == 0
6816       || (isec->flags & SEC_CODE) == 0
6817       || (isec->flags & SEC_LINKER_CREATED) != 0
6818       || isec->size < 4)
6819     return TRUE;
6820
6821   /* We cannot represent the required PIC relocs in the output, so don't
6822      do anything.  The linker doesn't support mixing -shared and -r
6823      anyway.  */
6824   if (bfd_link_relocatable (link_info) && bfd_link_pic (link_info))
6825     return TRUE;
6826
6827   htab = ppc_elf_hash_table (link_info);
6828   if (htab == NULL)
6829     return TRUE;
6830
6831   isec->size = (isec->size + 3) & -4;
6832   if (isec->rawsize == 0)
6833     isec->rawsize = isec->size;
6834   trampbase = isec->size;
6835
6836   BFD_ASSERT (isec->sec_info_type == SEC_INFO_TYPE_NONE
6837               || isec->sec_info_type == SEC_INFO_TYPE_TARGET);
6838   isec->sec_info_type = SEC_INFO_TYPE_TARGET;
6839
6840   if (htab->params->ppc476_workaround
6841       || htab->params->pic_fixup > 0)
6842     {
6843       if (elf_section_data (isec)->sec_info == NULL)
6844         {
6845           elf_section_data (isec)->sec_info
6846             = bfd_zalloc (abfd, sizeof (struct ppc_elf_relax_info));
6847           if (elf_section_data (isec)->sec_info == NULL)
6848             return FALSE;
6849         }
6850       relax_info = elf_section_data (isec)->sec_info;
6851       trampbase -= relax_info->workaround_size;
6852     }
6853
6854   maybe_pasted = (strcmp (isec->output_section->name, ".init") == 0
6855                   || strcmp (isec->output_section->name, ".fini") == 0);
6856   /* Space for a branch around any trampolines.  */
6857   trampoff = trampbase;
6858   if (maybe_pasted && trampbase == isec->rawsize)
6859     trampoff += 4;
6860
6861   symtab_hdr = &elf_symtab_hdr (abfd);
6862   picfixup_size = 0;
6863   if (htab->params->branch_trampolines
6864       || htab->params->pic_fixup > 0)
6865     {
6866       /* Get a copy of the native relocations.  */
6867       if (isec->reloc_count != 0)
6868         {
6869           internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL,
6870                                                        link_info->keep_memory);
6871           if (internal_relocs == NULL)
6872             goto error_return;
6873         }
6874
6875       got2 = bfd_get_section_by_name (abfd, ".got2");
6876
6877       irelend = internal_relocs + isec->reloc_count;
6878       for (irel = internal_relocs; irel < irelend; irel++)
6879         {
6880           unsigned long r_type = ELF32_R_TYPE (irel->r_info);
6881           bfd_vma toff, roff;
6882           asection *tsec;
6883           struct one_branch_fixup *f;
6884           size_t insn_offset = 0;
6885           bfd_vma max_branch_offset = 0, val;
6886           bfd_byte *hit_addr;
6887           unsigned long t0;
6888           struct elf_link_hash_entry *h;
6889           struct plt_entry **plist;
6890           unsigned char sym_type;
6891
6892           switch (r_type)
6893             {
6894             case R_PPC_REL24:
6895             case R_PPC_LOCAL24PC:
6896             case R_PPC_PLTREL24:
6897               max_branch_offset = 1 << 25;
6898               break;
6899
6900             case R_PPC_REL14:
6901             case R_PPC_REL14_BRTAKEN:
6902             case R_PPC_REL14_BRNTAKEN:
6903               max_branch_offset = 1 << 15;
6904               break;
6905
6906             case R_PPC_ADDR16_HA:
6907               if (htab->params->pic_fixup > 0)
6908                 break;
6909               continue;
6910
6911             default:
6912               continue;
6913             }
6914
6915           /* Get the value of the symbol referred to by the reloc.  */
6916           h = NULL;
6917           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6918             {
6919               /* A local symbol.  */
6920               Elf_Internal_Sym *isym;
6921
6922               /* Read this BFD's local symbols.  */
6923               if (isymbuf == NULL)
6924                 {
6925                   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6926                   if (isymbuf == NULL)
6927                     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
6928                                                     symtab_hdr->sh_info, 0,
6929                                                     NULL, NULL, NULL);
6930                   if (isymbuf == 0)
6931                     goto error_return;
6932                 }
6933               isym = isymbuf + ELF32_R_SYM (irel->r_info);
6934               if (isym->st_shndx == SHN_UNDEF)
6935                 tsec = bfd_und_section_ptr;
6936               else if (isym->st_shndx == SHN_ABS)
6937                 tsec = bfd_abs_section_ptr;
6938               else if (isym->st_shndx == SHN_COMMON)
6939                 tsec = bfd_com_section_ptr;
6940               else
6941                 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6942
6943               toff = isym->st_value;
6944               sym_type = ELF_ST_TYPE (isym->st_info);
6945             }
6946           else
6947             {
6948               /* Global symbol handling.  */
6949               unsigned long indx;
6950
6951               indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6952               h = elf_sym_hashes (abfd)[indx];
6953
6954               while (h->root.type == bfd_link_hash_indirect
6955                      || h->root.type == bfd_link_hash_warning)
6956                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6957
6958               if (h->root.type == bfd_link_hash_defined
6959                   || h->root.type == bfd_link_hash_defweak)
6960                 {
6961                   tsec = h->root.u.def.section;
6962                   toff = h->root.u.def.value;
6963                 }
6964               else if (h->root.type == bfd_link_hash_undefined
6965                        || h->root.type == bfd_link_hash_undefweak)
6966                 {
6967                   tsec = bfd_und_section_ptr;
6968                   toff = bfd_link_relocatable (link_info) ? indx : 0;
6969                 }
6970               else
6971                 continue;
6972
6973               /* If this branch is to __tls_get_addr then we may later
6974                  optimise away the call.  We won't be needing a long-
6975                  branch stub in that case.  */
6976               if (bfd_link_executable (link_info)
6977                   && h == htab->tls_get_addr
6978                   && irel != internal_relocs)
6979                 {
6980                   unsigned long t_symndx = ELF32_R_SYM (irel[-1].r_info);
6981                   unsigned long t_rtype = ELF32_R_TYPE (irel[-1].r_info);
6982                   unsigned int tls_mask = 0;
6983
6984                   /* The previous reloc should be one of R_PPC_TLSGD or
6985                      R_PPC_TLSLD, or for older object files, a reloc
6986                      on the __tls_get_addr arg setup insn.  Get tls
6987                      mask bits from the symbol on that reloc.  */
6988                   if (t_symndx < symtab_hdr->sh_info)
6989                     {
6990                       bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
6991
6992                       if (local_got_offsets != NULL)
6993                         {
6994                           struct plt_entry **local_plt = (struct plt_entry **)
6995                             (local_got_offsets + symtab_hdr->sh_info);
6996                           char *lgot_masks = (char *)
6997                             (local_plt + symtab_hdr->sh_info);
6998                           tls_mask = lgot_masks[t_symndx];
6999                         }
7000                     }
7001                   else
7002                     {
7003                       struct elf_link_hash_entry *th
7004                         = elf_sym_hashes (abfd)[t_symndx - symtab_hdr->sh_info];
7005
7006                       while (th->root.type == bfd_link_hash_indirect
7007                              || th->root.type == bfd_link_hash_warning)
7008                         th = (struct elf_link_hash_entry *) th->root.u.i.link;
7009
7010                       tls_mask
7011                         = ((struct ppc_elf_link_hash_entry *) th)->tls_mask;
7012                     }
7013
7014                   /* The mask bits tell us if the call will be
7015                      optimised away.  */
7016                   if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
7017                       && (t_rtype == R_PPC_TLSGD
7018                           || t_rtype == R_PPC_GOT_TLSGD16
7019                           || t_rtype == R_PPC_GOT_TLSGD16_LO))
7020                     continue;
7021                   if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
7022                       && (t_rtype == R_PPC_TLSLD
7023                           || t_rtype == R_PPC_GOT_TLSLD16
7024                           || t_rtype == R_PPC_GOT_TLSLD16_LO))
7025                     continue;
7026                 }
7027
7028               sym_type = h->type;
7029             }
7030
7031           if (r_type == R_PPC_ADDR16_HA)
7032             {
7033               if (h != NULL
7034                   && !h->def_regular
7035                   && h->protected_def
7036                   && ppc_elf_hash_entry (h)->has_addr16_ha
7037                   && ppc_elf_hash_entry (h)->has_addr16_lo)
7038                 picfixup_size += 12;
7039               continue;
7040             }
7041
7042           /* The condition here under which we call find_plt_ent must
7043              match that in relocate_section.  If we call find_plt_ent here
7044              but not in relocate_section, or vice versa, then the branch
7045              destination used here may be incorrect.  */
7046           plist = NULL;
7047           if (h != NULL)
7048             {
7049               /* We know is_branch_reloc (r_type) is true.  */
7050               if (h->type == STT_GNU_IFUNC
7051                   || r_type == R_PPC_PLTREL24)
7052                 plist = &h->plt.plist;
7053             }
7054           else if (sym_type == STT_GNU_IFUNC
7055                    && elf_local_got_offsets (abfd) != NULL)
7056             {
7057               bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
7058               struct plt_entry **local_plt = (struct plt_entry **)
7059                 (local_got_offsets + symtab_hdr->sh_info);
7060               plist = local_plt + ELF32_R_SYM (irel->r_info);
7061             }
7062           if (plist != NULL)
7063             {
7064               bfd_vma addend = 0;
7065               struct plt_entry *ent;
7066
7067               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (link_info))
7068                 addend = irel->r_addend;
7069               ent = find_plt_ent (plist, got2, addend);
7070               if (ent != NULL)
7071                 {
7072                   if (htab->plt_type == PLT_NEW
7073                       || h == NULL
7074                       || !htab->elf.dynamic_sections_created
7075                       || h->dynindx == -1)
7076                     {
7077                       tsec = htab->glink;
7078                       toff = ent->glink_offset;
7079                     }
7080                   else
7081                     {
7082                       tsec = htab->plt;
7083                       toff = ent->plt.offset;
7084                     }
7085                 }
7086             }
7087
7088           /* If the branch and target are in the same section, you have
7089              no hope of adding stubs.  We'll error out later should the
7090              branch overflow.  */
7091           if (tsec == isec)
7092             continue;
7093
7094           /* There probably isn't any reason to handle symbols in
7095              SEC_MERGE sections;  SEC_MERGE doesn't seem a likely
7096              attribute for a code section, and we are only looking at
7097              branches.  However, implement it correctly here as a
7098              reference for other target relax_section functions.  */
7099           if (0 && tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
7100             {
7101               /* At this stage in linking, no SEC_MERGE symbol has been
7102                  adjusted, so all references to such symbols need to be
7103                  passed through _bfd_merged_section_offset.  (Later, in
7104                  relocate_section, all SEC_MERGE symbols *except* for
7105                  section symbols have been adjusted.)
7106
7107                  gas may reduce relocations against symbols in SEC_MERGE
7108                  sections to a relocation against the section symbol when
7109                  the original addend was zero.  When the reloc is against
7110                  a section symbol we should include the addend in the
7111                  offset passed to _bfd_merged_section_offset, since the
7112                  location of interest is the original symbol.  On the
7113                  other hand, an access to "sym+addend" where "sym" is not
7114                  a section symbol should not include the addend;  Such an
7115                  access is presumed to be an offset from "sym";  The
7116                  location of interest is just "sym".  */
7117               if (sym_type == STT_SECTION)
7118                 toff += irel->r_addend;
7119
7120               toff
7121                 = _bfd_merged_section_offset (abfd, &tsec,
7122                                               elf_section_data (tsec)->sec_info,
7123                                               toff);
7124
7125               if (sym_type != STT_SECTION)
7126                 toff += irel->r_addend;
7127             }
7128           /* PLTREL24 addends are special.  */
7129           else if (r_type != R_PPC_PLTREL24)
7130             toff += irel->r_addend;
7131
7132           /* Attempted -shared link of non-pic code loses.  */
7133           if ((!bfd_link_relocatable (link_info)
7134                && tsec == bfd_und_section_ptr)
7135               || tsec->output_section == NULL
7136               || (tsec->owner != NULL
7137                   && (tsec->owner->flags & BFD_PLUGIN) != 0))
7138             continue;
7139
7140           roff = irel->r_offset;
7141
7142           /* If the branch is in range, no need to do anything.  */
7143           if (tsec != bfd_und_section_ptr
7144               && (!bfd_link_relocatable (link_info)
7145                   /* A relocatable link may have sections moved during
7146                      final link, so do not presume they remain in range.  */
7147                   || tsec->output_section == isec->output_section))
7148             {
7149               bfd_vma symaddr, reladdr;
7150
7151               symaddr = tsec->output_section->vma + tsec->output_offset + toff;
7152               reladdr = isec->output_section->vma + isec->output_offset + roff;
7153               if (symaddr - reladdr + max_branch_offset
7154                   < 2 * max_branch_offset)
7155                 continue;
7156             }
7157
7158           /* Look for an existing fixup to this address.  */
7159           for (f = branch_fixups; f ; f = f->next)
7160             if (f->tsec == tsec && f->toff == toff)
7161               break;
7162
7163           if (f == NULL)
7164             {
7165               size_t size;
7166               unsigned long stub_rtype;
7167
7168               val = trampoff - roff;
7169               if (val >= max_branch_offset)
7170                 /* Oh dear, we can't reach a trampoline.  Don't try to add
7171                    one.  We'll report an error later.  */
7172                 continue;
7173
7174               if (bfd_link_pic (link_info))
7175                 {
7176                   size = 4 * ARRAY_SIZE (shared_stub_entry);
7177                   insn_offset = 12;
7178                 }
7179               else
7180                 {
7181                   size = 4 * ARRAY_SIZE (stub_entry);
7182                   insn_offset = 0;
7183                 }
7184               stub_rtype = R_PPC_RELAX;
7185               if (tsec == htab->plt
7186                   || tsec == htab->glink)
7187                 {
7188                   stub_rtype = R_PPC_RELAX_PLT;
7189                   if (r_type == R_PPC_PLTREL24)
7190                     stub_rtype = R_PPC_RELAX_PLTREL24;
7191                 }
7192
7193               /* Hijack the old relocation.  Since we need two
7194                  relocations for this use a "composite" reloc.  */
7195               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7196                                            stub_rtype);
7197               irel->r_offset = trampoff + insn_offset;
7198               if (r_type == R_PPC_PLTREL24
7199                   && stub_rtype != R_PPC_RELAX_PLTREL24)
7200                 irel->r_addend = 0;
7201
7202               /* Record the fixup so we don't do it again this section.  */
7203               f = bfd_malloc (sizeof (*f));
7204               f->next = branch_fixups;
7205               f->tsec = tsec;
7206               f->toff = toff;
7207               f->trampoff = trampoff;
7208               branch_fixups = f;
7209
7210               trampoff += size;
7211               changes++;
7212             }
7213           else
7214             {
7215               val = f->trampoff - roff;
7216               if (val >= max_branch_offset)
7217                 continue;
7218
7219               /* Nop out the reloc, since we're finalizing things here.  */
7220               irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
7221             }
7222
7223           /* Get the section contents.  */
7224           if (contents == NULL)
7225             {
7226               /* Get cached copy if it exists.  */
7227               if (elf_section_data (isec)->this_hdr.contents != NULL)
7228                 contents = elf_section_data (isec)->this_hdr.contents;
7229               /* Go get them off disk.  */
7230               else if (!bfd_malloc_and_get_section (abfd, isec, &contents))
7231                 goto error_return;
7232             }
7233
7234           /* Fix up the existing branch to hit the trampoline.  */
7235           hit_addr = contents + roff;
7236           switch (r_type)
7237             {
7238             case R_PPC_REL24:
7239             case R_PPC_LOCAL24PC:
7240             case R_PPC_PLTREL24:
7241               t0 = bfd_get_32 (abfd, hit_addr);
7242               t0 &= ~0x3fffffc;
7243               t0 |= val & 0x3fffffc;
7244               bfd_put_32 (abfd, t0, hit_addr);
7245               break;
7246
7247             case R_PPC_REL14:
7248             case R_PPC_REL14_BRTAKEN:
7249             case R_PPC_REL14_BRNTAKEN:
7250               t0 = bfd_get_32 (abfd, hit_addr);
7251               t0 &= ~0xfffc;
7252               t0 |= val & 0xfffc;
7253               bfd_put_32 (abfd, t0, hit_addr);
7254               break;
7255             }
7256         }
7257
7258       while (branch_fixups != NULL)
7259         {
7260           struct one_branch_fixup *f = branch_fixups;
7261           branch_fixups = branch_fixups->next;
7262           free (f);
7263         }
7264     }
7265
7266   workaround_change = FALSE;
7267   newsize = trampoff;
7268   if (htab->params->ppc476_workaround
7269       && (!bfd_link_relocatable (link_info)
7270           || isec->output_section->alignment_power >= htab->params->pagesize_p2))
7271     {
7272       bfd_vma addr, end_addr;
7273       unsigned int crossings;
7274       bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
7275
7276       addr = isec->output_section->vma + isec->output_offset;
7277       end_addr = addr + trampoff;
7278       addr &= -pagesize;
7279       crossings = ((end_addr & -pagesize) - addr) >> htab->params->pagesize_p2;
7280       if (crossings != 0)
7281         {
7282           /* Keep space aligned, to ensure the patch code itself does
7283              not cross a page.  Don't decrease size calculated on a
7284              previous pass as otherwise we might never settle on a layout.  */
7285           newsize = 15 - ((end_addr - 1) & 15);
7286           newsize += crossings * 16;
7287           if (relax_info->workaround_size < newsize)
7288             {
7289               relax_info->workaround_size = newsize;
7290               workaround_change = TRUE;
7291             }
7292           /* Ensure relocate_section is called.  */
7293           isec->flags |= SEC_RELOC;
7294         }
7295       newsize = trampoff + relax_info->workaround_size;
7296     }
7297
7298   if (htab->params->pic_fixup > 0)
7299     {
7300       picfixup_size -= relax_info->picfixup_size;
7301       if (picfixup_size != 0)
7302         relax_info->picfixup_size += picfixup_size;
7303       newsize += relax_info->picfixup_size;
7304     }
7305
7306   if (changes != 0 || picfixup_size != 0 || workaround_change)
7307     isec->size = newsize;
7308
7309   if (isymbuf != NULL
7310       && symtab_hdr->contents != (unsigned char *) isymbuf)
7311     {
7312       if (! link_info->keep_memory)
7313         free (isymbuf);
7314       else
7315         {
7316           /* Cache the symbols for elf_link_input_bfd.  */
7317           symtab_hdr->contents = (unsigned char *) isymbuf;
7318         }
7319     }
7320
7321   if (contents != NULL
7322       && elf_section_data (isec)->this_hdr.contents != contents)
7323     {
7324       if (!changes && !link_info->keep_memory)
7325         free (contents);
7326       else
7327         {
7328           /* Cache the section contents for elf_link_input_bfd.  */
7329           elf_section_data (isec)->this_hdr.contents = contents;
7330         }
7331     }
7332
7333   changes += picfixup_size;
7334   if (changes != 0)
7335     {
7336       /* Append sufficient NOP relocs so we can write out relocation
7337          information for the trampolines.  */
7338       Elf_Internal_Shdr *rel_hdr;
7339       Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count)
7340                                                   * sizeof (*new_relocs));
7341       unsigned ix;
7342
7343       if (!new_relocs)
7344         goto error_return;
7345       memcpy (new_relocs, internal_relocs,
7346               isec->reloc_count * sizeof (*new_relocs));
7347       for (ix = changes; ix--;)
7348         {
7349           irel = new_relocs + ix + isec->reloc_count;
7350
7351           irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
7352         }
7353       if (internal_relocs != elf_section_data (isec)->relocs)
7354         free (internal_relocs);
7355       elf_section_data (isec)->relocs = new_relocs;
7356       isec->reloc_count += changes;
7357       rel_hdr = _bfd_elf_single_rel_hdr (isec);
7358       rel_hdr->sh_size += changes * rel_hdr->sh_entsize;
7359     }
7360   else if (internal_relocs != NULL
7361            && elf_section_data (isec)->relocs != internal_relocs)
7362     free (internal_relocs);
7363
7364   *again = changes != 0 || workaround_change;
7365   return TRUE;
7366
7367  error_return:
7368   while (branch_fixups != NULL)
7369     {
7370       struct one_branch_fixup *f = branch_fixups;
7371       branch_fixups = branch_fixups->next;
7372       free (f);
7373     }
7374   if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
7375     free (isymbuf);
7376   if (contents != NULL
7377       && elf_section_data (isec)->this_hdr.contents != contents)
7378     free (contents);
7379   if (internal_relocs != NULL
7380       && elf_section_data (isec)->relocs != internal_relocs)
7381     free (internal_relocs);
7382   return FALSE;
7383 }
7384 \f
7385 /* What to do when ld finds relocations against symbols defined in
7386    discarded sections.  */
7387
7388 static unsigned int
7389 ppc_elf_action_discarded (asection *sec)
7390 {
7391   if (strcmp (".fixup", sec->name) == 0)
7392     return 0;
7393
7394   if (strcmp (".got2", sec->name) == 0)
7395     return 0;
7396
7397   return _bfd_elf_default_action_discarded (sec);
7398 }
7399 \f
7400 /* Fill in the address for a pointer generated in a linker section.  */
7401
7402 static bfd_vma
7403 elf_finish_pointer_linker_section (bfd *input_bfd,
7404                                    elf_linker_section_t *lsect,
7405                                    struct elf_link_hash_entry *h,
7406                                    bfd_vma relocation,
7407                                    const Elf_Internal_Rela *rel)
7408 {
7409   elf_linker_section_pointers_t *linker_section_ptr;
7410
7411   BFD_ASSERT (lsect != NULL);
7412
7413   if (h != NULL)
7414     {
7415       /* Handle global symbol.  */
7416       struct ppc_elf_link_hash_entry *eh;
7417
7418       eh = (struct ppc_elf_link_hash_entry *) h;
7419       BFD_ASSERT (eh->elf.def_regular);
7420       linker_section_ptr = eh->linker_section_pointer;
7421     }
7422   else
7423     {
7424       /* Handle local symbol.  */
7425       unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
7426
7427       BFD_ASSERT (is_ppc_elf (input_bfd));
7428       BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
7429       linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx];
7430     }
7431
7432   linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr,
7433                                                         rel->r_addend,
7434                                                         lsect);
7435   BFD_ASSERT (linker_section_ptr != NULL);
7436
7437   /* Offset will always be a multiple of four, so use the bottom bit
7438      as a "written" flag.  */
7439   if ((linker_section_ptr->offset & 1) == 0)
7440     {
7441       bfd_put_32 (lsect->section->owner,
7442                   relocation + linker_section_ptr->addend,
7443                   lsect->section->contents + linker_section_ptr->offset);
7444       linker_section_ptr->offset += 1;
7445     }
7446
7447   relocation = (lsect->section->output_section->vma
7448                 + lsect->section->output_offset
7449                 + linker_section_ptr->offset - 1
7450                 - SYM_VAL (lsect->sym));
7451
7452 #ifdef DEBUG
7453   fprintf (stderr,
7454            "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
7455            lsect->name, (long) relocation, (long) relocation);
7456 #endif
7457
7458   return relocation;
7459 }
7460
7461 #define PPC_LO(v) ((v) & 0xffff)
7462 #define PPC_HI(v) (((v) >> 16) & 0xffff)
7463 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
7464
7465 static void
7466 write_glink_stub (struct plt_entry *ent, asection *plt_sec, unsigned char *p,
7467                   struct bfd_link_info *info)
7468 {
7469   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
7470   bfd *output_bfd = info->output_bfd;
7471   bfd_vma plt;
7472
7473   plt = ((ent->plt.offset & ~1)
7474          + plt_sec->output_section->vma
7475          + plt_sec->output_offset);
7476
7477   if (bfd_link_pic (info))
7478     {
7479       bfd_vma got = 0;
7480
7481       if (ent->addend >= 32768)
7482         got = (ent->addend
7483                + ent->sec->output_section->vma
7484                + ent->sec->output_offset);
7485       else if (htab->elf.hgot != NULL)
7486         got = SYM_VAL (htab->elf.hgot);
7487
7488       plt -= got;
7489
7490       if (plt + 0x8000 < 0x10000)
7491         {
7492           bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p);
7493           p += 4;
7494           bfd_put_32 (output_bfd, MTCTR_11, p);
7495           p += 4;
7496           bfd_put_32 (output_bfd, BCTR, p);
7497           p += 4;
7498           bfd_put_32 (output_bfd, htab->params->ppc476_workaround ? BA : NOP, p);
7499           p += 4;
7500         }
7501       else
7502         {
7503           bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p);
7504           p += 4;
7505           bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
7506           p += 4;
7507           bfd_put_32 (output_bfd, MTCTR_11, p);
7508           p += 4;
7509           bfd_put_32 (output_bfd, BCTR, p);
7510           p += 4;
7511         }
7512     }
7513   else
7514     {
7515       bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p);
7516       p += 4;
7517       bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
7518       p += 4;
7519       bfd_put_32 (output_bfd, MTCTR_11, p);
7520       p += 4;
7521       bfd_put_32 (output_bfd, BCTR, p);
7522       p += 4;
7523     }
7524 }
7525
7526 /* Return true if symbol is defined statically.  */
7527
7528 static bfd_boolean
7529 is_static_defined (struct elf_link_hash_entry *h)
7530 {
7531   return ((h->root.type == bfd_link_hash_defined
7532            || h->root.type == bfd_link_hash_defweak)
7533           && h->root.u.def.section != NULL
7534           && h->root.u.def.section->output_section != NULL);
7535 }
7536
7537 /* If INSN is an opcode that may be used with an @tls operand, return
7538    the transformed insn for TLS optimisation, otherwise return 0.  If
7539    REG is non-zero only match an insn with RB or RA equal to REG.  */
7540
7541 unsigned int
7542 _bfd_elf_ppc_at_tls_transform (unsigned int insn, unsigned int reg)
7543 {
7544   unsigned int rtra;
7545
7546   if ((insn & (0x3f << 26)) != 31 << 26)
7547     return 0;
7548
7549   if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
7550     rtra = insn & ((1 << 26) - (1 << 16));
7551   else if (((insn >> 16) & 0x1f) == reg)
7552     rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
7553   else
7554     return 0;
7555
7556   if ((insn & (0x3ff << 1)) == 266 << 1)
7557     /* add -> addi.  */
7558     insn = 14 << 26;
7559   else if ((insn & (0x1f << 1)) == 23 << 1
7560            && ((insn & (0x1f << 6)) < 14 << 6
7561                || ((insn & (0x1f << 6)) >= 16 << 6
7562                    && (insn & (0x1f << 6)) < 24 << 6)))
7563     /* load and store indexed -> dform.  */
7564     insn = (32 | ((insn >> 6) & 0x1f)) << 26;
7565   else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
7566     /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
7567     insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
7568   else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
7569     /* lwax -> lwa.  */
7570     insn = (58 << 26) | 2;
7571   else
7572     return 0;
7573   insn |= rtra;
7574   return insn;
7575 }
7576
7577 /* If INSN is an opcode that may be used with an @tprel operand, return
7578    the transformed insn for an undefined weak symbol, ie. with the
7579    thread pointer REG operand removed.  Otherwise return 0.  */
7580
7581 unsigned int
7582 _bfd_elf_ppc_at_tprel_transform (unsigned int insn, unsigned int reg)
7583 {
7584   if ((insn & (0x1f << 16)) == reg << 16
7585       && ((insn & (0x3f << 26)) == 14u << 26 /* addi */
7586           || (insn & (0x3f << 26)) == 15u << 26 /* addis */
7587           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
7588           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
7589           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
7590           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
7591           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
7592           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
7593           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
7594           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
7595           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
7596           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
7597           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
7598           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
7599           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
7600           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
7601               && (insn & 3) != 1)
7602           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
7603               && ((insn & 3) == 0 || (insn & 3) == 3))))
7604     {
7605       insn &= ~(0x1f << 16);
7606     }
7607   else if ((insn & (0x1f << 21)) == reg << 21
7608            && ((insn & (0x3e << 26)) == 24u << 26 /* ori, oris */
7609                || (insn & (0x3e << 26)) == 26u << 26 /* xori,xoris */
7610                || (insn & (0x3e << 26)) == 28u << 26 /* andi,andis */))
7611     {
7612       insn &= ~(0x1f << 21);
7613       insn |= (insn & (0x1f << 16)) << 5;
7614       if ((insn & (0x3e << 26)) == 26 << 26 /* xori,xoris */)
7615         insn -= 2 >> 26;  /* convert to ori,oris */
7616     }
7617   else
7618     insn = 0;
7619   return insn;
7620 }
7621
7622 static bfd_boolean
7623 is_insn_ds_form (unsigned int insn)
7624 {
7625   return ((insn & (0x3f << 26)) == 58u << 26 /* ld,ldu,lwa */
7626           || (insn & (0x3f << 26)) == 62u << 26 /* std,stdu,stq */
7627           || (insn & (0x3f << 26)) == 57u << 26 /* lfdp */
7628           || (insn & (0x3f << 26)) == 61u << 26 /* stfdp */);
7629 }
7630
7631 static bfd_boolean
7632 is_insn_dq_form (unsigned int insn)
7633 {
7634   return ((insn & (0x3f << 26)) == 56u << 26 /* lq */
7635           || ((insn & (0x3f << 26)) == (61u << 26) /* lxv, stxv */
7636               && (insn & 3) == 1));
7637 }
7638
7639 /* The RELOCATE_SECTION function is called by the ELF backend linker
7640    to handle the relocations for a section.
7641
7642    The relocs are always passed as Rela structures; if the section
7643    actually uses Rel structures, the r_addend field will always be
7644    zero.
7645
7646    This function is responsible for adjust the section contents as
7647    necessary, and (if using Rela relocs and generating a
7648    relocatable output file) adjusting the reloc addend as
7649    necessary.
7650
7651    This function does not have to worry about setting the reloc
7652    address or the reloc symbol index.
7653
7654    LOCAL_SYMS is a pointer to the swapped in local symbols.
7655
7656    LOCAL_SECTIONS is an array giving the section in the input file
7657    corresponding to the st_shndx field of each local symbol.
7658
7659    The global hash table entry for the global symbols can be found
7660    via elf_sym_hashes (input_bfd).
7661
7662    When generating relocatable output, this function must handle
7663    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
7664    going to be the section symbol corresponding to the output
7665    section, which means that the addend must be adjusted
7666    accordingly.  */
7667
7668 static bfd_boolean
7669 ppc_elf_relocate_section (bfd *output_bfd,
7670                           struct bfd_link_info *info,
7671                           bfd *input_bfd,
7672                           asection *input_section,
7673                           bfd_byte *contents,
7674                           Elf_Internal_Rela *relocs,
7675                           Elf_Internal_Sym *local_syms,
7676                           asection **local_sections)
7677 {
7678   Elf_Internal_Shdr *symtab_hdr;
7679   struct elf_link_hash_entry **sym_hashes;
7680   struct ppc_elf_link_hash_table *htab;
7681   Elf_Internal_Rela *rel;
7682   Elf_Internal_Rela *wrel;
7683   Elf_Internal_Rela *relend;
7684   Elf_Internal_Rela outrel;
7685   asection *got2;
7686   bfd_vma *local_got_offsets;
7687   bfd_boolean ret = TRUE;
7688   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
7689   bfd_boolean is_vxworks_tls;
7690   unsigned int picfixup_size = 0;
7691   struct ppc_elf_relax_info *relax_info = NULL;
7692
7693 #ifdef DEBUG
7694   _bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, "
7695                       "%ld relocations%s",
7696                       input_bfd, input_section,
7697                       (long) input_section->reloc_count,
7698                       (bfd_link_relocatable (info)) ? " (relocatable)" : "");
7699 #endif
7700
7701   got2 = bfd_get_section_by_name (input_bfd, ".got2");
7702
7703   /* Initialize howto table if not already done.  */
7704   if (!ppc_elf_howto_table[R_PPC_ADDR32])
7705     ppc_elf_howto_init ();
7706
7707   htab = ppc_elf_hash_table (info);
7708   local_got_offsets = elf_local_got_offsets (input_bfd);
7709   symtab_hdr = &elf_symtab_hdr (input_bfd);
7710   sym_hashes = elf_sym_hashes (input_bfd);
7711   /* We have to handle relocations in vxworks .tls_vars sections
7712      specially, because the dynamic loader is 'weird'.  */
7713   is_vxworks_tls = (htab->is_vxworks && bfd_link_pic (info)
7714                     && !strcmp (input_section->output_section->name,
7715                                 ".tls_vars"));
7716   if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET)
7717     relax_info = elf_section_data (input_section)->sec_info;
7718   rel = wrel = relocs;
7719   relend = relocs + input_section->reloc_count;
7720   for (; rel < relend; wrel++, rel++)
7721     {
7722       enum elf_ppc_reloc_type r_type;
7723       bfd_vma addend;
7724       bfd_reloc_status_type r;
7725       Elf_Internal_Sym *sym;
7726       asection *sec;
7727       struct elf_link_hash_entry *h;
7728       const char *sym_name;
7729       reloc_howto_type *howto;
7730       unsigned long r_symndx;
7731       bfd_vma relocation;
7732       bfd_vma branch_bit, from;
7733       bfd_boolean unresolved_reloc;
7734       bfd_boolean warned;
7735       unsigned int tls_type, tls_mask, tls_gd;
7736       struct plt_entry **ifunc;
7737       struct reloc_howto_struct alt_howto;
7738
7739     again:
7740       r_type = ELF32_R_TYPE (rel->r_info);
7741       sym = NULL;
7742       sec = NULL;
7743       h = NULL;
7744       unresolved_reloc = FALSE;
7745       warned = FALSE;
7746       r_symndx = ELF32_R_SYM (rel->r_info);
7747
7748       if (r_symndx < symtab_hdr->sh_info)
7749         {
7750           sym = local_syms + r_symndx;
7751           sec = local_sections[r_symndx];
7752           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
7753
7754           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
7755         }
7756       else
7757         {
7758           bfd_boolean ignored;
7759
7760           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
7761                                    r_symndx, symtab_hdr, sym_hashes,
7762                                    h, sec, relocation,
7763                                    unresolved_reloc, warned, ignored);
7764
7765           sym_name = h->root.root.string;
7766         }
7767
7768       if (sec != NULL && discarded_section (sec))
7769         {
7770           /* For relocs against symbols from removed linkonce sections,
7771              or sections discarded by a linker script, we just want the
7772              section contents zeroed.  Avoid any special processing.  */
7773           howto = NULL;
7774           if (r_type < R_PPC_max)
7775             howto = ppc_elf_howto_table[r_type];
7776
7777           _bfd_clear_contents (howto, input_bfd, input_section,
7778                                contents + rel->r_offset);
7779           wrel->r_offset = rel->r_offset;
7780           wrel->r_info = 0;
7781           wrel->r_addend = 0;
7782
7783           /* For ld -r, remove relocations in debug sections against
7784              sections defined in discarded sections.  Not done for
7785              non-debug to preserve relocs in .eh_frame which the
7786              eh_frame editing code expects to be present.  */
7787           if (bfd_link_relocatable (info)
7788               && (input_section->flags & SEC_DEBUGGING))
7789             wrel--;
7790
7791           continue;
7792         }
7793
7794       if (bfd_link_relocatable (info))
7795         {
7796           if (got2 != NULL
7797               && r_type == R_PPC_PLTREL24
7798               && rel->r_addend != 0)
7799             {
7800               /* R_PPC_PLTREL24 is rather special.  If non-zero, the
7801                  addend specifies the GOT pointer offset within .got2.  */
7802               rel->r_addend += got2->output_offset;
7803             }
7804           if (r_type != R_PPC_RELAX_PLT
7805               && r_type != R_PPC_RELAX_PLTREL24
7806               && r_type != R_PPC_RELAX)
7807             goto copy_reloc;
7808         }
7809
7810       /* TLS optimizations.  Replace instruction sequences and relocs
7811          based on information we collected in tls_optimize.  We edit
7812          RELOCS so that --emit-relocs will output something sensible
7813          for the final instruction stream.  */
7814       tls_mask = 0;
7815       tls_gd = 0;
7816       if (h != NULL)
7817         tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
7818       else if (local_got_offsets != NULL)
7819         {
7820           struct plt_entry **local_plt;
7821           char *lgot_masks;
7822           local_plt
7823             = (struct plt_entry **) (local_got_offsets + symtab_hdr->sh_info);
7824           lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
7825           tls_mask = lgot_masks[r_symndx];
7826         }
7827
7828       /* Ensure reloc mapping code below stays sane.  */
7829       if ((R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TLSGD16 & 3)
7830           || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
7831           || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
7832           || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3)
7833           || (R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TPREL16 & 3)
7834           || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3)
7835           || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3)
7836           || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3))
7837         abort ();
7838       switch (r_type)
7839         {
7840         default:
7841           break;
7842
7843         case R_PPC_GOT_TPREL16:
7844         case R_PPC_GOT_TPREL16_LO:
7845           if ((tls_mask & TLS_TLS) != 0
7846               && (tls_mask & TLS_TPREL) == 0)
7847             {
7848               bfd_vma insn;
7849
7850               insn = bfd_get_32 (output_bfd,
7851                                  contents + rel->r_offset - d_offset);
7852               insn &= 31 << 21;
7853               insn |= 0x3c020000;       /* addis 0,2,0 */
7854               bfd_put_32 (output_bfd, insn,
7855                           contents + rel->r_offset - d_offset);
7856               r_type = R_PPC_TPREL16_HA;
7857               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7858             }
7859           break;
7860
7861         case R_PPC_TLS:
7862           if ((tls_mask & TLS_TLS) != 0
7863               && (tls_mask & TLS_TPREL) == 0)
7864             {
7865               bfd_vma insn;
7866
7867               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
7868               insn = _bfd_elf_ppc_at_tls_transform (insn, 2);
7869               if (insn == 0)
7870                 abort ();
7871               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
7872               r_type = R_PPC_TPREL16_LO;
7873               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7874
7875               /* Was PPC_TLS which sits on insn boundary, now
7876                  PPC_TPREL16_LO which is at low-order half-word.  */
7877               rel->r_offset += d_offset;
7878             }
7879           break;
7880
7881         case R_PPC_GOT_TLSGD16_HI:
7882         case R_PPC_GOT_TLSGD16_HA:
7883           tls_gd = TLS_TPRELGD;
7884           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7885             goto tls_gdld_hi;
7886           break;
7887
7888         case R_PPC_GOT_TLSLD16_HI:
7889         case R_PPC_GOT_TLSLD16_HA:
7890           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7891             {
7892             tls_gdld_hi:
7893               if ((tls_mask & tls_gd) != 0)
7894                 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7895                           + R_PPC_GOT_TPREL16);
7896               else
7897                 {
7898                   rel->r_offset -= d_offset;
7899                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
7900                   r_type = R_PPC_NONE;
7901                 }
7902               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7903             }
7904           break;
7905
7906         case R_PPC_GOT_TLSGD16:
7907         case R_PPC_GOT_TLSGD16_LO:
7908           tls_gd = TLS_TPRELGD;
7909           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7910             goto tls_ldgd_opt;
7911           break;
7912
7913         case R_PPC_GOT_TLSLD16:
7914         case R_PPC_GOT_TLSLD16_LO:
7915           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7916             {
7917               unsigned int insn1, insn2;
7918               bfd_vma offset;
7919
7920             tls_ldgd_opt:
7921               offset = (bfd_vma) -1;
7922               /* If not using the newer R_PPC_TLSGD/LD to mark
7923                  __tls_get_addr calls, we must trust that the call
7924                  stays with its arg setup insns, ie. that the next
7925                  reloc is the __tls_get_addr call associated with
7926                  the current reloc.  Edit both insns.  */
7927               if (input_section->has_tls_get_addr_call
7928                   && rel + 1 < relend
7929                   && branch_reloc_hash_match (input_bfd, rel + 1,
7930                                               htab->tls_get_addr))
7931                 offset = rel[1].r_offset;
7932               /* We read the low GOT_TLS insn because we need to keep
7933                  the destination reg.  It may be something other than
7934                  the usual r3, and moved to r3 before the call by
7935                  intervening code.  */
7936               insn1 = bfd_get_32 (output_bfd,
7937                                   contents + rel->r_offset - d_offset);
7938               if ((tls_mask & tls_gd) != 0)
7939                 {
7940                   /* IE */
7941                   insn1 &= (0x1f << 21) | (0x1f << 16);
7942                   insn1 |= 32 << 26;    /* lwz */
7943                   if (offset != (bfd_vma) -1)
7944                     {
7945                       rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7946                       insn2 = 0x7c631214;       /* add 3,3,2 */
7947                       bfd_put_32 (output_bfd, insn2, contents + offset);
7948                     }
7949                   r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7950                             + R_PPC_GOT_TPREL16);
7951                   rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7952                 }
7953               else
7954                 {
7955                   /* LE */
7956                   insn1 &= 0x1f << 21;
7957                   insn1 |= 0x3c020000;  /* addis r,2,0 */
7958                   if (tls_gd == 0)
7959                     {
7960                       /* Was an LD reloc.  */
7961                       for (r_symndx = 0;
7962                            r_symndx < symtab_hdr->sh_info;
7963                            r_symndx++)
7964                         if (local_sections[r_symndx] == sec)
7965                           break;
7966                       if (r_symndx >= symtab_hdr->sh_info)
7967                         r_symndx = STN_UNDEF;
7968                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
7969                       if (r_symndx != STN_UNDEF)
7970                         rel->r_addend -= (local_syms[r_symndx].st_value
7971                                           + sec->output_offset
7972                                           + sec->output_section->vma);
7973                     }
7974                   r_type = R_PPC_TPREL16_HA;
7975                   rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7976                   if (offset != (bfd_vma) -1)
7977                     {
7978                       rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7979                       rel[1].r_offset = offset + d_offset;
7980                       rel[1].r_addend = rel->r_addend;
7981                       insn2 = 0x38630000;       /* addi 3,3,0 */
7982                       bfd_put_32 (output_bfd, insn2, contents + offset);
7983                     }
7984                 }
7985               bfd_put_32 (output_bfd, insn1,
7986                           contents + rel->r_offset - d_offset);
7987               if (tls_gd == 0)
7988                 {
7989                   /* We changed the symbol on an LD reloc.  Start over
7990                      in order to get h, sym, sec etc. right.  */
7991                   goto again;
7992                 }
7993             }
7994           break;
7995
7996         case R_PPC_TLSGD:
7997           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7998             {
7999               unsigned int insn2;
8000               bfd_vma offset = rel->r_offset;
8001
8002               if ((tls_mask & TLS_TPRELGD) != 0)
8003                 {
8004                   /* IE */
8005                   r_type = R_PPC_NONE;
8006                   insn2 = 0x7c631214;   /* add 3,3,2 */
8007                 }
8008               else
8009                 {
8010                   /* LE */
8011                   r_type = R_PPC_TPREL16_LO;
8012                   rel->r_offset += d_offset;
8013                   insn2 = 0x38630000;   /* addi 3,3,0 */
8014                 }
8015               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
8016               bfd_put_32 (output_bfd, insn2, contents + offset);
8017               /* Zap the reloc on the _tls_get_addr call too.  */
8018               BFD_ASSERT (offset == rel[1].r_offset);
8019               rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
8020             }
8021           break;
8022
8023         case R_PPC_TLSLD:
8024           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
8025             {
8026               unsigned int insn2;
8027
8028               for (r_symndx = 0;
8029                    r_symndx < symtab_hdr->sh_info;
8030                    r_symndx++)
8031                 if (local_sections[r_symndx] == sec)
8032                   break;
8033               if (r_symndx >= symtab_hdr->sh_info)
8034                 r_symndx = STN_UNDEF;
8035               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
8036               if (r_symndx != STN_UNDEF)
8037                 rel->r_addend -= (local_syms[r_symndx].st_value
8038                                   + sec->output_offset
8039                                   + sec->output_section->vma);
8040
8041               rel->r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
8042               rel->r_offset += d_offset;
8043               insn2 = 0x38630000;       /* addi 3,3,0 */
8044               bfd_put_32 (output_bfd, insn2,
8045                           contents + rel->r_offset - d_offset);
8046               /* Zap the reloc on the _tls_get_addr call too.  */
8047               BFD_ASSERT (rel->r_offset - d_offset == rel[1].r_offset);
8048               rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
8049               goto again;
8050             }
8051           break;
8052         }
8053
8054       /* Handle other relocations that tweak non-addend part of insn.  */
8055       branch_bit = 0;
8056       switch (r_type)
8057         {
8058         default:
8059           break;
8060
8061           /* Branch taken prediction relocations.  */
8062         case R_PPC_ADDR14_BRTAKEN:
8063         case R_PPC_REL14_BRTAKEN:
8064           branch_bit = BRANCH_PREDICT_BIT;
8065           /* Fall thru */
8066
8067           /* Branch not taken prediction relocations.  */
8068         case R_PPC_ADDR14_BRNTAKEN:
8069         case R_PPC_REL14_BRNTAKEN:
8070           {
8071             bfd_vma insn;
8072
8073             insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
8074             insn &= ~BRANCH_PREDICT_BIT;
8075             insn |= branch_bit;
8076
8077             from = (rel->r_offset
8078                     + input_section->output_offset
8079                     + input_section->output_section->vma);
8080
8081             /* Invert 'y' bit if not the default.  */
8082             if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
8083               insn ^= BRANCH_PREDICT_BIT;
8084
8085             bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
8086             break;
8087           }
8088         }
8089
8090       if (ELIMINATE_COPY_RELOCS
8091           && h != NULL
8092           && !h->def_regular
8093           && h->protected_def
8094           && ppc_elf_hash_entry (h)->has_addr16_ha
8095           && ppc_elf_hash_entry (h)->has_addr16_lo
8096           && htab->params->pic_fixup > 0)
8097         {
8098           /* Convert lis;addi or lis;load/store accessing a protected
8099              variable defined in a shared library to PIC.  */
8100           unsigned int insn;
8101
8102           if (r_type == R_PPC_ADDR16_HA)
8103             {
8104               insn = bfd_get_32 (output_bfd,
8105                                  contents + rel->r_offset - d_offset);
8106               if ((insn & (0x3f << 26)) == (15u << 26)
8107                   && (insn & (0x1f << 16)) == 0 /* lis */)
8108                 {
8109                   bfd_byte *p;
8110                   bfd_vma off;
8111                   bfd_vma got_addr;
8112
8113                   p = (contents + input_section->size
8114                        - relax_info->workaround_size
8115                        - relax_info->picfixup_size
8116                        + picfixup_size);
8117                   off = (p - contents) - (rel->r_offset - d_offset);
8118                   if (off > 0x1fffffc || (off & 3) != 0)
8119                     info->callbacks->einfo
8120                       (_("%P: %H: fixup branch overflow\n"),
8121                        input_bfd, input_section, rel->r_offset);
8122
8123                   bfd_put_32 (output_bfd, B | off,
8124                               contents + rel->r_offset - d_offset);
8125                   got_addr = (htab->got->output_section->vma
8126                               + htab->got->output_offset
8127                               + (h->got.offset & ~1));
8128                   wrel->r_offset = (p - contents) + d_offset;
8129                   wrel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_HA);
8130                   wrel->r_addend = got_addr;
8131                   insn &= ~0xffff;
8132                   insn |= ((unsigned int )(got_addr + 0x8000) >> 16) & 0xffff;
8133                   bfd_put_32 (output_bfd, insn, p);
8134
8135                   /* Convert lis to lwz, loading address from GOT.  */
8136                   insn &= ~0xffff;
8137                   insn ^= (32u ^ 15u) << 26;
8138                   insn |= (insn & (0x1f << 21)) >> 5;
8139                   insn |= got_addr & 0xffff;
8140                   bfd_put_32 (output_bfd, insn, p + 4);
8141
8142                   bfd_put_32 (output_bfd, B | ((-4 - off) & 0x3ffffff), p + 8);
8143                   picfixup_size += 12;
8144
8145                   /* Use one of the spare relocs, so --emit-relocs
8146                      output is reasonable.  */
8147                   memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel));
8148                   wrel++, rel++;
8149                   rel->r_offset = wrel[-1].r_offset + 4;
8150                   rel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_LO);
8151                   rel->r_addend = wrel[-1].r_addend;
8152
8153                   /* Continue on as if we had a got reloc, to output
8154                      dynamic reloc.  */
8155                   r_type = R_PPC_GOT16_LO;
8156                 }
8157               else
8158                 info->callbacks->einfo
8159                   (_("%P: %H: error: %s with unexpected instruction %x\n"),
8160                    input_bfd, input_section, rel->r_offset,
8161                    "R_PPC_ADDR16_HA", insn);
8162             }
8163           else if (r_type == R_PPC_ADDR16_LO)
8164             {
8165               insn = bfd_get_32 (output_bfd,
8166                                  contents + rel->r_offset - d_offset);
8167               if ((insn & (0x3f << 26)) == 14u << 26    /* addi */
8168                   || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8169                   || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8170                   || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8171                   || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8172                   || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8173                   || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8174                   || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8175                   || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8176                   || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8177                   || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8178                   || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8179                   || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8180                   || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8181                   || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8182                       && (insn & 3) != 1)
8183                   || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8184                       && ((insn & 3) == 0 || (insn & 3) == 3)))
8185                 {
8186                   /* Arrange to apply the reloc addend, if any.  */
8187                   relocation = 0;
8188                   unresolved_reloc = FALSE;
8189                   rel->r_info = ELF32_R_INFO (0, r_type);
8190                 }
8191               else
8192                 info->callbacks->einfo
8193                   (_("%P: %H: error: %s with unexpected instruction %x\n"),
8194                    input_bfd, input_section, rel->r_offset,
8195                    "R_PPC_ADDR16_LO", insn);
8196             }
8197         }
8198
8199       ifunc = NULL;
8200       if (!htab->is_vxworks)
8201         {
8202           struct plt_entry *ent;
8203
8204           if (h != NULL)
8205             {
8206               if (h->type == STT_GNU_IFUNC)
8207                 ifunc = &h->plt.plist;
8208             }
8209           else if (local_got_offsets != NULL
8210                    && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8211             {
8212               struct plt_entry **local_plt;
8213
8214               local_plt = (struct plt_entry **) (local_got_offsets
8215                                                  + symtab_hdr->sh_info);
8216               ifunc = local_plt + r_symndx;
8217             }
8218
8219           ent = NULL;
8220           if (ifunc != NULL
8221               && (!bfd_link_pic (info)
8222                   || is_branch_reloc (r_type)))
8223             {
8224               addend = 0;
8225               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info))
8226                 addend = rel->r_addend;
8227               ent = find_plt_ent (ifunc, got2, addend);
8228             }
8229           if (ent != NULL)
8230             {
8231               if (h == NULL && (ent->plt.offset & 1) == 0)
8232                 {
8233                   Elf_Internal_Rela rela;
8234                   bfd_byte *loc;
8235
8236                   rela.r_offset = (htab->iplt->output_section->vma
8237                                    + htab->iplt->output_offset
8238                                    + ent->plt.offset);
8239                   rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8240                   rela.r_addend = relocation;
8241                   loc = htab->reliplt->contents;
8242                   loc += (htab->reliplt->reloc_count++
8243                           * sizeof (Elf32_External_Rela));
8244                   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8245
8246                   ent->plt.offset |= 1;
8247                 }
8248               if (h == NULL && (ent->glink_offset & 1) == 0)
8249                 {
8250                   unsigned char *p = ((unsigned char *) htab->glink->contents
8251                                       + ent->glink_offset);
8252                   write_glink_stub (ent, htab->iplt, p, info);
8253                   ent->glink_offset |= 1;
8254                 }
8255
8256               unresolved_reloc = FALSE;
8257               if (htab->plt_type == PLT_NEW
8258                   || !htab->elf.dynamic_sections_created
8259                   || h == NULL
8260                   || h->dynindx == -1)
8261                 relocation = (htab->glink->output_section->vma
8262                               + htab->glink->output_offset
8263                               + (ent->glink_offset & ~1));
8264               else
8265                 relocation = (htab->plt->output_section->vma
8266                               + htab->plt->output_offset
8267                               + ent->plt.offset);
8268             }
8269         }
8270
8271       addend = rel->r_addend;
8272       tls_type = 0;
8273       howto = NULL;
8274       if (r_type < R_PPC_max)
8275         howto = ppc_elf_howto_table[r_type];
8276       switch (r_type)
8277         {
8278         default:
8279           info->callbacks->einfo
8280             (_("%P: %B: unknown relocation type %d for symbol %s\n"),
8281              input_bfd, (int) r_type, sym_name);
8282
8283           bfd_set_error (bfd_error_bad_value);
8284           ret = FALSE;
8285           goto copy_reloc;
8286
8287         case R_PPC_NONE:
8288         case R_PPC_TLS:
8289         case R_PPC_TLSGD:
8290         case R_PPC_TLSLD:
8291         case R_PPC_EMB_MRKREF:
8292         case R_PPC_GNU_VTINHERIT:
8293         case R_PPC_GNU_VTENTRY:
8294           goto copy_reloc;
8295
8296           /* GOT16 relocations.  Like an ADDR16 using the symbol's
8297              address in the GOT as relocation value instead of the
8298              symbol's value itself.  Also, create a GOT entry for the
8299              symbol and put the symbol value there.  */
8300         case R_PPC_GOT_TLSGD16:
8301         case R_PPC_GOT_TLSGD16_LO:
8302         case R_PPC_GOT_TLSGD16_HI:
8303         case R_PPC_GOT_TLSGD16_HA:
8304           tls_type = TLS_TLS | TLS_GD;
8305           goto dogot;
8306
8307         case R_PPC_GOT_TLSLD16:
8308         case R_PPC_GOT_TLSLD16_LO:
8309         case R_PPC_GOT_TLSLD16_HI:
8310         case R_PPC_GOT_TLSLD16_HA:
8311           tls_type = TLS_TLS | TLS_LD;
8312           goto dogot;
8313
8314         case R_PPC_GOT_TPREL16:
8315         case R_PPC_GOT_TPREL16_LO:
8316         case R_PPC_GOT_TPREL16_HI:
8317         case R_PPC_GOT_TPREL16_HA:
8318           tls_type = TLS_TLS | TLS_TPREL;
8319           goto dogot;
8320
8321         case R_PPC_GOT_DTPREL16:
8322         case R_PPC_GOT_DTPREL16_LO:
8323         case R_PPC_GOT_DTPREL16_HI:
8324         case R_PPC_GOT_DTPREL16_HA:
8325           tls_type = TLS_TLS | TLS_DTPREL;
8326           goto dogot;
8327
8328         case R_PPC_GOT16:
8329         case R_PPC_GOT16_LO:
8330         case R_PPC_GOT16_HI:
8331         case R_PPC_GOT16_HA:
8332           tls_mask = 0;
8333         dogot:
8334           {
8335             /* Relocation is to the entry for this symbol in the global
8336                offset table.  */
8337             bfd_vma off;
8338             bfd_vma *offp;
8339             unsigned long indx;
8340
8341             if (htab->got == NULL)
8342               abort ();
8343
8344             indx = 0;
8345             if (tls_type == (TLS_TLS | TLS_LD)
8346                 && (h == NULL
8347                     || !h->def_dynamic))
8348               offp = &htab->tlsld_got.offset;
8349             else if (h != NULL)
8350               {
8351                 bfd_boolean dyn;
8352                 dyn = htab->elf.dynamic_sections_created;
8353                 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
8354                     || (bfd_link_pic (info)
8355                         && SYMBOL_REFERENCES_LOCAL (info, h)))
8356                   /* This is actually a static link, or it is a
8357                      -Bsymbolic link and the symbol is defined
8358                      locally, or the symbol was forced to be local
8359                      because of a version file.  */
8360                   ;
8361                 else
8362                   {
8363                     BFD_ASSERT (h->dynindx != -1);
8364                     indx = h->dynindx;
8365                     unresolved_reloc = FALSE;
8366                   }
8367                 offp = &h->got.offset;
8368               }
8369             else
8370               {
8371                 if (local_got_offsets == NULL)
8372                   abort ();
8373                 offp = &local_got_offsets[r_symndx];
8374               }
8375
8376             /* The offset must always be a multiple of 4.  We use the
8377                least significant bit to record whether we have already
8378                processed this entry.  */
8379             off = *offp;
8380             if ((off & 1) != 0)
8381               off &= ~1;
8382             else
8383               {
8384                 unsigned int tls_m = (tls_mask
8385                                       & (TLS_LD | TLS_GD | TLS_DTPREL
8386                                          | TLS_TPREL | TLS_TPRELGD));
8387
8388                 if (offp == &htab->tlsld_got.offset)
8389                   tls_m = TLS_LD;
8390                 else if (h == NULL
8391                          || !h->def_dynamic)
8392                   tls_m &= ~TLS_LD;
8393
8394                 /* We might have multiple got entries for this sym.
8395                    Initialize them all.  */
8396                 do
8397                   {
8398                     int tls_ty = 0;
8399
8400                     if ((tls_m & TLS_LD) != 0)
8401                       {
8402                         tls_ty = TLS_TLS | TLS_LD;
8403                         tls_m &= ~TLS_LD;
8404                       }
8405                     else if ((tls_m & TLS_GD) != 0)
8406                       {
8407                         tls_ty = TLS_TLS | TLS_GD;
8408                         tls_m &= ~TLS_GD;
8409                       }
8410                     else if ((tls_m & TLS_DTPREL) != 0)
8411                       {
8412                         tls_ty = TLS_TLS | TLS_DTPREL;
8413                         tls_m &= ~TLS_DTPREL;
8414                       }
8415                     else if ((tls_m & (TLS_TPREL | TLS_TPRELGD)) != 0)
8416                       {
8417                         tls_ty = TLS_TLS | TLS_TPREL;
8418                         tls_m = 0;
8419                       }
8420
8421                     /* Generate relocs for the dynamic linker.  */
8422                     if ((bfd_link_pic (info) || indx != 0)
8423                         && (offp == &htab->tlsld_got.offset
8424                             || h == NULL
8425                             || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8426                             || h->root.type != bfd_link_hash_undefweak))
8427                       {
8428                         asection *rsec = htab->relgot;
8429                         bfd_byte * loc;
8430
8431                         if (ifunc != NULL)
8432                           rsec = htab->reliplt;
8433                         outrel.r_offset = (htab->got->output_section->vma
8434                                            + htab->got->output_offset
8435                                            + off);
8436                         outrel.r_addend = 0;
8437                         if (tls_ty & (TLS_LD | TLS_GD))
8438                           {
8439                             outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
8440                             if (tls_ty == (TLS_TLS | TLS_GD))
8441                               {
8442                                 loc = rsec->contents;
8443                                 loc += (rsec->reloc_count++
8444                                         * sizeof (Elf32_External_Rela));
8445                                 bfd_elf32_swap_reloca_out (output_bfd,
8446                                                            &outrel, loc);
8447                                 outrel.r_offset += 4;
8448                                 outrel.r_info
8449                                   = ELF32_R_INFO (indx, R_PPC_DTPREL32);
8450                               }
8451                           }
8452                         else if (tls_ty == (TLS_TLS | TLS_DTPREL))
8453                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
8454                         else if (tls_ty == (TLS_TLS | TLS_TPREL))
8455                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
8456                         else if (indx != 0)
8457                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
8458                         else if (ifunc != NULL)
8459                           outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8460                         else
8461                           outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
8462                         if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD))
8463                           {
8464                             outrel.r_addend += relocation;
8465                             if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
8466                               {
8467                                 if (htab->elf.tls_sec == NULL)
8468                                   outrel.r_addend = 0;
8469                                 else
8470                                   outrel.r_addend -= htab->elf.tls_sec->vma;
8471                               }
8472                           }
8473                         loc = rsec->contents;
8474                         loc += (rsec->reloc_count++
8475                                 * sizeof (Elf32_External_Rela));
8476                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
8477                       }
8478
8479                     /* Init the .got section contents if we're not
8480                        emitting a reloc.  */
8481                     else
8482                       {
8483                         bfd_vma value = relocation;
8484
8485                         if (tls_ty == (TLS_TLS | TLS_LD))
8486                           value = 1;
8487                         else if (tls_ty != 0)
8488                           {
8489                             if (htab->elf.tls_sec == NULL)
8490                               value = 0;
8491                             else
8492                               {
8493                                 value -= htab->elf.tls_sec->vma + DTP_OFFSET;
8494                                 if (tls_ty == (TLS_TLS | TLS_TPREL))
8495                                   value += DTP_OFFSET - TP_OFFSET;
8496                               }
8497
8498                             if (tls_ty == (TLS_TLS | TLS_GD))
8499                               {
8500                                 bfd_put_32 (output_bfd, value,
8501                                             htab->got->contents + off + 4);
8502                                 value = 1;
8503                               }
8504                           }
8505                         bfd_put_32 (output_bfd, value,
8506                                     htab->got->contents + off);
8507                       }
8508
8509                     off += 4;
8510                     if (tls_ty & (TLS_LD | TLS_GD))
8511                       off += 4;
8512                   }
8513                 while (tls_m != 0);
8514
8515                 off = *offp;
8516                 *offp = off | 1;
8517               }
8518
8519             if (off >= (bfd_vma) -2)
8520               abort ();
8521
8522             if ((tls_type & TLS_TLS) != 0)
8523               {
8524                 if (tls_type != (TLS_TLS | TLS_LD))
8525                   {
8526                     if ((tls_mask & TLS_LD) != 0
8527                         && !(h == NULL
8528                              || !h->def_dynamic))
8529                       off += 8;
8530                     if (tls_type != (TLS_TLS | TLS_GD))
8531                       {
8532                         if ((tls_mask & TLS_GD) != 0)
8533                           off += 8;
8534                         if (tls_type != (TLS_TLS | TLS_DTPREL))
8535                           {
8536                             if ((tls_mask & TLS_DTPREL) != 0)
8537                               off += 4;
8538                           }
8539                       }
8540                   }
8541               }
8542
8543             /* If here for a picfixup, we're done.  */
8544             if (r_type != ELF32_R_TYPE (rel->r_info))
8545               goto copy_reloc;
8546
8547             relocation = (htab->got->output_section->vma
8548                           + htab->got->output_offset
8549                           + off
8550                           - SYM_VAL (htab->elf.hgot));
8551
8552             /* Addends on got relocations don't make much sense.
8553                x+off@got is actually x@got+off, and since the got is
8554                generated by a hash table traversal, the value in the
8555                got at entry m+n bears little relation to the entry m.  */
8556             if (addend != 0)
8557               info->callbacks->einfo
8558                 (_("%P: %H: non-zero addend on %s reloc against `%s'\n"),
8559                  input_bfd, input_section, rel->r_offset,
8560                  howto->name,
8561                  sym_name);
8562           }
8563           break;
8564
8565           /* Relocations that need no special processing.  */
8566         case R_PPC_LOCAL24PC:
8567           /* It makes no sense to point a local relocation
8568              at a symbol not in this object.  */
8569           if (unresolved_reloc)
8570             {
8571               if (! (*info->callbacks->undefined_symbol) (info,
8572                                                           h->root.root.string,
8573                                                           input_bfd,
8574                                                           input_section,
8575                                                           rel->r_offset,
8576                                                           TRUE))
8577                 return FALSE;
8578               goto copy_reloc;
8579             }
8580           break;
8581
8582         case R_PPC_DTPREL16:
8583         case R_PPC_DTPREL16_LO:
8584         case R_PPC_DTPREL16_HI:
8585         case R_PPC_DTPREL16_HA:
8586           if (htab->elf.tls_sec != NULL)
8587             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
8588           break;
8589
8590           /* Relocations that may need to be propagated if this is a shared
8591              object.  */
8592         case R_PPC_TPREL16:
8593         case R_PPC_TPREL16_LO:
8594         case R_PPC_TPREL16_HI:
8595         case R_PPC_TPREL16_HA:
8596           if (h != NULL
8597               && h->root.type == bfd_link_hash_undefweak
8598               && h->dynindx == -1)
8599             {
8600               /* Make this relocation against an undefined weak symbol
8601                  resolve to zero.  This is really just a tweak, since
8602                  code using weak externs ought to check that they are
8603                  defined before using them.  */
8604               bfd_byte *p = contents + rel->r_offset - d_offset;
8605               unsigned int insn = bfd_get_32 (output_bfd, p);
8606               insn = _bfd_elf_ppc_at_tprel_transform (insn, 2);
8607               if (insn != 0)
8608                 bfd_put_32 (output_bfd, insn, p);
8609               break;
8610             }
8611           if (htab->elf.tls_sec != NULL)
8612             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
8613           /* The TPREL16 relocs shouldn't really be used in shared
8614              libs as they will result in DT_TEXTREL being set, but
8615              support them anyway.  */
8616           goto dodyn;
8617
8618         case R_PPC_TPREL32:
8619           if (htab->elf.tls_sec != NULL)
8620             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
8621           goto dodyn;
8622
8623         case R_PPC_DTPREL32:
8624           if (htab->elf.tls_sec != NULL)
8625             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
8626           goto dodyn;
8627
8628         case R_PPC_DTPMOD32:
8629           relocation = 1;
8630           addend = 0;
8631           goto dodyn;
8632
8633         case R_PPC_REL16:
8634         case R_PPC_REL16_LO:
8635         case R_PPC_REL16_HI:
8636         case R_PPC_REL16_HA:
8637         case R_PPC_REL16DX_HA:
8638           break;
8639
8640         case R_PPC_REL32:
8641           if (h == NULL || h == htab->elf.hgot)
8642             break;
8643           /* fall through */
8644
8645         case R_PPC_ADDR32:
8646         case R_PPC_ADDR16:
8647         case R_PPC_ADDR16_LO:
8648         case R_PPC_ADDR16_HI:
8649         case R_PPC_ADDR16_HA:
8650         case R_PPC_UADDR32:
8651         case R_PPC_UADDR16:
8652           goto dodyn;
8653
8654         case R_PPC_VLE_REL8:
8655         case R_PPC_VLE_REL15:
8656         case R_PPC_VLE_REL24:
8657         case R_PPC_REL24:
8658         case R_PPC_REL14:
8659         case R_PPC_REL14_BRTAKEN:
8660         case R_PPC_REL14_BRNTAKEN:
8661           /* If these relocations are not to a named symbol, they can be
8662              handled right here, no need to bother the dynamic linker.  */
8663           if (SYMBOL_CALLS_LOCAL (info, h)
8664               || h == htab->elf.hgot)
8665             break;
8666           /* fall through */
8667
8668         case R_PPC_ADDR24:
8669         case R_PPC_ADDR14:
8670         case R_PPC_ADDR14_BRTAKEN:
8671         case R_PPC_ADDR14_BRNTAKEN:
8672           if (h != NULL && !bfd_link_pic (info))
8673             break;
8674           /* fall through */
8675
8676         dodyn:
8677           if ((input_section->flags & SEC_ALLOC) == 0
8678               || is_vxworks_tls)
8679             break;
8680
8681           if ((bfd_link_pic (info)
8682                && !(h != NULL
8683                     && ((h->root.type == bfd_link_hash_undefined
8684                          && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
8685                              || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
8686                         || (h->root.type == bfd_link_hash_undefweak
8687                             && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)))
8688                && (must_be_dyn_reloc (info, r_type)
8689                    || !SYMBOL_CALLS_LOCAL (info, h)))
8690               || (ELIMINATE_COPY_RELOCS
8691                   && !bfd_link_pic (info)
8692                   && h != NULL
8693                   && h->dynindx != -1
8694                   && !h->non_got_ref
8695                   && !h->def_regular
8696                   && !(h->protected_def
8697                        && ppc_elf_hash_entry (h)->has_addr16_ha
8698                        && ppc_elf_hash_entry (h)->has_addr16_lo
8699                        && htab->params->pic_fixup > 0)))
8700             {
8701               int skip;
8702               bfd_byte *loc;
8703               asection *sreloc;
8704 #ifdef DEBUG
8705               fprintf (stderr, "ppc_elf_relocate_section needs to "
8706                        "create relocation for %s\n",
8707                        (h && h->root.root.string
8708                         ? h->root.root.string : "<unknown>"));
8709 #endif
8710
8711               /* When generating a shared object, these relocations
8712                  are copied into the output file to be resolved at run
8713                  time.  */
8714               sreloc = elf_section_data (input_section)->sreloc;
8715               if (ifunc)
8716                 sreloc = htab->reliplt;
8717               if (sreloc == NULL)
8718                 return FALSE;
8719
8720               skip = 0;
8721               outrel.r_offset = _bfd_elf_section_offset (output_bfd, info,
8722                                                          input_section,
8723                                                          rel->r_offset);
8724               if (outrel.r_offset == (bfd_vma) -1
8725                   || outrel.r_offset == (bfd_vma) -2)
8726                 skip = (int) outrel.r_offset;
8727               outrel.r_offset += (input_section->output_section->vma
8728                                   + input_section->output_offset);
8729
8730               if (skip)
8731                 memset (&outrel, 0, sizeof outrel);
8732               else if ((h != NULL
8733                         && (h->root.type == bfd_link_hash_undefined
8734                             || h->root.type == bfd_link_hash_undefweak))
8735                        || !SYMBOL_REFERENCES_LOCAL (info, h))
8736                 {
8737                   BFD_ASSERT (h->dynindx != -1);
8738                   unresolved_reloc = FALSE;
8739                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
8740                   outrel.r_addend = rel->r_addend;
8741                 }
8742               else
8743                 {
8744                   outrel.r_addend = relocation + rel->r_addend;
8745
8746                   if (r_type != R_PPC_ADDR32)
8747                     {
8748                       long indx = 0;
8749
8750                       if (ifunc != NULL)
8751                         {
8752                           /* If we get here when building a static
8753                              executable, then the libc startup function
8754                              responsible for applying indirect function
8755                              relocations is going to complain about
8756                              the reloc type.
8757                              If we get here when building a dynamic
8758                              executable, it will be because we have
8759                              a text relocation.  The dynamic loader
8760                              will set the text segment writable and
8761                              non-executable to apply text relocations.
8762                              So we'll segfault when trying to run the
8763                              indirection function to resolve the reloc.  */
8764                           info->callbacks->einfo
8765                             (_("%P: %H: relocation %s for indirect "
8766                                "function %s unsupported\n"),
8767                              input_bfd, input_section, rel->r_offset,
8768                              howto->name,
8769                              sym_name);
8770                           ret = FALSE;
8771                         }
8772                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
8773                         ;
8774                       else if (sec == NULL || sec->owner == NULL)
8775                         {
8776                           bfd_set_error (bfd_error_bad_value);
8777                           ret = FALSE;
8778                         }
8779                       else
8780                         {
8781                           asection *osec;
8782
8783                           /* We are turning this relocation into one
8784                              against a section symbol.  It would be
8785                              proper to subtract the symbol's value,
8786                              osec->vma, from the emitted reloc addend,
8787                              but ld.so expects buggy relocs.
8788                              FIXME: Why not always use a zero index?  */
8789                           osec = sec->output_section;
8790                           indx = elf_section_data (osec)->dynindx;
8791                           if (indx == 0)
8792                             {
8793                               osec = htab->elf.text_index_section;
8794                               indx = elf_section_data (osec)->dynindx;
8795                             }
8796                           BFD_ASSERT (indx != 0);
8797 #ifdef DEBUG
8798                           if (indx == 0)
8799                             printf ("indx=%ld section=%s flags=%08x name=%s\n",
8800                                     indx, osec->name, osec->flags,
8801                                     h->root.root.string);
8802 #endif
8803                         }
8804
8805                       outrel.r_info = ELF32_R_INFO (indx, r_type);
8806                     }
8807                   else if (ifunc != NULL)
8808                     outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8809                   else
8810                     outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
8811                 }
8812
8813               loc = sreloc->contents;
8814               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
8815               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
8816
8817               if (skip == -1)
8818                 goto copy_reloc;
8819
8820               /* This reloc will be computed at runtime.  We clear the memory
8821                  so that it contains predictable value.  */
8822               if (! skip
8823                   && ((input_section->flags & SEC_ALLOC) != 0
8824                       || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE))
8825                 {
8826                   relocation = howto->pc_relative ? outrel.r_offset : 0;
8827                   addend = 0;
8828                   break;
8829                 }
8830             }
8831           break;
8832
8833         case R_PPC_RELAX_PLT:
8834         case R_PPC_RELAX_PLTREL24:
8835           if (h != NULL)
8836             {
8837               struct plt_entry *ent;
8838               bfd_vma got2_addend = 0;
8839
8840               if (r_type == R_PPC_RELAX_PLTREL24)
8841                 {
8842                   if (bfd_link_pic (info))
8843                     got2_addend = addend;
8844                   addend = 0;
8845                 }
8846               ent = find_plt_ent (&h->plt.plist, got2, got2_addend);
8847               if (htab->plt_type == PLT_NEW)
8848                 relocation = (htab->glink->output_section->vma
8849                               + htab->glink->output_offset
8850                               + ent->glink_offset);
8851               else
8852                 relocation = (htab->plt->output_section->vma
8853                               + htab->plt->output_offset
8854                               + ent->plt.offset);
8855             }
8856           /* Fall thru */
8857
8858         case R_PPC_RELAX:
8859           {
8860             const int *stub;
8861             size_t size;
8862             size_t insn_offset = rel->r_offset;
8863             unsigned int insn;
8864
8865             if (bfd_link_pic (info))
8866               {
8867                 relocation -= (input_section->output_section->vma
8868                                + input_section->output_offset
8869                                + rel->r_offset - 4);
8870                 stub = shared_stub_entry;
8871                 bfd_put_32 (output_bfd, stub[0], contents + insn_offset - 12);
8872                 bfd_put_32 (output_bfd, stub[1], contents + insn_offset - 8);
8873                 bfd_put_32 (output_bfd, stub[2], contents + insn_offset - 4);
8874                 stub += 3;
8875                 size = ARRAY_SIZE (shared_stub_entry) - 3;
8876               }
8877             else
8878               {
8879                 stub = stub_entry;
8880                 size = ARRAY_SIZE (stub_entry);
8881               }
8882
8883             relocation += addend;
8884             if (bfd_link_relocatable (info))
8885               relocation = 0;
8886
8887             /* First insn is HA, second is LO.  */
8888             insn = *stub++;
8889             insn |= ((relocation + 0x8000) >> 16) & 0xffff;
8890             bfd_put_32 (output_bfd, insn, contents + insn_offset);
8891             insn_offset += 4;
8892
8893             insn = *stub++;
8894             insn |= relocation & 0xffff;
8895             bfd_put_32 (output_bfd, insn, contents + insn_offset);
8896             insn_offset += 4;
8897             size -= 2;
8898
8899             while (size != 0)
8900               {
8901                 insn = *stub++;
8902                 --size;
8903                 bfd_put_32 (output_bfd, insn, contents + insn_offset);
8904                 insn_offset += 4;
8905               }
8906
8907             /* Rewrite the reloc and convert one of the trailing nop
8908                relocs to describe this relocation.  */
8909             BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE);
8910             /* The relocs are at the bottom 2 bytes */
8911             wrel->r_offset = rel->r_offset + d_offset;
8912             wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
8913             wrel->r_addend = rel->r_addend;
8914             memmove (wrel + 1, wrel, (relend - wrel - 1) * sizeof (*wrel));
8915             wrel++, rel++;
8916             wrel->r_offset += 4;
8917             wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
8918           }
8919           continue;
8920
8921           /* Indirect .sdata relocation.  */
8922         case R_PPC_EMB_SDAI16:
8923           BFD_ASSERT (htab->sdata[0].section != NULL);
8924           if (!is_static_defined (htab->sdata[0].sym))
8925             {
8926               unresolved_reloc = TRUE;
8927               break;
8928             }
8929           relocation
8930             = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0],
8931                                                  h, relocation, rel);
8932           addend = 0;
8933           break;
8934
8935           /* Indirect .sdata2 relocation.  */
8936         case R_PPC_EMB_SDA2I16:
8937           BFD_ASSERT (htab->sdata[1].section != NULL);
8938           if (!is_static_defined (htab->sdata[1].sym))
8939             {
8940               unresolved_reloc = TRUE;
8941               break;
8942             }
8943           relocation
8944             = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1],
8945                                                  h, relocation, rel);
8946           addend = 0;
8947           break;
8948
8949           /* Handle the TOC16 reloc.  We want to use the offset within the .got
8950              section, not the actual VMA.  This is appropriate when generating
8951              an embedded ELF object, for which the .got section acts like the
8952              AIX .toc section.  */
8953         case R_PPC_TOC16:                       /* phony GOT16 relocations */
8954           if (sec == NULL || sec->output_section == NULL)
8955             {
8956               unresolved_reloc = TRUE;
8957               break;
8958             }
8959           BFD_ASSERT (strcmp (bfd_get_section_name (sec->owner, sec),
8960                               ".got") == 0
8961                       || strcmp (bfd_get_section_name (sec->owner, sec),
8962                                  ".cgot") == 0);
8963
8964           addend -= sec->output_section->vma + sec->output_offset + 0x8000;
8965           break;
8966
8967         case R_PPC_PLTREL24:
8968           if (h != NULL && ifunc == NULL)
8969             {
8970               struct plt_entry *ent;
8971
8972               ent = find_plt_ent (&h->plt.plist, got2,
8973                                   bfd_link_pic (info) ? addend : 0);
8974               if (ent == NULL
8975                   || htab->plt == NULL)
8976                 {
8977                   /* We didn't make a PLT entry for this symbol.  This
8978                      happens when statically linking PIC code, or when
8979                      using -Bsymbolic.  */
8980                 }
8981               else
8982                 {
8983                   /* Relocation is to the entry for this symbol in the
8984                      procedure linkage table.  */
8985                   unresolved_reloc = FALSE;
8986                   if (htab->plt_type == PLT_NEW)
8987                     relocation = (htab->glink->output_section->vma
8988                                   + htab->glink->output_offset
8989                                   + ent->glink_offset);
8990                   else
8991                     relocation = (htab->plt->output_section->vma
8992                                   + htab->plt->output_offset
8993                                   + ent->plt.offset);
8994                 }
8995             }
8996
8997           /* R_PPC_PLTREL24 is rather special.  If non-zero, the
8998              addend specifies the GOT pointer offset within .got2.
8999              Don't apply it to the relocation field.  */
9000           addend = 0;
9001           break;
9002
9003           /* Relocate against _SDA_BASE_.  */
9004         case R_PPC_SDAREL16:
9005           {
9006             const char *name;
9007             struct elf_link_hash_entry *sda = htab->sdata[0].sym;
9008
9009             if (sec == NULL
9010                 || sec->output_section == NULL
9011                 || !is_static_defined (sda))
9012               {
9013                 unresolved_reloc = TRUE;
9014                 break;
9015               }
9016             addend -= SYM_VAL (sda);
9017
9018             name = bfd_get_section_name (output_bfd, sec->output_section);
9019             if (!(strcmp (name, ".sdata") == 0
9020                   || strcmp (name, ".sbss") == 0))
9021               {
9022                 info->callbacks->einfo
9023                   (_("%P: %B: the target (%s) of a %s relocation is "
9024                      "in the wrong output section (%s)\n"),
9025                    input_bfd,
9026                    sym_name,
9027                    howto->name,
9028                    name);
9029               }
9030           }
9031           break;
9032
9033           /* Relocate against _SDA2_BASE_.  */
9034         case R_PPC_EMB_SDA2REL:
9035           {
9036             const char *name;
9037             struct elf_link_hash_entry *sda = htab->sdata[1].sym;
9038
9039             if (sec == NULL
9040                 || sec->output_section == NULL
9041                 || !is_static_defined (sda))
9042               {
9043                 unresolved_reloc = TRUE;
9044                 break;
9045               }
9046             addend -= SYM_VAL (sda);
9047
9048             name = bfd_get_section_name (output_bfd, sec->output_section);
9049             if (!(strcmp (name, ".sdata2") == 0
9050                   || strcmp (name, ".sbss2") == 0))
9051               {
9052                 info->callbacks->einfo
9053                   (_("%P: %B: the target (%s) of a %s relocation is "
9054                      "in the wrong output section (%s)\n"),
9055                    input_bfd,
9056                    sym_name,
9057                    howto->name,
9058                    name);
9059               }
9060           }
9061           break;
9062
9063         case R_PPC_VLE_LO16A:
9064           relocation = relocation + addend;
9065           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9066                                relocation, split16a_type);
9067           goto copy_reloc;
9068
9069         case R_PPC_VLE_LO16D:
9070           relocation = relocation + addend;
9071           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9072                                relocation, split16d_type);
9073           goto copy_reloc;
9074
9075         case R_PPC_VLE_HI16A:
9076           relocation = (relocation + addend) >> 16;
9077           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9078                                relocation, split16a_type);
9079           goto copy_reloc;
9080
9081         case R_PPC_VLE_HI16D:
9082           relocation = (relocation + addend) >> 16;
9083           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9084                                relocation, split16d_type);
9085           goto copy_reloc;
9086
9087         case R_PPC_VLE_HA16A:
9088           relocation = (relocation + addend + 0x8000) >> 16;
9089           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9090                                relocation, split16a_type);
9091           goto copy_reloc;
9092
9093         case R_PPC_VLE_HA16D:
9094           relocation = (relocation + addend + 0x8000) >> 16;
9095           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9096                                relocation, split16d_type);
9097           goto copy_reloc;
9098
9099           /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0.  */
9100         case R_PPC_EMB_SDA21:
9101         case R_PPC_VLE_SDA21:
9102         case R_PPC_EMB_RELSDA:
9103         case R_PPC_VLE_SDA21_LO:
9104           {
9105             const char *name;
9106             int reg;
9107             unsigned int insn;
9108             struct elf_link_hash_entry *sda = NULL;
9109
9110             if (sec == NULL || sec->output_section == NULL)
9111               {
9112                 unresolved_reloc = TRUE;
9113                 break;
9114               }
9115
9116             name = bfd_get_section_name (output_bfd, sec->output_section);
9117             if (strcmp (name, ".sdata") == 0
9118                 || strcmp (name, ".sbss") == 0)
9119               {
9120                 reg = 13;
9121                 sda = htab->sdata[0].sym;
9122               }
9123             else if (strcmp (name, ".sdata2") == 0
9124                      || strcmp (name, ".sbss2") == 0)
9125               {
9126                 reg = 2;
9127                 sda = htab->sdata[1].sym;
9128               }
9129             else if (strcmp (name, ".PPC.EMB.sdata0") == 0
9130                      || strcmp (name, ".PPC.EMB.sbss0") == 0)
9131               {
9132                 reg = 0;
9133               }
9134             else
9135               {
9136                 info->callbacks->einfo
9137                   (_("%P: %B: the target (%s) of a %s relocation is "
9138                      "in the wrong output section (%s)\n"),
9139                    input_bfd,
9140                    sym_name,
9141                    howto->name,
9142                    name);
9143
9144                 bfd_set_error (bfd_error_bad_value);
9145                 ret = FALSE;
9146                 goto copy_reloc;
9147               }
9148
9149             if (sda != NULL)
9150               {
9151                 if (!is_static_defined (sda))
9152                   {
9153                     unresolved_reloc = TRUE;
9154                     break;
9155                   }
9156                 addend -= SYM_VAL (sda);
9157               }
9158
9159             insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
9160             if (reg == 0
9161                 && (r_type == R_PPC_VLE_SDA21
9162                     || r_type == R_PPC_VLE_SDA21_LO))
9163               {
9164                 relocation = relocation + addend;
9165                 addend = 0;
9166
9167                 /* Force e_li insn, keeping RT from original insn.  */
9168                 insn &= 0x1f << 21;
9169                 insn |= 28u << 26;
9170
9171                 /* We have an li20 field, bits 17..20, 11..15, 21..31.  */
9172                 /* Top 4 bits of value to 17..20.  */
9173                 insn |= (relocation & 0xf0000) >> 5;
9174                 /* Next 5 bits of the value to 11..15.  */
9175                 insn |= (relocation & 0xf800) << 5;
9176                 /* And the final 11 bits of the value to bits 21 to 31.  */
9177                 insn |= relocation & 0x7ff;
9178
9179                 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9180
9181                 if (r_type == R_PPC_VLE_SDA21
9182                     && ((relocation + 0x80000) & 0xffffffff) > 0x100000)
9183                   goto overflow;
9184                 goto copy_reloc;
9185               }
9186             else if (r_type == R_PPC_EMB_SDA21
9187                      || r_type == R_PPC_VLE_SDA21
9188                      || r_type == R_PPC_VLE_SDA21_LO)
9189               {
9190                 /* Fill in register field.  */
9191                 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
9192               }
9193             bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9194           }
9195           break;
9196
9197         case R_PPC_VLE_SDAREL_LO16A:
9198         case R_PPC_VLE_SDAREL_LO16D:
9199         case R_PPC_VLE_SDAREL_HI16A:
9200         case R_PPC_VLE_SDAREL_HI16D:
9201         case R_PPC_VLE_SDAREL_HA16A:
9202         case R_PPC_VLE_SDAREL_HA16D:
9203           {
9204             bfd_vma value;
9205             const char *name;
9206             //int reg;
9207             struct elf_link_hash_entry *sda = NULL;
9208
9209             if (sec == NULL || sec->output_section == NULL)
9210               {
9211                 unresolved_reloc = TRUE;
9212                 break;
9213               }
9214
9215             name = bfd_get_section_name (output_bfd, sec->output_section);
9216             if (strcmp (name, ".sdata") == 0
9217                 || strcmp (name, ".sbss") == 0)
9218               {
9219                 //reg = 13;
9220                 sda = htab->sdata[0].sym;
9221               }
9222             else if (strcmp (name, ".sdata2") == 0
9223                      || strcmp (name, ".sbss2") == 0)
9224               {
9225                 //reg = 2;
9226                 sda = htab->sdata[1].sym;
9227               }
9228             else
9229               {
9230                 (*_bfd_error_handler)
9231                   (_("%B: the target (%s) of a %s relocation is "
9232                      "in the wrong output section (%s)"),
9233                    input_bfd,
9234                    sym_name,
9235                    howto->name,
9236                    name);
9237
9238                 bfd_set_error (bfd_error_bad_value);
9239                 ret = FALSE;
9240                 goto copy_reloc;
9241               }
9242
9243             if (sda != NULL)
9244               {
9245                 if (!is_static_defined (sda))
9246                   {
9247                     unresolved_reloc = TRUE;
9248                     break;
9249                   }
9250               }
9251
9252             value = (sda->root.u.def.section->output_section->vma
9253                      + sda->root.u.def.section->output_offset
9254                      + addend);
9255
9256             if (r_type == R_PPC_VLE_SDAREL_LO16A)
9257               ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9258                                    value, split16a_type);
9259             else if (r_type == R_PPC_VLE_SDAREL_LO16D)
9260               ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9261                                    value, split16d_type);
9262             else if (r_type == R_PPC_VLE_SDAREL_HI16A)
9263               {
9264                 value = value >> 16;
9265                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9266                                      value, split16a_type);
9267               }
9268             else if (r_type == R_PPC_VLE_SDAREL_HI16D)
9269               {
9270                 value = value >> 16;
9271                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9272                                      value, split16d_type);
9273               }
9274             else if (r_type == R_PPC_VLE_SDAREL_HA16A)
9275               {
9276                 value = (value + 0x8000) >> 16;
9277                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9278                                      value, split16a_type);
9279               }
9280             else if (r_type == R_PPC_VLE_SDAREL_HA16D)
9281               {
9282                 value = (value + 0x8000) >> 16;
9283                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9284                                      value, split16d_type);
9285               }
9286           }
9287           goto copy_reloc;
9288
9289           /* Relocate against the beginning of the section.  */
9290         case R_PPC_SECTOFF:
9291         case R_PPC_SECTOFF_LO:
9292         case R_PPC_SECTOFF_HI:
9293         case R_PPC_SECTOFF_HA:
9294           if (sec == NULL || sec->output_section == NULL)
9295             {
9296               unresolved_reloc = TRUE;
9297               break;
9298             }
9299           addend -= sec->output_section->vma;
9300           break;
9301
9302           /* Negative relocations.  */
9303         case R_PPC_EMB_NADDR32:
9304         case R_PPC_EMB_NADDR16:
9305         case R_PPC_EMB_NADDR16_LO:
9306         case R_PPC_EMB_NADDR16_HI:
9307         case R_PPC_EMB_NADDR16_HA:
9308           addend -= 2 * relocation;
9309           break;
9310
9311         case R_PPC_COPY:
9312         case R_PPC_GLOB_DAT:
9313         case R_PPC_JMP_SLOT:
9314         case R_PPC_RELATIVE:
9315         case R_PPC_IRELATIVE:
9316         case R_PPC_PLT32:
9317         case R_PPC_PLTREL32:
9318         case R_PPC_PLT16_LO:
9319         case R_PPC_PLT16_HI:
9320         case R_PPC_PLT16_HA:
9321         case R_PPC_ADDR30:
9322         case R_PPC_EMB_RELSEC16:
9323         case R_PPC_EMB_RELST_LO:
9324         case R_PPC_EMB_RELST_HI:
9325         case R_PPC_EMB_RELST_HA:
9326         case R_PPC_EMB_BIT_FLD:
9327           info->callbacks->einfo
9328             (_("%P: %B: relocation %s is not yet supported for symbol %s\n"),
9329              input_bfd,
9330              howto->name,
9331              sym_name);
9332
9333           bfd_set_error (bfd_error_invalid_operation);
9334           ret = FALSE;
9335           goto copy_reloc;
9336         }
9337
9338       /* Do any further special processing.  */
9339       switch (r_type)
9340         {
9341         default:
9342           break;
9343
9344         case R_PPC_ADDR16_HA:
9345         case R_PPC_REL16_HA:
9346         case R_PPC_REL16DX_HA:
9347         case R_PPC_SECTOFF_HA:
9348         case R_PPC_TPREL16_HA:
9349         case R_PPC_DTPREL16_HA:
9350         case R_PPC_EMB_NADDR16_HA:
9351         case R_PPC_EMB_RELST_HA:
9352           /* It's just possible that this symbol is a weak symbol
9353              that's not actually defined anywhere.  In that case,
9354              'sec' would be NULL, and we should leave the symbol
9355              alone (it will be set to zero elsewhere in the link).  */
9356           if (sec == NULL)
9357             break;
9358           /* Fall thru */
9359
9360         case R_PPC_PLT16_HA:
9361         case R_PPC_GOT16_HA:
9362         case R_PPC_GOT_TLSGD16_HA:
9363         case R_PPC_GOT_TLSLD16_HA:
9364         case R_PPC_GOT_TPREL16_HA:
9365         case R_PPC_GOT_DTPREL16_HA:
9366           /* Add 0x10000 if sign bit in 0:15 is set.
9367              Bits 0:15 are not used.  */
9368           addend += 0x8000;
9369           break;
9370
9371         case R_PPC_ADDR16:
9372         case R_PPC_ADDR16_LO:
9373         case R_PPC_GOT16:
9374         case R_PPC_GOT16_LO:
9375         case R_PPC_SDAREL16:
9376         case R_PPC_SECTOFF:
9377         case R_PPC_SECTOFF_LO:
9378         case R_PPC_DTPREL16:
9379         case R_PPC_DTPREL16_LO:
9380         case R_PPC_TPREL16:
9381         case R_PPC_TPREL16_LO:
9382         case R_PPC_GOT_TLSGD16:
9383         case R_PPC_GOT_TLSGD16_LO:
9384         case R_PPC_GOT_TLSLD16:
9385         case R_PPC_GOT_TLSLD16_LO:
9386         case R_PPC_GOT_DTPREL16:
9387         case R_PPC_GOT_DTPREL16_LO:
9388         case R_PPC_GOT_TPREL16:
9389         case R_PPC_GOT_TPREL16_LO:
9390           {
9391             /* The 32-bit ABI lacks proper relocations to deal with
9392                certain 64-bit instructions.  Prevent damage to bits
9393                that make up part of the insn opcode.  */
9394             unsigned int insn, mask, lobit;
9395
9396             insn = bfd_get_32 (output_bfd,
9397                                contents + rel->r_offset - d_offset);
9398             mask = 0;
9399             if (is_insn_ds_form (insn))
9400               mask = 3;
9401             else if (is_insn_dq_form (insn))
9402               mask = 15;
9403             else
9404               break;
9405             relocation += addend;
9406             addend = insn & mask;
9407             lobit = mask & relocation;
9408             if (lobit != 0)
9409               {
9410                 relocation ^= lobit;
9411                 info->callbacks->einfo
9412                   (_("%P: %H: error: %s against `%s' not a multiple of %u\n"),
9413                    input_bfd, input_section, rel->r_offset,
9414                    howto->name, sym_name, mask + 1);
9415                 bfd_set_error (bfd_error_bad_value);
9416                 ret = FALSE;
9417               }
9418           }
9419           break;
9420         }
9421
9422 #ifdef DEBUG
9423       fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, "
9424                "offset = %ld, addend = %ld\n",
9425                howto->name,
9426                (int) r_type,
9427                sym_name,
9428                r_symndx,
9429                (long) rel->r_offset,
9430                (long) addend);
9431 #endif
9432
9433       if (unresolved_reloc
9434           && !((input_section->flags & SEC_DEBUGGING) != 0
9435                && h->def_dynamic)
9436           && _bfd_elf_section_offset (output_bfd, info, input_section,
9437                                       rel->r_offset) != (bfd_vma) -1)
9438         {
9439           info->callbacks->einfo
9440             (_("%P: %H: unresolvable %s relocation against symbol `%s'\n"),
9441              input_bfd, input_section, rel->r_offset,
9442              howto->name,
9443              sym_name);
9444           ret = FALSE;
9445         }
9446
9447       /* 16-bit fields in insns mostly have signed values, but a
9448          few insns have 16-bit unsigned values.  Really, we should
9449          have different reloc types.  */
9450       if (howto->complain_on_overflow != complain_overflow_dont
9451           && howto->dst_mask == 0xffff
9452           && (input_section->flags & SEC_CODE) != 0)
9453         {
9454           enum complain_overflow complain = complain_overflow_signed;
9455
9456           if ((elf_section_flags (input_section) & SHF_PPC_VLE) == 0)
9457             {
9458               unsigned int insn;
9459
9460               insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
9461               if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
9462                 complain = complain_overflow_bitfield;
9463               else if ((insn & (0x3f << 26)) == 28u << 26 /* andi */
9464                        || (insn & (0x3f << 26)) == 24u << 26 /* ori */
9465                        || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
9466                 complain = complain_overflow_unsigned;
9467             }
9468           if (howto->complain_on_overflow != complain)
9469             {
9470               alt_howto = *howto;
9471               alt_howto.complain_on_overflow = complain;
9472               howto = &alt_howto;
9473             }
9474         }
9475
9476       if (r_type == R_PPC_REL16DX_HA)
9477         {
9478           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
9479           if (rel->r_offset + 4 > input_section->size)
9480             r = bfd_reloc_outofrange;
9481           else
9482             {
9483               unsigned int insn;
9484
9485               relocation += addend;
9486               relocation -= (rel->r_offset
9487                              + input_section->output_offset
9488                              + input_section->output_section->vma);
9489               relocation >>= 16;
9490               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
9491               insn &= ~0x1fffc1;
9492               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
9493               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
9494               r = bfd_reloc_ok;
9495             }
9496         }
9497       else
9498         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
9499                                       rel->r_offset, relocation, addend);
9500
9501       if (r != bfd_reloc_ok)
9502         {
9503           if (r == bfd_reloc_overflow)
9504             {
9505             overflow:
9506               /* On code like "if (foo) foo();" don't report overflow
9507                  on a branch to zero when foo is undefined.  */
9508               if (!warned
9509                   && !(h != NULL
9510                        && (h->root.type == bfd_link_hash_undefweak
9511                            || h->root.type == bfd_link_hash_undefined)
9512                        && is_branch_reloc (r_type)))
9513                 {
9514                   if (!((*info->callbacks->reloc_overflow)
9515                         (info, (h ? &h->root : NULL), sym_name,
9516                          howto->name, rel->r_addend,
9517                          input_bfd, input_section, rel->r_offset)))
9518                     return FALSE;
9519                 }
9520             }
9521           else
9522             {
9523               info->callbacks->einfo
9524                 (_("%P: %H: %s reloc against `%s': error %d\n"),
9525                  input_bfd, input_section, rel->r_offset,
9526                  howto->name, sym_name, (int) r);
9527               ret = FALSE;
9528             }
9529         }
9530     copy_reloc:
9531       if (wrel != rel)
9532         *wrel = *rel;
9533     }
9534
9535   if (wrel != rel)
9536     {
9537       Elf_Internal_Shdr *rel_hdr;
9538       size_t deleted = rel - wrel;
9539
9540       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
9541       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9542       if (rel_hdr->sh_size == 0)
9543         {
9544           /* It is too late to remove an empty reloc section.  Leave
9545              one NONE reloc.
9546              ??? What is wrong with an empty section???  */
9547           rel_hdr->sh_size = rel_hdr->sh_entsize;
9548           deleted -= 1;
9549           wrel++;
9550         }
9551       relend = wrel;
9552       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
9553       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9554       input_section->reloc_count -= deleted;
9555     }
9556
9557 #ifdef DEBUG
9558   fprintf (stderr, "\n");
9559 #endif
9560
9561   if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9562       && input_section->size != input_section->rawsize
9563       && (strcmp (input_section->output_section->name, ".init") == 0
9564           || strcmp (input_section->output_section->name, ".fini") == 0))
9565     {
9566       /* Branch around the trampolines.  */
9567       unsigned int insn = B + input_section->size - input_section->rawsize;
9568       bfd_put_32 (input_bfd, insn, contents + input_section->rawsize);
9569     }
9570
9571   if (htab->params->ppc476_workaround
9572       && input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9573       && (!bfd_link_relocatable (info)
9574           || (input_section->output_section->alignment_power
9575               >= htab->params->pagesize_p2)))
9576     {
9577       bfd_vma start_addr, end_addr, addr;
9578       bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
9579
9580       if (relax_info->workaround_size != 0)
9581         {
9582           bfd_byte *p;
9583           unsigned int n;
9584           bfd_byte fill[4];
9585
9586           bfd_put_32 (input_bfd, BA, fill);
9587           p = contents + input_section->size - relax_info->workaround_size;
9588           n = relax_info->workaround_size >> 2;
9589           while (n--)
9590             {
9591               memcpy (p, fill, 4);
9592               p += 4;
9593             }
9594         }
9595
9596       /* The idea is: Replace the last instruction on a page with a
9597          branch to a patch area.  Put the insn there followed by a
9598          branch back to the next page.  Complicated a little by
9599          needing to handle moved conditional branches, and by not
9600          wanting to touch data-in-text.  */
9601
9602       start_addr = (input_section->output_section->vma
9603                     + input_section->output_offset);
9604       end_addr = (start_addr + input_section->size
9605                   - relax_info->workaround_size);
9606       for (addr = ((start_addr & -pagesize) + pagesize - 4);
9607            addr < end_addr;
9608            addr += pagesize)
9609         {
9610           bfd_vma offset = addr - start_addr;
9611           Elf_Internal_Rela *lo, *hi;
9612           bfd_boolean is_data;
9613           bfd_vma patch_off, patch_addr;
9614           unsigned int insn;
9615
9616           /* Do we have a data reloc at this offset?  If so, leave
9617              the word alone.  */
9618           is_data = FALSE;
9619           lo = relocs;
9620           hi = relend;
9621           rel = NULL;
9622           while (lo < hi)
9623             {
9624               rel = lo + (hi - lo) / 2;
9625               if (rel->r_offset < offset)
9626                 lo = rel + 1;
9627               else if (rel->r_offset > offset + 3)
9628                 hi = rel;
9629               else
9630                 {
9631                   switch (ELF32_R_TYPE (rel->r_info))
9632                     {
9633                     case R_PPC_ADDR32:
9634                     case R_PPC_UADDR32:
9635                     case R_PPC_REL32:
9636                     case R_PPC_ADDR30:
9637                       is_data = TRUE;
9638                       break;
9639                     default:
9640                       break;
9641                     }
9642                   break;
9643                 }
9644             }
9645           if (is_data)
9646             continue;
9647
9648           /* Some instructions can be left alone too.  Unconditional
9649              branches, except for bcctr with BO=0x14 (bctr, bctrl),
9650              avoid the icache failure.
9651
9652              The problem occurs due to prefetch across a page boundary
9653              where stale instructions can be fetched from the next
9654              page, and the mechanism for flushing these bad
9655              instructions fails under certain circumstances.  The
9656              unconditional branches:
9657              1) Branch: b, bl, ba, bla,
9658              2) Branch Conditional: bc, bca, bcl, bcla,
9659              3) Branch Conditional to Link Register: bclr, bclrl,
9660              where (2) and (3) have BO=0x14 making them unconditional,
9661              prevent the bad prefetch because the prefetch itself is
9662              affected by these instructions.  This happens even if the
9663              instruction is not executed.
9664
9665              A bctr example:
9666              .
9667              .  lis 9,new_page@ha
9668              .  addi 9,9,new_page@l
9669              .  mtctr 9
9670              .  bctr
9671              .  nop
9672              .  nop
9673              . new_page:
9674              .
9675              The bctr is not predicted taken due to ctr not being
9676              ready, so prefetch continues on past the bctr into the
9677              new page which might have stale instructions.  If they
9678              fail to be flushed, then they will be executed after the
9679              bctr executes.  Either of the following modifications
9680              prevent the bad prefetch from happening in the first
9681              place:
9682              .
9683              .  lis 9,new_page@ha        lis 9,new_page@ha
9684              .  addi 9,9,new_page@l      addi 9,9,new_page@l
9685              .  mtctr 9                  mtctr 9
9686              .  bctr                     bctr
9687              .  nop                      b somewhere_else
9688              .  b somewhere_else         nop
9689              . new_page:                new_page:
9690              .  */
9691           insn = bfd_get_32 (input_bfd, contents + offset);
9692           if ((insn & (0x3f << 26)) == (18u << 26)          /* b,bl,ba,bla */
9693               || ((insn & (0x3f << 26)) == (16u << 26)      /* bc,bcl,bca,bcla*/
9694                   && (insn & (0x14 << 21)) == (0x14 << 21)) /*   with BO=0x14 */
9695               || ((insn & (0x3f << 26)) == (19u << 26)
9696                   && (insn & (0x3ff << 1)) == (16u << 1)    /* bclr,bclrl */
9697                   && (insn & (0x14 << 21)) == (0x14 << 21)))/*   with BO=0x14 */
9698             continue;
9699
9700           patch_addr = (start_addr + input_section->size
9701                         - relax_info->workaround_size);
9702           patch_addr = (patch_addr + 15) & -16;
9703           patch_off = patch_addr - start_addr;
9704           bfd_put_32 (input_bfd, B + patch_off - offset, contents + offset);
9705
9706           if (rel != NULL
9707               && rel->r_offset >= offset
9708               && rel->r_offset < offset + 4)
9709             {
9710               asection *sreloc;
9711
9712               /* If the insn we are patching had a reloc, adjust the
9713                  reloc r_offset so that the reloc applies to the moved
9714                  location.  This matters for -r and --emit-relocs.  */
9715               if (rel + 1 != relend)
9716                 {
9717                   Elf_Internal_Rela tmp = *rel;
9718
9719                   /* Keep the relocs sorted by r_offset.  */
9720                   memmove (rel, rel + 1, (relend - (rel + 1)) * sizeof (*rel));
9721                   relend[-1] = tmp;
9722                 }
9723               relend[-1].r_offset += patch_off - offset;
9724
9725               /* Adjust REL16 addends too.  */
9726               switch (ELF32_R_TYPE (relend[-1].r_info))
9727                 {
9728                 case R_PPC_REL16:
9729                 case R_PPC_REL16_LO:
9730                 case R_PPC_REL16_HI:
9731                 case R_PPC_REL16_HA:
9732                   relend[-1].r_addend += patch_off - offset;
9733                   break;
9734                 default:
9735                   break;
9736                 }
9737
9738               /* If we are building a PIE or shared library with
9739                  non-PIC objects, perhaps we had a dynamic reloc too?
9740                  If so, the dynamic reloc must move with the insn.  */
9741               sreloc = elf_section_data (input_section)->sreloc;
9742               if (sreloc != NULL)
9743                 {
9744                   Elf32_External_Rela *slo, *shi, *srelend;
9745                   bfd_vma soffset;
9746
9747                   slo = (Elf32_External_Rela *) sreloc->contents;
9748                   shi = srelend = slo + sreloc->reloc_count;
9749                   soffset = (offset + input_section->output_section->vma
9750                              + input_section->output_offset);
9751                   while (slo < shi)
9752                     {
9753                       Elf32_External_Rela *srel = slo + (shi - slo) / 2;
9754                       bfd_elf32_swap_reloca_in (output_bfd, (bfd_byte *) srel,
9755                                                 &outrel);
9756                       if (outrel.r_offset < soffset)
9757                         slo = srel + 1;
9758                       else if (outrel.r_offset > soffset + 3)
9759                         shi = srel;
9760                       else
9761                         {
9762                           if (srel + 1 != srelend)
9763                             {
9764                               memmove (srel, srel + 1,
9765                                        (srelend - (srel + 1)) * sizeof (*srel));
9766                               srel = srelend - 1;
9767                             }
9768                           outrel.r_offset += patch_off - offset;
9769                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,
9770                                                      (bfd_byte *) srel);
9771                           break;
9772                         }
9773                     }
9774                 }
9775             }
9776           else
9777             rel = NULL;
9778
9779           if ((insn & (0x3f << 26)) == (16u << 26) /* bc */
9780               && (insn & 2) == 0 /* relative */)
9781             {
9782               bfd_vma delta = ((insn & 0xfffc) ^ 0x8000) - 0x8000;
9783
9784               delta += offset - patch_off;
9785               if (bfd_link_relocatable (info) && rel != NULL)
9786                 delta = 0;
9787               if (!bfd_link_relocatable (info) && rel != NULL)
9788                 {
9789                   enum elf_ppc_reloc_type r_type;
9790
9791                   r_type = ELF32_R_TYPE (relend[-1].r_info);
9792                   if (r_type == R_PPC_REL14_BRTAKEN)
9793                     insn |= BRANCH_PREDICT_BIT;
9794                   else if (r_type == R_PPC_REL14_BRNTAKEN)
9795                     insn &= ~BRANCH_PREDICT_BIT;
9796                   else
9797                     BFD_ASSERT (r_type == R_PPC_REL14);
9798
9799                   if ((r_type == R_PPC_REL14_BRTAKEN
9800                        || r_type == R_PPC_REL14_BRNTAKEN)
9801                       && delta + 0x8000 < 0x10000
9802                       && (bfd_signed_vma) delta < 0)
9803                     insn ^= BRANCH_PREDICT_BIT;
9804                 }
9805               if (delta + 0x8000 < 0x10000)
9806                 {
9807                   bfd_put_32 (input_bfd,
9808                               (insn & ~0xfffc) | (delta & 0xfffc),
9809                               contents + patch_off);
9810                   patch_off += 4;
9811                   bfd_put_32 (input_bfd,
9812                               B | ((offset + 4 - patch_off) & 0x3fffffc),
9813                               contents + patch_off);
9814                   patch_off += 4;
9815                 }
9816               else
9817                 {
9818                   if (rel != NULL)
9819                     {
9820                       unsigned int r_sym = ELF32_R_SYM (relend[-1].r_info);
9821
9822                       relend[-1].r_offset += 8;
9823                       relend[-1].r_info = ELF32_R_INFO (r_sym, R_PPC_REL24);
9824                     }
9825                   bfd_put_32 (input_bfd,
9826                               (insn & ~0xfffc) | 8,
9827                               contents + patch_off);
9828                   patch_off += 4;
9829                   bfd_put_32 (input_bfd,
9830                               B | ((offset + 4 - patch_off) & 0x3fffffc),
9831                               contents + patch_off);
9832                   patch_off += 4;
9833                   bfd_put_32 (input_bfd,
9834                               B | ((delta - 8) & 0x3fffffc),
9835                               contents + patch_off);
9836                   patch_off += 4;
9837                 }
9838             }
9839           else
9840             {
9841               bfd_put_32 (input_bfd, insn, contents + patch_off);
9842               patch_off += 4;
9843               bfd_put_32 (input_bfd,
9844                           B | ((offset + 4 - patch_off) & 0x3fffffc),
9845                           contents + patch_off);
9846               patch_off += 4;
9847             }
9848           BFD_ASSERT (patch_off <= input_section->size);
9849           relax_info->workaround_size = input_section->size - patch_off;
9850         }
9851     }
9852
9853   return ret;
9854 }
9855 \f
9856 /* Finish up dynamic symbol handling.  We set the contents of various
9857    dynamic sections here.  */
9858
9859 static bfd_boolean
9860 ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
9861                                struct bfd_link_info *info,
9862                                struct elf_link_hash_entry *h,
9863                                Elf_Internal_Sym *sym)
9864 {
9865   struct ppc_elf_link_hash_table *htab;
9866   struct plt_entry *ent;
9867   bfd_boolean doneone;
9868
9869 #ifdef DEBUG
9870   fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
9871            h->root.root.string);
9872 #endif
9873
9874   htab = ppc_elf_hash_table (info);
9875   BFD_ASSERT (htab->elf.dynobj != NULL);
9876
9877   doneone = FALSE;
9878   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
9879     if (ent->plt.offset != (bfd_vma) -1)
9880       {
9881         if (!doneone)
9882           {
9883             Elf_Internal_Rela rela;
9884             bfd_byte *loc;
9885             bfd_vma reloc_index;
9886
9887             if (htab->plt_type == PLT_NEW
9888                 || !htab->elf.dynamic_sections_created
9889                 || h->dynindx == -1)
9890               reloc_index = ent->plt.offset / 4;
9891             else
9892               {
9893                 reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size)
9894                                / htab->plt_slot_size);
9895                 if (reloc_index > PLT_NUM_SINGLE_ENTRIES
9896                     && htab->plt_type == PLT_OLD)
9897                   reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
9898               }
9899
9900             /* This symbol has an entry in the procedure linkage table.
9901                Set it up.  */
9902             if (htab->plt_type == PLT_VXWORKS
9903                 && htab->elf.dynamic_sections_created
9904                 && h->dynindx != -1)
9905               {
9906                 bfd_vma got_offset;
9907                 const bfd_vma *plt_entry;
9908
9909                 /* The first three entries in .got.plt are reserved.  */
9910                 got_offset = (reloc_index + 3) * 4;
9911
9912                 /* Use the right PLT. */
9913                 plt_entry = bfd_link_pic (info) ? ppc_elf_vxworks_pic_plt_entry
9914                             : ppc_elf_vxworks_plt_entry;
9915
9916                 /* Fill in the .plt on VxWorks.  */
9917                 if (bfd_link_pic (info))
9918                   {
9919                     bfd_put_32 (output_bfd,
9920                                 plt_entry[0] | PPC_HA (got_offset),
9921                                 htab->plt->contents + ent->plt.offset + 0);
9922                     bfd_put_32 (output_bfd,
9923                                 plt_entry[1] | PPC_LO (got_offset),
9924                                 htab->plt->contents + ent->plt.offset + 4);
9925                   }
9926                 else
9927                   {
9928                     bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot);
9929
9930                     bfd_put_32 (output_bfd,
9931                                 plt_entry[0] | PPC_HA (got_loc),
9932                                 htab->plt->contents + ent->plt.offset + 0);
9933                     bfd_put_32 (output_bfd,
9934                                 plt_entry[1] | PPC_LO (got_loc),
9935                                 htab->plt->contents + ent->plt.offset + 4);
9936                   }
9937
9938                 bfd_put_32 (output_bfd, plt_entry[2],
9939                             htab->plt->contents + ent->plt.offset + 8);
9940                 bfd_put_32 (output_bfd, plt_entry[3],
9941                             htab->plt->contents + ent->plt.offset + 12);
9942
9943                 /* This instruction is an immediate load.  The value loaded is
9944                    the byte offset of the R_PPC_JMP_SLOT relocation from the
9945                    start of the .rela.plt section.  The value is stored in the
9946                    low-order 16 bits of the load instruction.  */
9947                 /* NOTE: It appears that this is now an index rather than a
9948                    prescaled offset.  */
9949                 bfd_put_32 (output_bfd,
9950                             plt_entry[4] | reloc_index,
9951                             htab->plt->contents + ent->plt.offset + 16);
9952                 /* This instruction is a PC-relative branch whose target is
9953                    the start of the PLT section.  The address of this branch
9954                    instruction is 20 bytes beyond the start of this PLT entry.
9955                    The address is encoded in bits 6-29, inclusive.  The value
9956                    stored is right-shifted by two bits, permitting a 26-bit
9957                    offset.  */
9958                 bfd_put_32 (output_bfd,
9959                             (plt_entry[5]
9960                              | (-(ent->plt.offset + 20) & 0x03fffffc)),
9961                             htab->plt->contents + ent->plt.offset + 20);
9962                 bfd_put_32 (output_bfd, plt_entry[6],
9963                             htab->plt->contents + ent->plt.offset + 24);
9964                 bfd_put_32 (output_bfd, plt_entry[7],
9965                             htab->plt->contents + ent->plt.offset + 28);
9966
9967                 /* Fill in the GOT entry corresponding to this PLT slot with
9968                    the address immediately after the "bctr" instruction
9969                    in this PLT entry.  */
9970                 bfd_put_32 (output_bfd, (htab->plt->output_section->vma
9971                                          + htab->plt->output_offset
9972                                          + ent->plt.offset + 16),
9973                             htab->sgotplt->contents + got_offset);
9974
9975                 if (!bfd_link_pic (info))
9976                   {
9977                     /* Fill in a couple of entries in .rela.plt.unloaded.  */
9978                     loc = htab->srelplt2->contents
9979                       + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index
9980                           * VXWORKS_PLT_NON_JMP_SLOT_RELOCS)
9981                          * sizeof (Elf32_External_Rela));
9982
9983                     /* Provide the @ha relocation for the first instruction.  */
9984                     rela.r_offset = (htab->plt->output_section->vma
9985                                      + htab->plt->output_offset
9986                                      + ent->plt.offset + 2);
9987                     rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9988                                                 R_PPC_ADDR16_HA);
9989                     rela.r_addend = got_offset;
9990                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9991                     loc += sizeof (Elf32_External_Rela);
9992
9993                     /* Provide the @l relocation for the second instruction.  */
9994                     rela.r_offset = (htab->plt->output_section->vma
9995                                      + htab->plt->output_offset
9996                                      + ent->plt.offset + 6);
9997                     rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9998                                                 R_PPC_ADDR16_LO);
9999                     rela.r_addend = got_offset;
10000                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10001                     loc += sizeof (Elf32_External_Rela);
10002
10003                     /* Provide a relocation for the GOT entry corresponding to this
10004                        PLT slot.  Point it at the middle of the .plt entry.  */
10005                     rela.r_offset = (htab->sgotplt->output_section->vma
10006                                      + htab->sgotplt->output_offset
10007                                      + got_offset);
10008                     rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
10009                                                 R_PPC_ADDR32);
10010                     rela.r_addend = ent->plt.offset + 16;
10011                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10012                   }
10013
10014                 /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT.
10015                    In particular, the offset for the relocation is not the
10016                    address of the PLT entry for this function, as specified
10017                    by the ABI.  Instead, the offset is set to the address of
10018                    the GOT slot for this function.  See EABI 4.4.4.1.  */
10019                 rela.r_offset = (htab->sgotplt->output_section->vma
10020                                  + htab->sgotplt->output_offset
10021                                  + got_offset);
10022
10023               }
10024             else
10025               {
10026                 asection *splt = htab->plt;
10027                 if (!htab->elf.dynamic_sections_created
10028                     || h->dynindx == -1)
10029                   splt = htab->iplt;
10030
10031                 rela.r_offset = (splt->output_section->vma
10032                                  + splt->output_offset
10033                                  + ent->plt.offset);
10034                 if (htab->plt_type == PLT_OLD
10035                     || !htab->elf.dynamic_sections_created
10036                     || h->dynindx == -1)
10037                   {
10038                     /* We don't need to fill in the .plt.  The ppc dynamic
10039                        linker will fill it in.  */
10040                   }
10041                 else
10042                   {
10043                     bfd_vma val = (htab->glink_pltresolve + ent->plt.offset
10044                                    + htab->glink->output_section->vma
10045                                    + htab->glink->output_offset);
10046                     bfd_put_32 (output_bfd, val,
10047                                 splt->contents + ent->plt.offset);
10048                   }
10049               }
10050
10051             /* Fill in the entry in the .rela.plt section.  */
10052             rela.r_addend = 0;
10053             if (!htab->elf.dynamic_sections_created
10054                 || h->dynindx == -1)
10055               {
10056                 BFD_ASSERT (h->type == STT_GNU_IFUNC
10057                             && h->def_regular
10058                             && (h->root.type == bfd_link_hash_defined
10059                                 || h->root.type == bfd_link_hash_defweak));
10060                 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
10061                 rela.r_addend = SYM_VAL (h);
10062               }
10063             else
10064               rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
10065
10066             if (!htab->elf.dynamic_sections_created
10067                 || h->dynindx == -1)
10068               loc = (htab->reliplt->contents
10069                      + (htab->reliplt->reloc_count++
10070                         * sizeof (Elf32_External_Rela)));
10071             else
10072               loc = (htab->relplt->contents
10073                      + reloc_index * sizeof (Elf32_External_Rela));
10074             bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10075
10076             if (!h->def_regular)
10077               {
10078                 /* Mark the symbol as undefined, rather than as
10079                    defined in the .plt section.  Leave the value if
10080                    there were any relocations where pointer equality
10081                    matters (this is a clue for the dynamic linker, to
10082                    make function pointer comparisons work between an
10083                    application and shared library), otherwise set it
10084                    to zero.  */
10085                 sym->st_shndx = SHN_UNDEF;
10086                 if (!h->pointer_equality_needed)
10087                   sym->st_value = 0;
10088                 else if (!h->ref_regular_nonweak)
10089                   {
10090                     /* This breaks function pointer comparisons, but
10091                        that is better than breaking tests for a NULL
10092                        function pointer.  */
10093                     sym->st_value = 0;
10094                   }
10095               }
10096             else if (h->type == STT_GNU_IFUNC
10097                      && !bfd_link_pic (info))
10098               {
10099                 /* Set the value of ifunc symbols in a non-pie
10100                    executable to the glink entry.  This is to avoid
10101                    text relocations.  We can't do this for ifunc in
10102                    allocate_dynrelocs, as we do for normal dynamic
10103                    function symbols with plt entries, because we need
10104                    to keep the original value around for the ifunc
10105                    relocation.  */
10106                 sym->st_shndx = (_bfd_elf_section_from_bfd_section
10107                                  (output_bfd, htab->glink->output_section));
10108                 sym->st_value = (ent->glink_offset
10109                                  + htab->glink->output_offset
10110                                  + htab->glink->output_section->vma);
10111               }
10112             doneone = TRUE;
10113           }
10114
10115         if (htab->plt_type == PLT_NEW
10116             || !htab->elf.dynamic_sections_created
10117             || h->dynindx == -1)
10118           {
10119             unsigned char *p;
10120             asection *splt = htab->plt;
10121             if (!htab->elf.dynamic_sections_created
10122                 || h->dynindx == -1)
10123               splt = htab->iplt;
10124
10125             p = (unsigned char *) htab->glink->contents + ent->glink_offset;
10126
10127             if (h == htab->tls_get_addr && !htab->params->no_tls_get_addr_opt)
10128               {
10129                 bfd_put_32 (output_bfd, LWZ_11_3, p);
10130                 p += 4;
10131                 bfd_put_32 (output_bfd, LWZ_12_3 + 4, p);
10132                 p += 4;
10133                 bfd_put_32 (output_bfd, MR_0_3, p);
10134                 p += 4;
10135                 bfd_put_32 (output_bfd, CMPWI_11_0, p);
10136                 p += 4;
10137                 bfd_put_32 (output_bfd, ADD_3_12_2, p);
10138                 p += 4;
10139                 bfd_put_32 (output_bfd, BEQLR, p);
10140                 p += 4;
10141                 bfd_put_32 (output_bfd, MR_3_0, p);
10142                 p += 4;
10143                 bfd_put_32 (output_bfd, NOP, p);
10144                 p += 4;
10145               }
10146
10147             write_glink_stub (ent, splt, p, info);
10148
10149             if (!bfd_link_pic (info))
10150               /* We only need one non-PIC glink stub.  */
10151               break;
10152           }
10153         else
10154           break;
10155       }
10156
10157   if (h->needs_copy)
10158     {
10159       asection *s;
10160       Elf_Internal_Rela rela;
10161       bfd_byte *loc;
10162
10163       /* This symbols needs a copy reloc.  Set it up.  */
10164
10165 #ifdef DEBUG
10166       fprintf (stderr, ", copy");
10167 #endif
10168
10169       BFD_ASSERT (h->dynindx != -1);
10170
10171       if (ppc_elf_hash_entry (h)->has_sda_refs)
10172         s = htab->relsbss;
10173       else
10174         s = htab->relbss;
10175       BFD_ASSERT (s != NULL);
10176
10177       rela.r_offset = SYM_VAL (h);
10178       rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
10179       rela.r_addend = 0;
10180       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
10181       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10182     }
10183
10184 #ifdef DEBUG
10185   fprintf (stderr, "\n");
10186 #endif
10187
10188   return TRUE;
10189 }
10190 \f
10191 static enum elf_reloc_type_class
10192 ppc_elf_reloc_type_class (const struct bfd_link_info *info,
10193                           const asection *rel_sec,
10194                           const Elf_Internal_Rela *rela)
10195 {
10196   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
10197
10198   if (rel_sec == htab->reliplt)
10199     return reloc_class_ifunc;
10200
10201   switch (ELF32_R_TYPE (rela->r_info))
10202     {
10203     case R_PPC_RELATIVE:
10204       return reloc_class_relative;
10205     case R_PPC_JMP_SLOT:
10206       return reloc_class_plt;
10207     case R_PPC_COPY:
10208       return reloc_class_copy;
10209     default:
10210       return reloc_class_normal;
10211     }
10212 }
10213 \f
10214 /* Finish up the dynamic sections.  */
10215
10216 static bfd_boolean
10217 ppc_elf_finish_dynamic_sections (bfd *output_bfd,
10218                                  struct bfd_link_info *info)
10219 {
10220   asection *sdyn;
10221   asection *splt;
10222   struct ppc_elf_link_hash_table *htab;
10223   bfd_vma got;
10224   bfd *dynobj;
10225   bfd_boolean ret = TRUE;
10226
10227 #ifdef DEBUG
10228   fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
10229 #endif
10230
10231   htab = ppc_elf_hash_table (info);
10232   dynobj = elf_hash_table (info)->dynobj;
10233   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
10234   if (htab->is_vxworks)
10235     splt = bfd_get_linker_section (dynobj, ".plt");
10236   else
10237     splt = NULL;
10238
10239   got = 0;
10240   if (htab->elf.hgot != NULL)
10241     got = SYM_VAL (htab->elf.hgot);
10242
10243   if (htab->elf.dynamic_sections_created)
10244     {
10245       Elf32_External_Dyn *dyncon, *dynconend;
10246
10247       BFD_ASSERT (htab->plt != NULL && sdyn != NULL);
10248
10249       dyncon = (Elf32_External_Dyn *) sdyn->contents;
10250       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
10251       for (; dyncon < dynconend; dyncon++)
10252         {
10253           Elf_Internal_Dyn dyn;
10254           asection *s;
10255
10256           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
10257
10258           switch (dyn.d_tag)
10259             {
10260             case DT_PLTGOT:
10261               if (htab->is_vxworks)
10262                 s = htab->sgotplt;
10263               else
10264                 s = htab->plt;
10265               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10266               break;
10267
10268             case DT_PLTRELSZ:
10269               dyn.d_un.d_val = htab->relplt->size;
10270               break;
10271
10272             case DT_JMPREL:
10273               s = htab->relplt;
10274               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10275               break;
10276
10277             case DT_PPC_GOT:
10278               dyn.d_un.d_ptr = got;
10279               break;
10280
10281             case DT_RELASZ:
10282               if (htab->is_vxworks)
10283                 {
10284                   if (htab->relplt)
10285                     dyn.d_un.d_ptr -= htab->relplt->size;
10286                   break;
10287                 }
10288               continue;
10289
10290             default:
10291               if (htab->is_vxworks
10292                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
10293                 break;
10294               continue;
10295             }
10296
10297           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
10298         }
10299     }
10300
10301   if (htab->got != NULL)
10302     {
10303       if (htab->elf.hgot->root.u.def.section == htab->got
10304           || htab->elf.hgot->root.u.def.section == htab->sgotplt)
10305         {
10306           unsigned char *p = htab->elf.hgot->root.u.def.section->contents;
10307
10308           p += htab->elf.hgot->root.u.def.value;
10309           if (htab->plt_type == PLT_OLD)
10310             {
10311               /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4
10312                  so that a function can easily find the address of
10313                  _GLOBAL_OFFSET_TABLE_.  */
10314               BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4
10315                           < htab->elf.hgot->root.u.def.section->size);
10316               bfd_put_32 (output_bfd, 0x4e800021, p - 4);
10317             }
10318
10319           if (sdyn != NULL)
10320             {
10321               bfd_vma val = sdyn->output_section->vma + sdyn->output_offset;
10322               BFD_ASSERT (htab->elf.hgot->root.u.def.value
10323                           < htab->elf.hgot->root.u.def.section->size);
10324               bfd_put_32 (output_bfd, val, p);
10325             }
10326         }
10327       else
10328         {
10329           info->callbacks->einfo (_("%P: %s not defined in linker created %s\n"),
10330                                   htab->elf.hgot->root.root.string,
10331                                   (htab->sgotplt != NULL
10332                                    ? htab->sgotplt->name : htab->got->name));
10333           bfd_set_error (bfd_error_bad_value);
10334           ret = FALSE;
10335         }
10336
10337       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
10338     }
10339
10340   /* Fill in the first entry in the VxWorks procedure linkage table.  */
10341   if (splt && splt->size > 0)
10342     {
10343       /* Use the right PLT. */
10344       const bfd_vma *plt_entry = (bfd_link_pic (info)
10345                                   ? ppc_elf_vxworks_pic_plt0_entry
10346                                   : ppc_elf_vxworks_plt0_entry);
10347
10348       if (!bfd_link_pic (info))
10349         {
10350           bfd_vma got_value = SYM_VAL (htab->elf.hgot);
10351
10352           bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value),
10353                       splt->contents +  0);
10354           bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value),
10355                       splt->contents +  4);
10356         }
10357       else
10358         {
10359           bfd_put_32 (output_bfd, plt_entry[0], splt->contents +  0);
10360           bfd_put_32 (output_bfd, plt_entry[1], splt->contents +  4);
10361         }
10362       bfd_put_32 (output_bfd, plt_entry[2], splt->contents +  8);
10363       bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12);
10364       bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16);
10365       bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20);
10366       bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24);
10367       bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28);
10368
10369       if (! bfd_link_pic (info))
10370         {
10371           Elf_Internal_Rela rela;
10372           bfd_byte *loc;
10373
10374           loc = htab->srelplt2->contents;
10375
10376           /* Output the @ha relocation for the first instruction.  */
10377           rela.r_offset = (htab->plt->output_section->vma
10378                            + htab->plt->output_offset
10379                            + 2);
10380           rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
10381           rela.r_addend = 0;
10382           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10383           loc += sizeof (Elf32_External_Rela);
10384
10385           /* Output the @l relocation for the second instruction.  */
10386           rela.r_offset = (htab->plt->output_section->vma
10387                            + htab->plt->output_offset
10388                            + 6);
10389           rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
10390           rela.r_addend = 0;
10391           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10392           loc += sizeof (Elf32_External_Rela);
10393
10394           /* Fix up the remaining relocations.  They may have the wrong
10395              symbol index for _G_O_T_ or _P_L_T_ depending on the order
10396              in which symbols were output.  */
10397           while (loc < htab->srelplt2->contents + htab->srelplt2->size)
10398             {
10399               Elf_Internal_Rela rel;
10400
10401               bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10402               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
10403               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10404               loc += sizeof (Elf32_External_Rela);
10405
10406               bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10407               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
10408               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10409               loc += sizeof (Elf32_External_Rela);
10410
10411               bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10412               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32);
10413               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10414               loc += sizeof (Elf32_External_Rela);
10415             }
10416         }
10417     }
10418
10419   if (htab->glink != NULL
10420       && htab->glink->contents != NULL
10421       && htab->elf.dynamic_sections_created)
10422     {
10423       unsigned char *p;
10424       unsigned char *endp;
10425       bfd_vma res0;
10426       unsigned int i;
10427
10428       /*
10429        * PIC glink code is the following:
10430        *
10431        * # ith PLT code stub.
10432        *   addis 11,30,(plt+(i-1)*4-got)@ha
10433        *   lwz 11,(plt+(i-1)*4-got)@l(11)
10434        *   mtctr 11
10435        *   bctr
10436        *
10437        * # A table of branches, one for each plt entry.
10438        * # The idea is that the plt call stub loads ctr and r11 with these
10439        * # addresses, so (r11 - res_0) gives the plt index * 4.
10440        * res_0: b PLTresolve
10441        * res_1: b PLTresolve
10442        * .
10443        * # Some number of entries towards the end can be nops
10444        * res_n_m3: nop
10445        * res_n_m2: nop
10446        * res_n_m1:
10447        *
10448        * PLTresolve:
10449        *    addis 11,11,(1f-res_0)@ha
10450        *    mflr 0
10451        *    bcl 20,31,1f
10452        * 1: addi 11,11,(1b-res_0)@l
10453        *    mflr 12
10454        *    mtlr 0
10455        *    sub 11,11,12                # r11 = index * 4
10456        *    addis 12,12,(got+4-1b)@ha
10457        *    lwz 0,(got+4-1b)@l(12)      # got[1] address of dl_runtime_resolve
10458        *    lwz 12,(got+8-1b)@l(12)     # got[2] contains the map address
10459        *    mtctr 0
10460        *    add 0,11,11
10461        *    add 11,0,11                 # r11 = index * 12 = reloc offset.
10462        *    bctr
10463        */
10464       static const unsigned int pic_plt_resolve[] =
10465         {
10466           ADDIS_11_11,
10467           MFLR_0,
10468           BCL_20_31,
10469           ADDI_11_11,
10470           MFLR_12,
10471           MTLR_0,
10472           SUB_11_11_12,
10473           ADDIS_12_12,
10474           LWZ_0_12,
10475           LWZ_12_12,
10476           MTCTR_0,
10477           ADD_0_11_11,
10478           ADD_11_0_11,
10479           BCTR,
10480           NOP,
10481           NOP
10482         };
10483
10484       /*
10485        * Non-PIC glink code is a little simpler.
10486        *
10487        * # ith PLT code stub.
10488        *   lis 11,(plt+(i-1)*4)@ha
10489        *   lwz 11,(plt+(i-1)*4)@l(11)
10490        *   mtctr 11
10491        *   bctr
10492        *
10493        * The branch table is the same, then comes
10494        *
10495        * PLTresolve:
10496        *    lis 12,(got+4)@ha
10497        *    addis 11,11,(-res_0)@ha
10498        *    lwz 0,(got+4)@l(12)         # got[1] address of dl_runtime_resolve
10499        *    addi 11,11,(-res_0)@l       # r11 = index * 4
10500        *    mtctr 0
10501        *    add 0,11,11
10502        *    lwz 12,(got+8)@l(12)        # got[2] contains the map address
10503        *    add 11,0,11                 # r11 = index * 12 = reloc offset.
10504        *    bctr
10505        */
10506       static const unsigned int plt_resolve[] =
10507         {
10508           LIS_12,
10509           ADDIS_11_11,
10510           LWZ_0_12,
10511           ADDI_11_11,
10512           MTCTR_0,
10513           ADD_0_11_11,
10514           LWZ_12_12,
10515           ADD_11_0_11,
10516           BCTR,
10517           NOP,
10518           NOP,
10519           NOP,
10520           NOP,
10521           NOP,
10522           NOP,
10523           NOP
10524         };
10525
10526       if (ARRAY_SIZE (pic_plt_resolve) != GLINK_PLTRESOLVE / 4)
10527         abort ();
10528       if (ARRAY_SIZE (plt_resolve) != GLINK_PLTRESOLVE / 4)
10529         abort ();
10530
10531       /* Build the branch table, one for each plt entry (less one),
10532          and perhaps some padding.  */
10533       p = htab->glink->contents;
10534       p += htab->glink_pltresolve;
10535       endp = htab->glink->contents;
10536       endp += htab->glink->size - GLINK_PLTRESOLVE;
10537       while (p < endp - (htab->params->ppc476_workaround ? 0 : 8 * 4))
10538         {
10539           bfd_put_32 (output_bfd, B + endp - p, p);
10540           p += 4;
10541         }
10542       while (p < endp)
10543         {
10544           bfd_put_32 (output_bfd, NOP, p);
10545           p += 4;
10546         }
10547
10548       res0 = (htab->glink_pltresolve
10549               + htab->glink->output_section->vma
10550               + htab->glink->output_offset);
10551
10552       if (htab->params->ppc476_workaround)
10553         {
10554           /* Ensure that a call stub at the end of a page doesn't
10555              result in prefetch over the end of the page into the
10556              glink branch table.  */
10557           bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
10558           bfd_vma page_addr;
10559           bfd_vma glink_start = (htab->glink->output_section->vma
10560                                  + htab->glink->output_offset);
10561
10562           for (page_addr = res0 & -pagesize;
10563                page_addr > glink_start;
10564                page_addr -= pagesize)
10565             {
10566               /* We have a plt call stub that may need fixing.  */
10567               bfd_byte *loc;
10568               unsigned int insn;
10569
10570               loc = htab->glink->contents + page_addr - 4 - glink_start;
10571               insn = bfd_get_32 (output_bfd, loc);
10572               if (insn == BCTR)
10573                 {
10574                   /* By alignment, we know that there must be at least
10575                      one other call stub before this one.  */
10576                   insn = bfd_get_32 (output_bfd, loc - 16);
10577                   if (insn == BCTR)
10578                     bfd_put_32 (output_bfd, B | (-16 & 0x3fffffc), loc);
10579                   else
10580                     bfd_put_32 (output_bfd, B | (-20 & 0x3fffffc), loc);
10581                 }
10582             }
10583         }
10584
10585       /* Last comes the PLTresolve stub.  */
10586       if (bfd_link_pic (info))
10587         {
10588           bfd_vma bcl;
10589
10590           for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++)
10591             {
10592               unsigned int insn = pic_plt_resolve[i];
10593
10594               if (htab->params->ppc476_workaround && insn == NOP)
10595                 insn = BA + 0;
10596               bfd_put_32 (output_bfd, insn, p);
10597               p += 4;
10598             }
10599           p -= 4 * ARRAY_SIZE (pic_plt_resolve);
10600
10601           bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4
10602                  + htab->glink->output_section->vma
10603                  + htab->glink->output_offset);
10604
10605           bfd_put_32 (output_bfd,
10606                       ADDIS_11_11 + PPC_HA (bcl - res0), p + 0*4);
10607           bfd_put_32 (output_bfd,
10608                       ADDI_11_11 + PPC_LO (bcl - res0), p + 3*4);
10609           bfd_put_32 (output_bfd,
10610                       ADDIS_12_12 + PPC_HA (got + 4 - bcl), p + 7*4);
10611           if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl))
10612             {
10613               bfd_put_32 (output_bfd,
10614                           LWZ_0_12 + PPC_LO (got + 4 - bcl), p + 8*4);
10615               bfd_put_32 (output_bfd,
10616                           LWZ_12_12 + PPC_LO (got + 8 - bcl), p + 9*4);
10617             }
10618           else
10619             {
10620               bfd_put_32 (output_bfd,
10621                           LWZU_0_12 + PPC_LO (got + 4 - bcl), p + 8*4);
10622               bfd_put_32 (output_bfd,
10623                           LWZ_12_12 + 4, p + 9*4);
10624             }
10625         }
10626       else
10627         {
10628           for (i = 0; i < ARRAY_SIZE (plt_resolve); i++)
10629             {
10630               unsigned int insn = plt_resolve[i];
10631
10632               if (htab->params->ppc476_workaround && insn == NOP)
10633                 insn = BA + 0;
10634               bfd_put_32 (output_bfd, insn, p);
10635               p += 4;
10636             }
10637           p -= 4 * ARRAY_SIZE (plt_resolve);
10638
10639           bfd_put_32 (output_bfd,
10640                       LIS_12 + PPC_HA (got + 4), p + 0*4);
10641           bfd_put_32 (output_bfd,
10642                       ADDIS_11_11 + PPC_HA (-res0), p + 1*4);
10643           bfd_put_32 (output_bfd,
10644                       ADDI_11_11 + PPC_LO (-res0), p + 3*4);
10645           if (PPC_HA (got + 4) == PPC_HA (got + 8))
10646             {
10647               bfd_put_32 (output_bfd,
10648                           LWZ_0_12 + PPC_LO (got + 4), p + 2*4);
10649               bfd_put_32 (output_bfd,
10650                           LWZ_12_12 + PPC_LO (got + 8), p + 6*4);
10651             }
10652           else
10653             {
10654               bfd_put_32 (output_bfd,
10655                           LWZU_0_12 + PPC_LO (got + 4), p + 2*4);
10656               bfd_put_32 (output_bfd,
10657                           LWZ_12_12 + 4, p + 6*4);
10658             }
10659         }
10660     }
10661
10662   if (htab->glink_eh_frame != NULL
10663       && htab->glink_eh_frame->contents != NULL)
10664     {
10665       unsigned char *p = htab->glink_eh_frame->contents;
10666       bfd_vma val;
10667
10668       p += sizeof (glink_eh_frame_cie);
10669       /* FDE length.  */
10670       p += 4;
10671       /* CIE pointer.  */
10672       p += 4;
10673       /* Offset to .glink.  */
10674       val = (htab->glink->output_section->vma
10675              + htab->glink->output_offset);
10676       val -= (htab->glink_eh_frame->output_section->vma
10677               + htab->glink_eh_frame->output_offset);
10678       val -= p - htab->glink_eh_frame->contents;
10679       bfd_put_32 (htab->elf.dynobj, val, p);
10680
10681       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
10682           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
10683                                                htab->glink_eh_frame,
10684                                                htab->glink_eh_frame->contents))
10685         return FALSE;
10686     }
10687
10688   return ret;
10689 }
10690 \f
10691 #define TARGET_LITTLE_SYM       powerpc_elf32_le_vec
10692 #define TARGET_LITTLE_NAME      "elf32-powerpcle"
10693 #define TARGET_BIG_SYM          powerpc_elf32_vec
10694 #define TARGET_BIG_NAME         "elf32-powerpc"
10695 #define ELF_ARCH                bfd_arch_powerpc
10696 #define ELF_TARGET_ID           PPC32_ELF_DATA
10697 #define ELF_MACHINE_CODE        EM_PPC
10698 #ifdef __QNXTARGET__
10699 #define ELF_MAXPAGESIZE         0x1000
10700 #define ELF_COMMONPAGESIZE      0x1000
10701 #else
10702 #define ELF_MAXPAGESIZE         0x10000
10703 #define ELF_COMMONPAGESIZE      0x10000
10704 #endif
10705 #define ELF_MINPAGESIZE         0x1000
10706 #define elf_info_to_howto       ppc_elf_info_to_howto
10707
10708 #ifdef  EM_CYGNUS_POWERPC
10709 #define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
10710 #endif
10711
10712 #ifdef EM_PPC_OLD
10713 #define ELF_MACHINE_ALT2        EM_PPC_OLD
10714 #endif
10715
10716 #define elf_backend_plt_not_loaded      1
10717 #define elf_backend_can_gc_sections     1
10718 #define elf_backend_can_refcount        1
10719 #define elf_backend_rela_normal         1
10720 #define elf_backend_caches_rawsize      1
10721
10722 #define bfd_elf32_mkobject                      ppc_elf_mkobject
10723 #define bfd_elf32_bfd_merge_private_bfd_data    ppc_elf_merge_private_bfd_data
10724 #define bfd_elf32_bfd_relax_section             ppc_elf_relax_section
10725 #define bfd_elf32_bfd_reloc_type_lookup         ppc_elf_reloc_type_lookup
10726 #define bfd_elf32_bfd_reloc_name_lookup         ppc_elf_reloc_name_lookup
10727 #define bfd_elf32_bfd_set_private_flags         ppc_elf_set_private_flags
10728 #define bfd_elf32_bfd_link_hash_table_create    ppc_elf_link_hash_table_create
10729 #define bfd_elf32_get_synthetic_symtab          ppc_elf_get_synthetic_symtab
10730
10731 #define elf_backend_object_p                    ppc_elf_object_p
10732 #define elf_backend_gc_mark_hook                ppc_elf_gc_mark_hook
10733 #define elf_backend_gc_sweep_hook               ppc_elf_gc_sweep_hook
10734 #define elf_backend_section_from_shdr           ppc_elf_section_from_shdr
10735 #define elf_backend_relocate_section            ppc_elf_relocate_section
10736 #define elf_backend_create_dynamic_sections     ppc_elf_create_dynamic_sections
10737 #define elf_backend_check_relocs                ppc_elf_check_relocs
10738 #define elf_backend_copy_indirect_symbol        ppc_elf_copy_indirect_symbol
10739 #define elf_backend_adjust_dynamic_symbol       ppc_elf_adjust_dynamic_symbol
10740 #define elf_backend_add_symbol_hook             ppc_elf_add_symbol_hook
10741 #define elf_backend_size_dynamic_sections       ppc_elf_size_dynamic_sections
10742 #define elf_backend_hash_symbol                 ppc_elf_hash_symbol
10743 #define elf_backend_finish_dynamic_symbol       ppc_elf_finish_dynamic_symbol
10744 #define elf_backend_finish_dynamic_sections     ppc_elf_finish_dynamic_sections
10745 #define elf_backend_fake_sections               ppc_elf_fake_sections
10746 #define elf_backend_additional_program_headers  ppc_elf_additional_program_headers
10747 #define elf_backend_modify_segment_map          ppc_elf_modify_segment_map
10748 #define elf_backend_grok_prstatus               ppc_elf_grok_prstatus
10749 #define elf_backend_grok_psinfo                 ppc_elf_grok_psinfo
10750 #define elf_backend_write_core_note             ppc_elf_write_core_note
10751 #define elf_backend_reloc_type_class            ppc_elf_reloc_type_class
10752 #define elf_backend_begin_write_processing      ppc_elf_begin_write_processing
10753 #define elf_backend_final_write_processing      ppc_elf_final_write_processing
10754 #define elf_backend_write_section               ppc_elf_write_section
10755 #define elf_backend_get_sec_type_attr           ppc_elf_get_sec_type_attr
10756 #define elf_backend_plt_sym_val                 ppc_elf_plt_sym_val
10757 #define elf_backend_action_discarded            ppc_elf_action_discarded
10758 #define elf_backend_init_index_section          _bfd_elf_init_1_index_section
10759 #define elf_backend_lookup_section_flags_hook   ppc_elf_lookup_section_flags
10760 #define elf_backend_section_processing          ppc_elf_section_processing
10761
10762 #include "elf32-target.h"
10763
10764 /* FreeBSD Target */
10765
10766 #undef  TARGET_LITTLE_SYM
10767 #undef  TARGET_LITTLE_NAME
10768
10769 #undef  TARGET_BIG_SYM
10770 #define TARGET_BIG_SYM  powerpc_elf32_fbsd_vec
10771 #undef  TARGET_BIG_NAME
10772 #define TARGET_BIG_NAME "elf32-powerpc-freebsd"
10773
10774 #undef  ELF_OSABI
10775 #define ELF_OSABI       ELFOSABI_FREEBSD
10776
10777 #undef  elf32_bed
10778 #define elf32_bed       elf32_powerpc_fbsd_bed
10779
10780 #include "elf32-target.h"
10781
10782 /* VxWorks Target */
10783
10784 #undef TARGET_LITTLE_SYM
10785 #undef TARGET_LITTLE_NAME
10786
10787 #undef TARGET_BIG_SYM
10788 #define TARGET_BIG_SYM          powerpc_elf32_vxworks_vec
10789 #undef TARGET_BIG_NAME
10790 #define TARGET_BIG_NAME         "elf32-powerpc-vxworks"
10791
10792 #undef  ELF_OSABI
10793
10794 /* VxWorks uses the elf default section flags for .plt.  */
10795 static const struct bfd_elf_special_section *
10796 ppc_elf_vxworks_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
10797 {
10798   if (sec->name == NULL)
10799     return NULL;
10800
10801   if (strcmp (sec->name, ".plt") == 0)
10802     return _bfd_elf_get_sec_type_attr (abfd, sec);
10803
10804   return ppc_elf_get_sec_type_attr (abfd, sec);
10805 }
10806
10807 /* Like ppc_elf_link_hash_table_create, but overrides
10808    appropriately for VxWorks.  */
10809 static struct bfd_link_hash_table *
10810 ppc_elf_vxworks_link_hash_table_create (bfd *abfd)
10811 {
10812   struct bfd_link_hash_table *ret;
10813
10814   ret = ppc_elf_link_hash_table_create (abfd);
10815   if (ret)
10816     {
10817       struct ppc_elf_link_hash_table *htab
10818         = (struct ppc_elf_link_hash_table *)ret;
10819       htab->is_vxworks = 1;
10820       htab->plt_type = PLT_VXWORKS;
10821       htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE;
10822       htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE;
10823       htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE;
10824     }
10825   return ret;
10826 }
10827
10828 /* Tweak magic VxWorks symbols as they are loaded.  */
10829 static bfd_boolean
10830 ppc_elf_vxworks_add_symbol_hook (bfd *abfd,
10831                                  struct bfd_link_info *info,
10832                                  Elf_Internal_Sym *sym,
10833                                  const char **namep ATTRIBUTE_UNUSED,
10834                                  flagword *flagsp ATTRIBUTE_UNUSED,
10835                                  asection **secp,
10836                                  bfd_vma *valp)
10837 {
10838   if (!elf_vxworks_add_symbol_hook(abfd, info, sym,namep, flagsp, secp,
10839                                    valp))
10840     return FALSE;
10841
10842   return ppc_elf_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, valp);
10843 }
10844
10845 static void
10846 ppc_elf_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
10847 {
10848   ppc_elf_final_write_processing(abfd, linker);
10849   elf_vxworks_final_write_processing(abfd, linker);
10850 }
10851
10852 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
10853    define it.  */
10854 #undef elf_backend_want_plt_sym
10855 #define elf_backend_want_plt_sym                1
10856 #undef elf_backend_want_got_plt
10857 #define elf_backend_want_got_plt                1
10858 #undef elf_backend_got_symbol_offset
10859 #define elf_backend_got_symbol_offset           0
10860 #undef elf_backend_plt_not_loaded
10861 #define elf_backend_plt_not_loaded              0
10862 #undef elf_backend_plt_readonly
10863 #define elf_backend_plt_readonly                1
10864 #undef elf_backend_got_header_size
10865 #define elf_backend_got_header_size             12
10866
10867 #undef bfd_elf32_get_synthetic_symtab
10868
10869 #undef bfd_elf32_bfd_link_hash_table_create
10870 #define bfd_elf32_bfd_link_hash_table_create \
10871   ppc_elf_vxworks_link_hash_table_create
10872 #undef elf_backend_add_symbol_hook
10873 #define elf_backend_add_symbol_hook \
10874   ppc_elf_vxworks_add_symbol_hook
10875 #undef elf_backend_link_output_symbol_hook
10876 #define elf_backend_link_output_symbol_hook \
10877   elf_vxworks_link_output_symbol_hook
10878 #undef elf_backend_final_write_processing
10879 #define elf_backend_final_write_processing \
10880   ppc_elf_vxworks_final_write_processing
10881 #undef elf_backend_get_sec_type_attr
10882 #define elf_backend_get_sec_type_attr \
10883   ppc_elf_vxworks_get_sec_type_attr
10884 #undef elf_backend_emit_relocs
10885 #define elf_backend_emit_relocs \
10886   elf_vxworks_emit_relocs
10887
10888 #undef elf32_bed
10889 #define elf32_bed                               ppc_elf_vxworks_bed
10890 #undef elf_backend_post_process_headers
10891
10892 #include "elf32-target.h"