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