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        || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
3679       && (abfd->flags & DYNAMIC) == 0
3680       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
3681     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
3682
3683   return TRUE;
3684 }
3685 \f
3686 /* Find a linker generated pointer with a given addend and type.  */
3687
3688 static elf_linker_section_pointers_t *
3689 elf_find_pointer_linker_section
3690   (elf_linker_section_pointers_t *linker_pointers,
3691    bfd_vma addend,
3692    elf_linker_section_t *lsect)
3693 {
3694   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
3695     if (lsect == linker_pointers->lsect && addend == linker_pointers->addend)
3696       return linker_pointers;
3697
3698   return NULL;
3699 }
3700
3701 /* Allocate a pointer to live in a linker created section.  */
3702
3703 static bfd_boolean
3704 elf_allocate_pointer_linker_section (bfd *abfd,
3705                                      elf_linker_section_t *lsect,
3706                                      struct elf_link_hash_entry *h,
3707                                      const Elf_Internal_Rela *rel)
3708 {
3709   elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
3710   elf_linker_section_pointers_t *linker_section_ptr;
3711   unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
3712   bfd_size_type amt;
3713
3714   BFD_ASSERT (lsect != NULL);
3715
3716   /* Is this a global symbol?  */
3717   if (h != NULL)
3718     {
3719       struct ppc_elf_link_hash_entry *eh;
3720
3721       /* Has this symbol already been allocated?  If so, our work is done.  */
3722       eh = (struct ppc_elf_link_hash_entry *) h;
3723       if (elf_find_pointer_linker_section (eh->linker_section_pointer,
3724                                            rel->r_addend,
3725                                            lsect))
3726         return TRUE;
3727
3728       ptr_linker_section_ptr = &eh->linker_section_pointer;
3729     }
3730   else
3731     {
3732       BFD_ASSERT (is_ppc_elf (abfd));
3733
3734       /* Allocation of a pointer to a local symbol.  */
3735       elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
3736
3737       /* Allocate a table to hold the local symbols if first time.  */
3738       if (!ptr)
3739         {
3740           unsigned int num_symbols = elf_symtab_hdr (abfd).sh_info;
3741
3742           amt = num_symbols;
3743           amt *= sizeof (elf_linker_section_pointers_t *);
3744           ptr = bfd_zalloc (abfd, amt);
3745
3746           if (!ptr)
3747             return FALSE;
3748
3749           elf_local_ptr_offsets (abfd) = ptr;
3750         }
3751
3752       /* Has this symbol already been allocated?  If so, our work is done.  */
3753       if (elf_find_pointer_linker_section (ptr[r_symndx],
3754                                            rel->r_addend,
3755                                            lsect))
3756         return TRUE;
3757
3758       ptr_linker_section_ptr = &ptr[r_symndx];
3759     }
3760
3761   /* Allocate space for a pointer in the linker section, and allocate
3762      a new pointer record from internal memory.  */
3763   BFD_ASSERT (ptr_linker_section_ptr != NULL);
3764   amt = sizeof (elf_linker_section_pointers_t);
3765   linker_section_ptr = bfd_alloc (abfd, amt);
3766
3767   if (!linker_section_ptr)
3768     return FALSE;
3769
3770   linker_section_ptr->next = *ptr_linker_section_ptr;
3771   linker_section_ptr->addend = rel->r_addend;
3772   linker_section_ptr->lsect = lsect;
3773   *ptr_linker_section_ptr = linker_section_ptr;
3774
3775   if (!bfd_set_section_alignment (lsect->section->owner, lsect->section, 2))
3776     return FALSE;
3777   linker_section_ptr->offset = lsect->section->size;
3778   lsect->section->size += 4;
3779
3780 #ifdef DEBUG
3781   fprintf (stderr,
3782            "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3783            lsect->name, (long) linker_section_ptr->offset,
3784            (long) lsect->section->size);
3785 #endif
3786
3787   return TRUE;
3788 }
3789
3790 static struct plt_entry **
3791 update_local_sym_info (bfd *abfd,
3792                        Elf_Internal_Shdr *symtab_hdr,
3793                        unsigned long r_symndx,
3794                        int tls_type)
3795 {
3796   bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
3797   struct plt_entry **local_plt;
3798   char *local_got_tls_masks;
3799
3800   if (local_got_refcounts == NULL)
3801     {
3802       bfd_size_type size = symtab_hdr->sh_info;
3803
3804       size *= (sizeof (*local_got_refcounts)
3805                + sizeof (*local_plt)
3806                + sizeof (*local_got_tls_masks));
3807       local_got_refcounts = bfd_zalloc (abfd, size);
3808       if (local_got_refcounts == NULL)
3809         return NULL;
3810       elf_local_got_refcounts (abfd) = local_got_refcounts;
3811     }
3812
3813   local_plt = (struct plt_entry **) (local_got_refcounts + symtab_hdr->sh_info);
3814   local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
3815   local_got_tls_masks[r_symndx] |= tls_type;
3816   if (tls_type != PLT_IFUNC)
3817     local_got_refcounts[r_symndx] += 1;
3818   return local_plt + r_symndx;
3819 }
3820
3821 static bfd_boolean
3822 update_plt_info (bfd *abfd, struct plt_entry **plist,
3823                  asection *sec, bfd_vma addend)
3824 {
3825   struct plt_entry *ent;
3826
3827   if (addend < 32768)
3828     sec = NULL;
3829   for (ent = *plist; ent != NULL; ent = ent->next)
3830     if (ent->sec == sec && ent->addend == addend)
3831       break;
3832   if (ent == NULL)
3833     {
3834       bfd_size_type amt = sizeof (*ent);
3835       ent = bfd_alloc (abfd, amt);
3836       if (ent == NULL)
3837         return FALSE;
3838       ent->next = *plist;
3839       ent->sec = sec;
3840       ent->addend = addend;
3841       ent->plt.refcount = 0;
3842       *plist = ent;
3843     }
3844   ent->plt.refcount += 1;
3845   return TRUE;
3846 }
3847
3848 static struct plt_entry *
3849 find_plt_ent (struct plt_entry **plist, asection *sec, bfd_vma addend)
3850 {
3851   struct plt_entry *ent;
3852
3853   if (addend < 32768)
3854     sec = NULL;
3855   for (ent = *plist; ent != NULL; ent = ent->next)
3856     if (ent->sec == sec && ent->addend == addend)
3857       break;
3858   return ent;
3859 }
3860
3861 static bfd_boolean
3862 is_branch_reloc (enum elf_ppc_reloc_type r_type)
3863 {
3864   return (r_type == R_PPC_PLTREL24
3865           || r_type == R_PPC_LOCAL24PC
3866           || r_type == R_PPC_REL24
3867           || r_type == R_PPC_REL14
3868           || r_type == R_PPC_REL14_BRTAKEN
3869           || r_type == R_PPC_REL14_BRNTAKEN
3870           || r_type == R_PPC_ADDR24
3871           || r_type == R_PPC_ADDR14
3872           || r_type == R_PPC_ADDR14_BRTAKEN
3873           || r_type == R_PPC_ADDR14_BRNTAKEN);
3874 }
3875
3876 static void
3877 bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
3878 {
3879   (*_bfd_error_handler)
3880     (_("%B: relocation %s cannot be used when making a shared object"),
3881      abfd,
3882      ppc_elf_howto_table[r_type]->name);
3883   bfd_set_error (bfd_error_bad_value);
3884 }
3885
3886 /* Look through the relocs for a section during the first phase, and
3887    allocate space in the global offset table or procedure linkage
3888    table.  */
3889
3890 static bfd_boolean
3891 ppc_elf_check_relocs (bfd *abfd,
3892                       struct bfd_link_info *info,
3893                       asection *sec,
3894                       const Elf_Internal_Rela *relocs)
3895 {
3896   struct ppc_elf_link_hash_table *htab;
3897   Elf_Internal_Shdr *symtab_hdr;
3898   struct elf_link_hash_entry **sym_hashes;
3899   const Elf_Internal_Rela *rel;
3900   const Elf_Internal_Rela *rel_end;
3901   asection *got2, *sreloc;
3902   struct elf_link_hash_entry *tga;
3903
3904   if (bfd_link_relocatable (info))
3905     return TRUE;
3906
3907   /* Don't do anything special with non-loaded, non-alloced sections.
3908      In particular, any relocs in such sections should not affect GOT
3909      and PLT reference counting (ie. we don't allow them to create GOT
3910      or PLT entries), there's no possibility or desire to optimize TLS
3911      relocs, and there's not much point in propagating relocs to shared
3912      libs that the dynamic linker won't relocate.  */
3913   if ((sec->flags & SEC_ALLOC) == 0)
3914     return TRUE;
3915
3916 #ifdef DEBUG
3917   _bfd_error_handler ("ppc_elf_check_relocs called for section %A in %B",
3918                       sec, abfd);
3919 #endif
3920
3921   BFD_ASSERT (is_ppc_elf (abfd));
3922
3923   /* Initialize howto table if not already done.  */
3924   if (!ppc_elf_howto_table[R_PPC_ADDR32])
3925     ppc_elf_howto_init ();
3926
3927   htab = ppc_elf_hash_table (info);
3928   if (htab->glink == NULL)
3929     {
3930       if (htab->elf.dynobj == NULL)
3931         htab->elf.dynobj = abfd;
3932       if (!ppc_elf_create_glink (htab->elf.dynobj, info))
3933         return FALSE;
3934     }
3935   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
3936                               FALSE, FALSE, TRUE);
3937   symtab_hdr = &elf_symtab_hdr (abfd);
3938   sym_hashes = elf_sym_hashes (abfd);
3939   got2 = bfd_get_section_by_name (abfd, ".got2");
3940   sreloc = NULL;
3941
3942   rel_end = relocs + sec->reloc_count;
3943   for (rel = relocs; rel < rel_end; rel++)
3944     {
3945       unsigned long r_symndx;
3946       enum elf_ppc_reloc_type r_type;
3947       struct elf_link_hash_entry *h;
3948       int tls_type;
3949       struct plt_entry **ifunc;
3950
3951       r_symndx = ELF32_R_SYM (rel->r_info);
3952       if (r_symndx < symtab_hdr->sh_info)
3953         h = NULL;
3954       else
3955         {
3956           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3957           while (h->root.type == bfd_link_hash_indirect
3958                  || h->root.type == bfd_link_hash_warning)
3959             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3960
3961           /* PR15323, ref flags aren't set for references in the same
3962              object.  */
3963           h->root.non_ir_ref = 1;
3964         }
3965
3966       /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
3967          This shows up in particular in an R_PPC_ADDR32 in the eabi
3968          startup code.  */
3969       if (h != NULL
3970           && htab->got == NULL
3971           && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3972         {
3973           if (htab->elf.dynobj == NULL)
3974             htab->elf.dynobj = abfd;
3975           if (!ppc_elf_create_got (htab->elf.dynobj, info))
3976             return FALSE;
3977           BFD_ASSERT (h == htab->elf.hgot);
3978         }
3979
3980       tls_type = 0;
3981       r_type = ELF32_R_TYPE (rel->r_info);
3982       ifunc = NULL;
3983       if (h == NULL && !htab->is_vxworks)
3984         {
3985           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3986                                                           abfd, r_symndx);
3987           if (isym == NULL)
3988             return FALSE;
3989
3990           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3991             {
3992               /* Set PLT_IFUNC flag for this sym, no GOT entry yet.  */
3993               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
3994                                              PLT_IFUNC);
3995               if (ifunc == NULL)
3996                 return FALSE;
3997
3998               /* STT_GNU_IFUNC symbols must have a PLT entry;
3999                  In a non-pie executable even when there are
4000                  no plt calls.  */
4001               if (!bfd_link_pic (info)
4002                   || is_branch_reloc (r_type))
4003                 {
4004                   bfd_vma addend = 0;
4005                   if (r_type == R_PPC_PLTREL24)
4006                     {
4007                       ppc_elf_tdata (abfd)->makes_plt_call = 1;
4008                       if (bfd_link_pic (info))
4009                         addend = rel->r_addend;
4010                     }
4011                   if (!update_plt_info (abfd, ifunc, got2, addend))
4012                     return FALSE;
4013                 }
4014             }
4015         }
4016
4017       if (!htab->is_vxworks
4018           && is_branch_reloc (r_type)
4019           && h != NULL
4020           && h == tga)
4021         {
4022           if (rel != relocs
4023               && (ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSGD
4024                   || ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSLD))
4025             /* We have a new-style __tls_get_addr call with a marker
4026                reloc.  */
4027             ;
4028           else
4029             /* Mark this section as having an old-style call.  */
4030             sec->has_tls_get_addr_call = 1;
4031         }
4032
4033       switch (r_type)
4034         {
4035         case R_PPC_TLSGD:
4036         case R_PPC_TLSLD:
4037           /* These special tls relocs tie a call to __tls_get_addr with
4038              its parameter symbol.  */
4039           break;
4040
4041         case R_PPC_GOT_TLSLD16:
4042         case R_PPC_GOT_TLSLD16_LO:
4043         case R_PPC_GOT_TLSLD16_HI:
4044         case R_PPC_GOT_TLSLD16_HA:
4045           tls_type = TLS_TLS | TLS_LD;
4046           goto dogottls;
4047
4048         case R_PPC_GOT_TLSGD16:
4049         case R_PPC_GOT_TLSGD16_LO:
4050         case R_PPC_GOT_TLSGD16_HI:
4051         case R_PPC_GOT_TLSGD16_HA:
4052           tls_type = TLS_TLS | TLS_GD;
4053           goto dogottls;
4054
4055         case R_PPC_GOT_TPREL16:
4056         case R_PPC_GOT_TPREL16_LO:
4057         case R_PPC_GOT_TPREL16_HI:
4058         case R_PPC_GOT_TPREL16_HA:
4059           if (bfd_link_pic (info))
4060             info->flags |= DF_STATIC_TLS;
4061           tls_type = TLS_TLS | TLS_TPREL;
4062           goto dogottls;
4063
4064         case R_PPC_GOT_DTPREL16:
4065         case R_PPC_GOT_DTPREL16_LO:
4066         case R_PPC_GOT_DTPREL16_HI:
4067         case R_PPC_GOT_DTPREL16_HA:
4068           tls_type = TLS_TLS | TLS_DTPREL;
4069         dogottls:
4070           sec->has_tls_reloc = 1;
4071           /* Fall thru */
4072
4073           /* GOT16 relocations */
4074         case R_PPC_GOT16:
4075         case R_PPC_GOT16_LO:
4076         case R_PPC_GOT16_HI:
4077         case R_PPC_GOT16_HA:
4078           /* This symbol requires a global offset table entry.  */
4079           if (htab->got == NULL)
4080             {
4081               if (htab->elf.dynobj == NULL)
4082                 htab->elf.dynobj = abfd;
4083               if (!ppc_elf_create_got (htab->elf.dynobj, info))
4084                 return FALSE;
4085             }
4086           if (h != NULL)
4087             {
4088               h->got.refcount += 1;
4089               ppc_elf_hash_entry (h)->tls_mask |= tls_type;
4090             }
4091           else
4092             /* This is a global offset table entry for a local symbol.  */
4093             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
4094               return FALSE;
4095
4096           /* We may also need a plt entry if the symbol turns out to be
4097              an ifunc.  */
4098           if (h != NULL && !bfd_link_pic (info))
4099             {
4100               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4101                 return FALSE;
4102             }
4103           break;
4104
4105           /* Indirect .sdata relocation.  */
4106         case R_PPC_EMB_SDAI16:
4107           if (bfd_link_pic (info))
4108             {
4109               bad_shared_reloc (abfd, r_type);
4110               return FALSE;
4111             }
4112           htab->sdata[0].sym->ref_regular = 1;
4113           if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[0],
4114                                                     h, rel))
4115             return FALSE;
4116           if (h != NULL)
4117             {
4118               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4119               h->non_got_ref = TRUE;
4120             }
4121           break;
4122
4123           /* Indirect .sdata2 relocation.  */
4124         case R_PPC_EMB_SDA2I16:
4125           if (bfd_link_pic (info))
4126             {
4127               bad_shared_reloc (abfd, r_type);
4128               return FALSE;
4129             }
4130           htab->sdata[1].sym->ref_regular = 1;
4131           if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[1],
4132                                                     h, rel))
4133             return FALSE;
4134           if (h != NULL)
4135             {
4136               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4137               h->non_got_ref = TRUE;
4138             }
4139           break;
4140
4141         case R_PPC_SDAREL16:
4142           htab->sdata[0].sym->ref_regular = 1;
4143           /* Fall thru */
4144
4145         case R_PPC_VLE_SDAREL_LO16A:
4146         case R_PPC_VLE_SDAREL_LO16D:
4147         case R_PPC_VLE_SDAREL_HI16A:
4148         case R_PPC_VLE_SDAREL_HI16D:
4149         case R_PPC_VLE_SDAREL_HA16A:
4150         case R_PPC_VLE_SDAREL_HA16D:
4151           if (h != NULL)
4152             {
4153               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4154               h->non_got_ref = TRUE;
4155             }
4156           break;
4157
4158         case R_PPC_VLE_REL8:
4159         case R_PPC_VLE_REL15:
4160         case R_PPC_VLE_REL24:
4161         case R_PPC_VLE_LO16A:
4162         case R_PPC_VLE_LO16D:
4163         case R_PPC_VLE_HI16A:
4164         case R_PPC_VLE_HI16D:
4165         case R_PPC_VLE_HA16A:
4166         case R_PPC_VLE_HA16D:
4167           break;
4168
4169         case R_PPC_EMB_SDA2REL:
4170           if (bfd_link_pic (info))
4171             {
4172               bad_shared_reloc (abfd, r_type);
4173               return FALSE;
4174             }
4175           htab->sdata[1].sym->ref_regular = 1;
4176           if (h != NULL)
4177             {
4178               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4179               h->non_got_ref = TRUE;
4180             }
4181           break;
4182
4183         case R_PPC_VLE_SDA21_LO:
4184         case R_PPC_VLE_SDA21:
4185         case R_PPC_EMB_SDA21:
4186         case R_PPC_EMB_RELSDA:
4187           if (bfd_link_pic (info))
4188             {
4189               bad_shared_reloc (abfd, r_type);
4190               return FALSE;
4191             }
4192           if (h != NULL)
4193             {
4194               ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
4195               h->non_got_ref = TRUE;
4196             }
4197           break;
4198
4199         case R_PPC_EMB_NADDR32:
4200         case R_PPC_EMB_NADDR16:
4201         case R_PPC_EMB_NADDR16_LO:
4202         case R_PPC_EMB_NADDR16_HI:
4203         case R_PPC_EMB_NADDR16_HA:
4204           if (bfd_link_pic (info))
4205             {
4206               bad_shared_reloc (abfd, r_type);
4207               return FALSE;
4208             }
4209           if (h != NULL)
4210             h->non_got_ref = TRUE;
4211           break;
4212
4213         case R_PPC_PLTREL24:
4214           if (h == NULL)
4215             break;
4216           /* Fall through */
4217         case R_PPC_PLT32:
4218         case R_PPC_PLTREL32:
4219         case R_PPC_PLT16_LO:
4220         case R_PPC_PLT16_HI:
4221         case R_PPC_PLT16_HA:
4222 #ifdef DEBUG
4223           fprintf (stderr, "Reloc requires a PLT entry\n");
4224 #endif
4225           /* This symbol requires a procedure linkage table entry.  */
4226           if (h == NULL)
4227             {
4228               if (ifunc == NULL)
4229                 {
4230                   /* It does not make sense to have a procedure linkage
4231                      table entry for a non-ifunc local symbol.  */
4232                   info->callbacks->einfo
4233                     (_("%P: %H: %s reloc against local symbol\n"),
4234                      abfd, sec, rel->r_offset,
4235                      ppc_elf_howto_table[r_type]->name);
4236                   bfd_set_error (bfd_error_bad_value);
4237                   return FALSE;
4238                 }
4239             }
4240           else
4241             {
4242               bfd_vma addend = 0;
4243
4244               if (r_type == R_PPC_PLTREL24)
4245                 {
4246                   ppc_elf_tdata (abfd)->makes_plt_call = 1;
4247                   if (bfd_link_pic (info))
4248                     addend = rel->r_addend;
4249                 }
4250               h->needs_plt = 1;
4251               if (!update_plt_info (abfd, &h->plt.plist, got2, addend))
4252                 return FALSE;
4253             }
4254           break;
4255
4256           /* The following relocations don't need to propagate the
4257              relocation if linking a shared object since they are
4258              section relative.  */
4259         case R_PPC_SECTOFF:
4260         case R_PPC_SECTOFF_LO:
4261         case R_PPC_SECTOFF_HI:
4262         case R_PPC_SECTOFF_HA:
4263         case R_PPC_DTPREL16:
4264         case R_PPC_DTPREL16_LO:
4265         case R_PPC_DTPREL16_HI:
4266         case R_PPC_DTPREL16_HA:
4267         case R_PPC_TOC16:
4268           break;
4269
4270         case R_PPC_REL16:
4271         case R_PPC_REL16_LO:
4272         case R_PPC_REL16_HI:
4273         case R_PPC_REL16_HA:
4274         case R_PPC_REL16DX_HA:
4275           ppc_elf_tdata (abfd)->has_rel16 = 1;
4276           break;
4277
4278           /* These are just markers.  */
4279         case R_PPC_TLS:
4280         case R_PPC_EMB_MRKREF:
4281         case R_PPC_NONE:
4282         case R_PPC_max:
4283         case R_PPC_RELAX:
4284         case R_PPC_RELAX_PLT:
4285         case R_PPC_RELAX_PLTREL24:
4286           break;
4287
4288           /* These should only appear in dynamic objects.  */
4289         case R_PPC_COPY:
4290         case R_PPC_GLOB_DAT:
4291         case R_PPC_JMP_SLOT:
4292         case R_PPC_RELATIVE:
4293         case R_PPC_IRELATIVE:
4294           break;
4295
4296           /* These aren't handled yet.  We'll report an error later.  */
4297         case R_PPC_ADDR30:
4298         case R_PPC_EMB_RELSEC16:
4299         case R_PPC_EMB_RELST_LO:
4300         case R_PPC_EMB_RELST_HI:
4301         case R_PPC_EMB_RELST_HA:
4302         case R_PPC_EMB_BIT_FLD:
4303           break;
4304
4305           /* This refers only to functions defined in the shared library.  */
4306         case R_PPC_LOCAL24PC:
4307           if (h != NULL && h == htab->elf.hgot && htab->plt_type == PLT_UNSET)
4308             {
4309               htab->plt_type = PLT_OLD;
4310               htab->old_bfd = abfd;
4311             }
4312           if (h != NULL && h->type == STT_GNU_IFUNC)
4313             {
4314               if (bfd_link_pic (info))
4315                 {
4316                   info->callbacks->einfo
4317                     (_("%P: %H: @local call to ifunc %s\n"),
4318                      abfd, sec, rel->r_offset,
4319                      h->root.root.string);
4320                   bfd_set_error (bfd_error_bad_value);
4321                   return FALSE;
4322                 }
4323               h->needs_plt = 1;
4324               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4325                 return FALSE;
4326             }
4327           break;
4328
4329           /* This relocation describes the C++ object vtable hierarchy.
4330              Reconstruct it for later use during GC.  */
4331         case R_PPC_GNU_VTINHERIT:
4332           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4333             return FALSE;
4334           break;
4335
4336           /* This relocation describes which C++ vtable entries are actually
4337              used.  Record for later use during GC.  */
4338         case R_PPC_GNU_VTENTRY:
4339           BFD_ASSERT (h != NULL);
4340           if (h != NULL
4341               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4342             return FALSE;
4343           break;
4344
4345           /* We shouldn't really be seeing these.  */
4346         case R_PPC_TPREL32:
4347         case R_PPC_TPREL16:
4348         case R_PPC_TPREL16_LO:
4349         case R_PPC_TPREL16_HI:
4350         case R_PPC_TPREL16_HA:
4351           if (bfd_link_pic (info))
4352             info->flags |= DF_STATIC_TLS;
4353           goto dodyn;
4354
4355           /* Nor these.  */
4356         case R_PPC_DTPMOD32:
4357         case R_PPC_DTPREL32:
4358           goto dodyn;
4359
4360         case R_PPC_REL32:
4361           if (h == NULL
4362               && got2 != NULL
4363               && (sec->flags & SEC_CODE) != 0
4364               && bfd_link_pic (info)
4365               && htab->plt_type == PLT_UNSET)
4366             {
4367               /* Old -fPIC gcc code has .long LCTOC1-LCFx just before
4368                  the start of a function, which assembles to a REL32
4369                  reference to .got2.  If we detect one of these, then
4370                  force the old PLT layout because the linker cannot
4371                  reliably deduce the GOT pointer value needed for
4372                  PLT call stubs.  */
4373               asection *s;
4374               Elf_Internal_Sym *isym;
4375
4376               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4377                                             abfd, r_symndx);
4378               if (isym == NULL)
4379                 return FALSE;
4380
4381               s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4382               if (s == got2)
4383                 {
4384                   htab->plt_type = PLT_OLD;
4385                   htab->old_bfd = abfd;
4386                 }
4387             }
4388           if (h == NULL || h == htab->elf.hgot)
4389             break;
4390           /* fall through */
4391
4392         case R_PPC_ADDR32:
4393         case R_PPC_ADDR16:
4394         case R_PPC_ADDR16_LO:
4395         case R_PPC_ADDR16_HI:
4396         case R_PPC_ADDR16_HA:
4397         case R_PPC_UADDR32:
4398         case R_PPC_UADDR16:
4399           if (h != NULL && !bfd_link_pic (info))
4400             {
4401               /* We may need a plt entry if the symbol turns out to be
4402                  a function defined in a dynamic object.  */
4403               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4404                 return FALSE;
4405
4406               /* We may need a copy reloc too.  */
4407               h->non_got_ref = 1;
4408               h->pointer_equality_needed = 1;
4409               if (r_type == R_PPC_ADDR16_HA)
4410                 ppc_elf_hash_entry (h)->has_addr16_ha = 1;
4411               if (r_type == R_PPC_ADDR16_LO)
4412                 ppc_elf_hash_entry (h)->has_addr16_lo = 1;
4413             }
4414           goto dodyn;
4415
4416         case R_PPC_REL24:
4417         case R_PPC_REL14:
4418         case R_PPC_REL14_BRTAKEN:
4419         case R_PPC_REL14_BRNTAKEN:
4420           if (h == NULL)
4421             break;
4422           if (h == htab->elf.hgot)
4423             {
4424               if (htab->plt_type == PLT_UNSET)
4425                 {
4426                   htab->plt_type = PLT_OLD;
4427                   htab->old_bfd = abfd;
4428                 }
4429               break;
4430             }
4431           /* fall through */
4432
4433         case R_PPC_ADDR24:
4434         case R_PPC_ADDR14:
4435         case R_PPC_ADDR14_BRTAKEN:
4436         case R_PPC_ADDR14_BRNTAKEN:
4437           if (h != NULL && !bfd_link_pic (info))
4438             {
4439               /* We may need a plt entry if the symbol turns out to be
4440                  a function defined in a dynamic object.  */
4441               h->needs_plt = 1;
4442               if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
4443                 return FALSE;
4444               break;
4445             }
4446
4447         dodyn:
4448           /* If we are creating a shared library, and this is a reloc
4449              against a global symbol, or a non PC relative reloc
4450              against a local symbol, then we need to copy the reloc
4451              into the shared library.  However, if we are linking with
4452              -Bsymbolic, we do not need to copy a reloc against a
4453              global symbol which is defined in an object we are
4454              including in the link (i.e., DEF_REGULAR is set).  At
4455              this point we have not seen all the input files, so it is
4456              possible that DEF_REGULAR is not set now but will be set
4457              later (it is never cleared).  In case of a weak definition,
4458              DEF_REGULAR may be cleared later by a strong definition in
4459              a shared library.  We account for that possibility below by
4460              storing information in the dyn_relocs field of the hash
4461              table entry.  A similar situation occurs when creating
4462              shared libraries and symbol visibility changes render the
4463              symbol local.
4464
4465              If on the other hand, we are creating an executable, we
4466              may need to keep relocations for symbols satisfied by a
4467              dynamic library if we manage to avoid copy relocs for the
4468              symbol.  */
4469           if ((bfd_link_pic (info)
4470                && (must_be_dyn_reloc (info, r_type)
4471                    || (h != NULL
4472                        && (!SYMBOLIC_BIND (info, h)
4473                            || h->root.type == bfd_link_hash_defweak
4474                            || !h->def_regular))))
4475               || (ELIMINATE_COPY_RELOCS
4476                   && !bfd_link_pic (info)
4477                   && h != NULL
4478                   && (h->root.type == bfd_link_hash_defweak
4479                       || !h->def_regular)))
4480             {
4481 #ifdef DEBUG
4482               fprintf (stderr,
4483                        "ppc_elf_check_relocs needs to "
4484                        "create relocation for %s\n",
4485                        (h && h->root.root.string
4486                         ? h->root.root.string : "<unknown>"));
4487 #endif
4488               if (sreloc == NULL)
4489                 {
4490                   if (htab->elf.dynobj == NULL)
4491                     htab->elf.dynobj = abfd;
4492
4493                   sreloc = _bfd_elf_make_dynamic_reloc_section
4494                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
4495
4496                   if (sreloc == NULL)
4497                     return FALSE;
4498                 }
4499
4500               /* If this is a global symbol, we count the number of
4501                  relocations we need for this symbol.  */
4502               if (h != NULL)
4503                 {
4504                   struct elf_dyn_relocs *p;
4505                   struct elf_dyn_relocs **rel_head;
4506
4507                   rel_head = &ppc_elf_hash_entry (h)->dyn_relocs;
4508                   p = *rel_head;
4509                   if (p == NULL || p->sec != sec)
4510                     {
4511                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4512                       if (p == NULL)
4513                         return FALSE;
4514                       p->next = *rel_head;
4515                       *rel_head = p;
4516                       p->sec = sec;
4517                       p->count = 0;
4518                       p->pc_count = 0;
4519                     }
4520                   p->count += 1;
4521                   if (!must_be_dyn_reloc (info, r_type))
4522                     p->pc_count += 1;
4523                 }
4524               else
4525                 {
4526                   /* Track dynamic relocs needed for local syms too.
4527                      We really need local syms available to do this
4528                      easily.  Oh well.  */
4529                   struct ppc_dyn_relocs *p;
4530                   struct ppc_dyn_relocs **rel_head;
4531                   bfd_boolean is_ifunc;
4532                   asection *s;
4533                   void *vpp;
4534                   Elf_Internal_Sym *isym;
4535
4536                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4537                                                 abfd, r_symndx);
4538                   if (isym == NULL)
4539                     return FALSE;
4540
4541                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4542                   if (s == NULL)
4543                     s = sec;
4544
4545                   vpp = &elf_section_data (s)->local_dynrel;
4546                   rel_head = (struct ppc_dyn_relocs **) vpp;
4547                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
4548                   p = *rel_head;
4549                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
4550                     p = p->next;
4551                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
4552                     {
4553                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4554                       if (p == NULL)
4555                         return FALSE;
4556                       p->next = *rel_head;
4557                       *rel_head = p;
4558                       p->sec = sec;
4559                       p->ifunc = is_ifunc;
4560                       p->count = 0;
4561                     }
4562                   p->count += 1;
4563                 }
4564             }
4565
4566           break;
4567         }
4568     }
4569
4570   return TRUE;
4571 }
4572 \f
4573
4574 /* Merge object attributes from IBFD into OBFD.  Raise an error if
4575    there are conflicting attributes.  */
4576 static bfd_boolean
4577 ppc_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
4578 {
4579   obj_attribute *in_attr, *in_attrs;
4580   obj_attribute *out_attr, *out_attrs;
4581
4582   if (!elf_known_obj_attributes_proc (obfd)[0].i)
4583     {
4584       /* This is the first object.  Copy the attributes.  */
4585       _bfd_elf_copy_obj_attributes (ibfd, obfd);
4586
4587       /* Use the Tag_null value to indicate the attributes have been
4588          initialized.  */
4589       elf_known_obj_attributes_proc (obfd)[0].i = 1;
4590
4591       return TRUE;
4592     }
4593
4594   in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4595   out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4596
4597   /* Check for conflicting Tag_GNU_Power_ABI_FP attributes and merge
4598      non-conflicting ones.  */
4599   in_attr = &in_attrs[Tag_GNU_Power_ABI_FP];
4600   out_attr = &out_attrs[Tag_GNU_Power_ABI_FP];
4601   if (in_attr->i != out_attr->i)
4602     {
4603       out_attr->type = 1;
4604       if (out_attr->i == 0)
4605         out_attr->i = in_attr->i;
4606       else if (in_attr->i == 0)
4607         ;
4608       else if (out_attr->i == 1 && in_attr->i == 2)
4609         _bfd_error_handler
4610           (_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd);
4611       else if (out_attr->i == 1 && in_attr->i == 3)
4612         _bfd_error_handler
4613           (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
4614           obfd, ibfd);
4615       else if (out_attr->i == 3 && in_attr->i == 1)
4616         _bfd_error_handler
4617           (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
4618           ibfd, obfd);
4619       else if (out_attr->i == 3 && in_attr->i == 2)
4620         _bfd_error_handler
4621           (_("Warning: %B uses soft float, %B uses single-precision hard float"),
4622           ibfd, obfd);
4623       else if (out_attr->i == 2 && (in_attr->i == 1 || in_attr->i == 3))
4624         _bfd_error_handler
4625           (_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd);
4626       else if (in_attr->i > 3)
4627         _bfd_error_handler
4628           (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
4629            in_attr->i);
4630       else
4631         _bfd_error_handler
4632           (_("Warning: %B uses unknown floating point ABI %d"), obfd,
4633            out_attr->i);
4634     }
4635
4636   /* Check for conflicting Tag_GNU_Power_ABI_Vector attributes and
4637      merge non-conflicting ones.  */
4638   in_attr = &in_attrs[Tag_GNU_Power_ABI_Vector];
4639   out_attr = &out_attrs[Tag_GNU_Power_ABI_Vector];
4640   if (in_attr->i != out_attr->i)
4641     {
4642       const char *in_abi = NULL, *out_abi = NULL;
4643
4644       switch (in_attr->i)
4645         {
4646         case 1: in_abi = "generic"; break;
4647         case 2: in_abi = "AltiVec"; break;
4648         case 3: in_abi = "SPE"; break;
4649         }
4650
4651       switch (out_attr->i)
4652         {
4653         case 1: out_abi = "generic"; break;
4654         case 2: out_abi = "AltiVec"; break;
4655         case 3: out_abi = "SPE"; break;
4656         }
4657
4658       out_attr->type = 1;
4659       if (out_attr->i == 0)
4660         out_attr->i = in_attr->i;
4661       else if (in_attr->i == 0)
4662         ;
4663       /* For now, allow generic to transition to AltiVec or SPE
4664          without a warning.  If GCC marked files with their stack
4665          alignment and used don't-care markings for files which are
4666          not affected by the vector ABI, we could warn about this
4667          case too.  */
4668       else if (out_attr->i == 1)
4669         out_attr->i = in_attr->i;
4670       else if (in_attr->i == 1)
4671         ;
4672       else if (in_abi == NULL)
4673         _bfd_error_handler
4674           (_("Warning: %B uses unknown vector ABI %d"), ibfd,
4675            in_attr->i);
4676       else if (out_abi == NULL)
4677         _bfd_error_handler
4678           (_("Warning: %B uses unknown vector ABI %d"), obfd,
4679            in_attr->i);
4680       else
4681         _bfd_error_handler
4682           (_("Warning: %B uses vector ABI \"%s\", %B uses \"%s\""),
4683            ibfd, obfd, in_abi, out_abi);
4684     }
4685
4686   /* Check for conflicting Tag_GNU_Power_ABI_Struct_Return attributes
4687      and merge non-conflicting ones.  */
4688   in_attr = &in_attrs[Tag_GNU_Power_ABI_Struct_Return];
4689   out_attr = &out_attrs[Tag_GNU_Power_ABI_Struct_Return];
4690   if (in_attr->i != out_attr->i)
4691     {
4692       out_attr->type = 1;
4693       if (out_attr->i == 0)
4694        out_attr->i = in_attr->i;
4695       else if (in_attr->i == 0)
4696        ;
4697       else if (out_attr->i == 1 && in_attr->i == 2)
4698        _bfd_error_handler
4699          (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), obfd, ibfd);
4700       else if (out_attr->i == 2 && in_attr->i == 1)
4701        _bfd_error_handler
4702          (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), ibfd, obfd);
4703       else if (in_attr->i > 2)
4704        _bfd_error_handler
4705          (_("Warning: %B uses unknown small structure return convention %d"), ibfd,
4706           in_attr->i);
4707       else
4708        _bfd_error_handler
4709          (_("Warning: %B uses unknown small structure return convention %d"), obfd,
4710           out_attr->i);
4711     }
4712
4713   /* Merge Tag_compatibility attributes and any common GNU ones.  */
4714   _bfd_elf_merge_object_attributes (ibfd, obfd);
4715
4716   return TRUE;
4717 }
4718
4719 /* Merge backend specific data from an object file to the output
4720    object file when linking.  */
4721
4722 static bfd_boolean
4723 ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4724 {
4725   flagword old_flags;
4726   flagword new_flags;
4727   bfd_boolean error;
4728
4729   if (!is_ppc_elf (ibfd) || !is_ppc_elf (obfd))
4730     return TRUE;
4731
4732   /* Check if we have the same endianness.  */
4733   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4734     return FALSE;
4735
4736   if (!ppc_elf_merge_obj_attributes (ibfd, obfd))
4737     return FALSE;
4738
4739   new_flags = elf_elfheader (ibfd)->e_flags;
4740   old_flags = elf_elfheader (obfd)->e_flags;
4741   if (!elf_flags_init (obfd))
4742     {
4743       /* First call, no flags set.  */
4744       elf_flags_init (obfd) = TRUE;
4745       elf_elfheader (obfd)->e_flags = new_flags;
4746     }
4747
4748   /* Compatible flags are ok.  */
4749   else if (new_flags == old_flags)
4750     ;
4751
4752   /* Incompatible flags.  */
4753   else
4754     {
4755       /* Warn about -mrelocatable mismatch.  Allow -mrelocatable-lib
4756          to be linked with either.  */
4757       error = FALSE;
4758       if ((new_flags & EF_PPC_RELOCATABLE) != 0
4759           && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
4760         {
4761           error = TRUE;
4762           (*_bfd_error_handler)
4763             (_("%B: compiled with -mrelocatable and linked with "
4764                "modules compiled normally"), ibfd);
4765         }
4766       else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
4767                && (old_flags & EF_PPC_RELOCATABLE) != 0)
4768         {
4769           error = TRUE;
4770           (*_bfd_error_handler)
4771             (_("%B: compiled normally and linked with "
4772                "modules compiled with -mrelocatable"), ibfd);
4773         }
4774
4775       /* The output is -mrelocatable-lib iff both the input files are.  */
4776       if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
4777         elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
4778
4779       /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
4780          but each input file is either -mrelocatable or -mrelocatable-lib.  */
4781       if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
4782           && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
4783           && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
4784         elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
4785
4786       /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if
4787          any module uses it.  */
4788       elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
4789
4790       new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
4791       old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
4792
4793       /* Warn about any other mismatches.  */
4794       if (new_flags != old_flags)
4795         {
4796           error = TRUE;
4797           (*_bfd_error_handler)
4798             (_("%B: uses different e_flags (0x%lx) fields "
4799                "than previous modules (0x%lx)"),
4800              ibfd, (long) new_flags, (long) old_flags);
4801         }
4802
4803       if (error)
4804         {
4805           bfd_set_error (bfd_error_bad_value);
4806           return FALSE;
4807         }
4808     }
4809
4810   return TRUE;
4811 }
4812
4813 static void
4814 ppc_elf_vle_split16 (bfd *output_bfd, bfd_byte *loc,
4815                      bfd_vma value,
4816                      split16_format_type split16_format)
4817
4818 {
4819   unsigned int insn, top5;
4820
4821   insn = bfd_get_32 (output_bfd, loc);
4822   top5 = value & 0xf800;
4823   top5 = top5 << (split16_format == split16a_type ? 9 : 5);
4824   insn |= top5;
4825   insn |= value & 0x7ff;
4826   bfd_put_32 (output_bfd, insn, loc);
4827 }
4828
4829 \f
4830 /* Choose which PLT scheme to use, and set .plt flags appropriately.
4831    Returns -1 on error, 0 for old PLT, 1 for new PLT.  */
4832 int
4833 ppc_elf_select_plt_layout (bfd *output_bfd ATTRIBUTE_UNUSED,
4834                            struct bfd_link_info *info)
4835 {
4836   struct ppc_elf_link_hash_table *htab;
4837   flagword flags;
4838
4839   htab = ppc_elf_hash_table (info);
4840
4841   if (htab->plt_type == PLT_UNSET)
4842     {
4843       struct elf_link_hash_entry *h;
4844
4845       if (htab->params->plt_style == PLT_OLD)
4846         htab->plt_type = PLT_OLD;
4847       else if (bfd_link_pic (info)
4848                && htab->elf.dynamic_sections_created
4849                && (h = elf_link_hash_lookup (&htab->elf, "_mcount",
4850                                              FALSE, FALSE, TRUE)) != NULL
4851                && (h->type == STT_FUNC
4852                    || h->needs_plt)
4853                && h->ref_regular
4854                && !(SYMBOL_CALLS_LOCAL (info, h)
4855                     || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4856                         && h->root.type == bfd_link_hash_undefweak)))
4857         {
4858           /* Profiling of shared libs (and pies) is not supported with
4859              secure plt, because ppc32 does profiling before a
4860              function prologue and a secure plt pic call stubs needs
4861              r30 to be set up.  */
4862           htab->plt_type = PLT_OLD;
4863         }
4864       else
4865         {
4866           bfd *ibfd;
4867           enum ppc_elf_plt_type plt_type = htab->params->plt_style;
4868
4869           /* Look through the reloc flags left by ppc_elf_check_relocs.
4870              Use the old style bss plt if a file makes plt calls
4871              without using the new relocs, and if ld isn't given
4872              --secure-plt and we never see REL16 relocs.  */
4873           if (plt_type == PLT_UNSET)
4874             plt_type = PLT_OLD;
4875           for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
4876             if (is_ppc_elf (ibfd))
4877               {
4878                 if (ppc_elf_tdata (ibfd)->has_rel16)
4879                   plt_type = PLT_NEW;
4880                 else if (ppc_elf_tdata (ibfd)->makes_plt_call)
4881                   {
4882                     plt_type = PLT_OLD;
4883                     htab->old_bfd = ibfd;
4884                     break;
4885                   }
4886               }
4887           htab->plt_type = plt_type;
4888         }
4889     }
4890   if (htab->plt_type == PLT_OLD && htab->params->plt_style == PLT_NEW)
4891     {
4892       if (htab->old_bfd != NULL)
4893         info->callbacks->einfo (_("%P: bss-plt forced due to %B\n"),
4894                                 htab->old_bfd);
4895       else
4896         info->callbacks->einfo (_("%P: bss-plt forced by profiling\n"));
4897     }
4898
4899   BFD_ASSERT (htab->plt_type != PLT_VXWORKS);
4900
4901   if (htab->plt_type == PLT_NEW)
4902     {
4903       flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4904                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4905
4906       /* The new PLT is a loaded section.  */
4907       if (htab->plt != NULL
4908           && !bfd_set_section_flags (htab->elf.dynobj, htab->plt, flags))
4909         return -1;
4910
4911       /* The new GOT is not executable.  */
4912       if (htab->got != NULL
4913           && !bfd_set_section_flags (htab->elf.dynobj, htab->got, flags))
4914         return -1;
4915     }
4916   else
4917     {
4918       /* Stop an unused .glink section from affecting .text alignment.  */
4919       if (htab->glink != NULL
4920           && !bfd_set_section_alignment (htab->elf.dynobj, htab->glink, 0))
4921         return -1;
4922     }
4923   return htab->plt_type == PLT_NEW;
4924 }
4925 \f
4926 /* Return the section that should be marked against GC for a given
4927    relocation.  */
4928
4929 static asection *
4930 ppc_elf_gc_mark_hook (asection *sec,
4931                       struct bfd_link_info *info,
4932                       Elf_Internal_Rela *rel,
4933                       struct elf_link_hash_entry *h,
4934                       Elf_Internal_Sym *sym)
4935 {
4936   if (h != NULL)
4937     switch (ELF32_R_TYPE (rel->r_info))
4938       {
4939       case R_PPC_GNU_VTINHERIT:
4940       case R_PPC_GNU_VTENTRY:
4941         return NULL;
4942       }
4943
4944   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4945 }
4946
4947 /* Update the got, plt and dynamic reloc reference counts for the
4948    section being removed.  */
4949
4950 static bfd_boolean
4951 ppc_elf_gc_sweep_hook (bfd *abfd,
4952                        struct bfd_link_info *info,
4953                        asection *sec,
4954                        const Elf_Internal_Rela *relocs)
4955 {
4956   struct ppc_elf_link_hash_table *htab;
4957   Elf_Internal_Shdr *symtab_hdr;
4958   struct elf_link_hash_entry **sym_hashes;
4959   bfd_signed_vma *local_got_refcounts;
4960   const Elf_Internal_Rela *rel, *relend;
4961   asection *got2;
4962
4963   if (bfd_link_relocatable (info))
4964     return TRUE;
4965
4966   if ((sec->flags & SEC_ALLOC) == 0)
4967     return TRUE;
4968
4969   elf_section_data (sec)->local_dynrel = NULL;
4970
4971   htab = ppc_elf_hash_table (info);
4972   symtab_hdr = &elf_symtab_hdr (abfd);
4973   sym_hashes = elf_sym_hashes (abfd);
4974   local_got_refcounts = elf_local_got_refcounts (abfd);
4975   got2 = bfd_get_section_by_name (abfd, ".got2");
4976
4977   relend = relocs + sec->reloc_count;
4978   for (rel = relocs; rel < relend; rel++)
4979     {
4980       unsigned long r_symndx;
4981       enum elf_ppc_reloc_type r_type;
4982       struct elf_link_hash_entry *h = NULL;
4983
4984       r_symndx = ELF32_R_SYM (rel->r_info);
4985       if (r_symndx >= symtab_hdr->sh_info)
4986         {
4987           struct elf_dyn_relocs **pp, *p;
4988           struct ppc_elf_link_hash_entry *eh;
4989
4990           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4991           while (h->root.type == bfd_link_hash_indirect
4992                  || h->root.type == bfd_link_hash_warning)
4993             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4994           eh = (struct ppc_elf_link_hash_entry *) h;
4995
4996           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
4997             if (p->sec == sec)
4998               {
4999                 /* Everything must go for SEC.  */
5000                 *pp = p->next;
5001                 break;
5002               }
5003         }
5004
5005       r_type = ELF32_R_TYPE (rel->r_info);
5006       if (!htab->is_vxworks
5007           && h == NULL
5008           && local_got_refcounts != NULL
5009           && (!bfd_link_pic (info)
5010               || is_branch_reloc (r_type)))
5011         {
5012           struct plt_entry **local_plt = (struct plt_entry **)
5013             (local_got_refcounts + symtab_hdr->sh_info);
5014           char *local_got_tls_masks = (char *)
5015             (local_plt + symtab_hdr->sh_info);
5016           if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5017             {
5018               struct plt_entry **ifunc = local_plt + r_symndx;
5019               bfd_vma addend = 0;
5020               struct plt_entry *ent;
5021
5022               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info))
5023                 addend = rel->r_addend;
5024               ent = find_plt_ent (ifunc, got2, addend);
5025               if (ent->plt.refcount > 0)
5026                 ent->plt.refcount -= 1;
5027               continue;
5028             }
5029         }
5030
5031       switch (r_type)
5032         {
5033         case R_PPC_GOT_TLSLD16:
5034         case R_PPC_GOT_TLSLD16_LO:
5035         case R_PPC_GOT_TLSLD16_HI:
5036         case R_PPC_GOT_TLSLD16_HA:
5037         case R_PPC_GOT_TLSGD16:
5038         case R_PPC_GOT_TLSGD16_LO:
5039         case R_PPC_GOT_TLSGD16_HI:
5040         case R_PPC_GOT_TLSGD16_HA:
5041         case R_PPC_GOT_TPREL16:
5042         case R_PPC_GOT_TPREL16_LO:
5043         case R_PPC_GOT_TPREL16_HI:
5044         case R_PPC_GOT_TPREL16_HA:
5045         case R_PPC_GOT_DTPREL16:
5046         case R_PPC_GOT_DTPREL16_LO:
5047         case R_PPC_GOT_DTPREL16_HI:
5048         case R_PPC_GOT_DTPREL16_HA:
5049         case R_PPC_GOT16:
5050         case R_PPC_GOT16_LO:
5051         case R_PPC_GOT16_HI:
5052         case R_PPC_GOT16_HA:
5053           if (h != NULL)
5054             {
5055               if (h->got.refcount > 0)
5056                 h->got.refcount--;
5057               if (!bfd_link_pic (info))
5058                 {
5059                   struct plt_entry *ent;
5060
5061                   ent = find_plt_ent (&h->plt.plist, NULL, 0);
5062                   if (ent != NULL && ent->plt.refcount > 0)
5063                     ent->plt.refcount -= 1;
5064                 }
5065             }
5066           else if (local_got_refcounts != NULL)
5067             {
5068               if (local_got_refcounts[r_symndx] > 0)
5069                 local_got_refcounts[r_symndx]--;
5070             }
5071           break;
5072
5073         case R_PPC_REL24:
5074         case R_PPC_REL14:
5075         case R_PPC_REL14_BRTAKEN:
5076         case R_PPC_REL14_BRNTAKEN:
5077         case R_PPC_REL32:
5078           if (h == NULL || h == htab->elf.hgot)
5079             break;
5080           /* Fall thru */
5081
5082         case R_PPC_ADDR32:
5083         case R_PPC_ADDR24:
5084         case R_PPC_ADDR16:
5085         case R_PPC_ADDR16_LO:
5086         case R_PPC_ADDR16_HI:
5087         case R_PPC_ADDR16_HA:
5088         case R_PPC_ADDR14:
5089         case R_PPC_ADDR14_BRTAKEN:
5090         case R_PPC_ADDR14_BRNTAKEN:
5091         case R_PPC_UADDR32:
5092         case R_PPC_UADDR16:
5093           if (bfd_link_pic (info))
5094             break;
5095
5096         case R_PPC_PLT32:
5097         case R_PPC_PLTREL24:
5098         case R_PPC_PLTREL32:
5099         case R_PPC_PLT16_LO:
5100         case R_PPC_PLT16_HI:
5101         case R_PPC_PLT16_HA:
5102           if (h != NULL)
5103             {
5104               bfd_vma addend = 0;
5105               struct plt_entry *ent;
5106
5107               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info))
5108                 addend = rel->r_addend;
5109               ent = find_plt_ent (&h->plt.plist, got2, addend);
5110               if (ent != NULL && ent->plt.refcount > 0)
5111                 ent->plt.refcount -= 1;
5112             }
5113           break;
5114
5115         default:
5116           break;
5117         }
5118     }
5119   return TRUE;
5120 }
5121 \f
5122 /* Set plt output section type, htab->tls_get_addr, and call the
5123    generic ELF tls_setup function.  */
5124
5125 asection *
5126 ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
5127 {
5128   struct ppc_elf_link_hash_table *htab;
5129
5130   htab = ppc_elf_hash_table (info);
5131   htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5132                                              FALSE, FALSE, TRUE);
5133   if (htab->plt_type != PLT_NEW)
5134     htab->params->no_tls_get_addr_opt = TRUE;
5135
5136   if (!htab->params->no_tls_get_addr_opt)
5137     {
5138       struct elf_link_hash_entry *opt, *tga;
5139       opt = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
5140                                   FALSE, FALSE, TRUE);
5141       if (opt != NULL
5142           && (opt->root.type == bfd_link_hash_defined
5143               || opt->root.type == bfd_link_hash_defweak))
5144         {
5145           /* If glibc supports an optimized __tls_get_addr call stub,
5146              signalled by the presence of __tls_get_addr_opt, and we'll
5147              be calling __tls_get_addr via a plt call stub, then
5148              make __tls_get_addr point to __tls_get_addr_opt.  */
5149           tga = htab->tls_get_addr;
5150           if (htab->elf.dynamic_sections_created
5151               && tga != NULL
5152               && (tga->type == STT_FUNC
5153                   || tga->needs_plt)
5154               && !(SYMBOL_CALLS_LOCAL (info, tga)
5155                    || (ELF_ST_VISIBILITY (tga->other) != STV_DEFAULT
5156                        && tga->root.type == bfd_link_hash_undefweak)))
5157             {
5158               struct plt_entry *ent;
5159               for (ent = tga->plt.plist; ent != NULL; ent = ent->next)
5160                 if (ent->plt.refcount > 0)
5161                   break;
5162               if (ent != NULL)
5163                 {
5164                   tga->root.type = bfd_link_hash_indirect;
5165                   tga->root.u.i.link = &opt->root;
5166                   ppc_elf_copy_indirect_symbol (info, opt, tga);
5167                   opt->forced_local = 0;
5168                   if (opt->dynindx != -1)
5169                     {
5170                       /* Use __tls_get_addr_opt in dynamic relocations.  */
5171                       opt->dynindx = -1;
5172                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
5173                                               opt->dynstr_index);
5174                       if (!bfd_elf_link_record_dynamic_symbol (info, opt))
5175                         return FALSE;
5176                     }
5177                   htab->tls_get_addr = opt;
5178                 }
5179             }
5180         }
5181       else
5182         htab->params->no_tls_get_addr_opt = TRUE;
5183     }
5184   if (htab->plt_type == PLT_NEW
5185       && htab->plt != NULL
5186       && htab->plt->output_section != NULL)
5187     {
5188       elf_section_type (htab->plt->output_section) = SHT_PROGBITS;
5189       elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE;
5190     }
5191
5192   return _bfd_elf_tls_setup (obfd, info);
5193 }
5194
5195 /* Return TRUE iff REL is a branch reloc with a global symbol matching
5196    HASH.  */
5197
5198 static bfd_boolean
5199 branch_reloc_hash_match (const bfd *ibfd,
5200                          const Elf_Internal_Rela *rel,
5201                          const struct elf_link_hash_entry *hash)
5202 {
5203   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
5204   enum elf_ppc_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
5205   unsigned int r_symndx = ELF32_R_SYM (rel->r_info);
5206
5207   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
5208     {
5209       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
5210       struct elf_link_hash_entry *h;
5211
5212       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5213       while (h->root.type == bfd_link_hash_indirect
5214              || h->root.type == bfd_link_hash_warning)
5215         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5216       if (h == hash)
5217         return TRUE;
5218     }
5219   return FALSE;
5220 }
5221
5222 /* Run through all the TLS relocs looking for optimization
5223    opportunities.  */
5224
5225 bfd_boolean
5226 ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED,
5227                       struct bfd_link_info *info)
5228 {
5229   bfd *ibfd;
5230   asection *sec;
5231   struct ppc_elf_link_hash_table *htab;
5232   int pass;
5233
5234   if (!bfd_link_executable (info))
5235     return TRUE;
5236
5237   htab = ppc_elf_hash_table (info);
5238   if (htab == NULL)
5239     return FALSE;
5240
5241   /* Make two passes through the relocs.  First time check that tls
5242      relocs involved in setting up a tls_get_addr call are indeed
5243      followed by such a call.  If they are not, don't do any tls
5244      optimization.  On the second pass twiddle tls_mask flags to
5245      notify relocate_section that optimization can be done, and
5246      adjust got and plt refcounts.  */
5247   for (pass = 0; pass < 2; ++pass)
5248     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5249       {
5250         Elf_Internal_Sym *locsyms = NULL;
5251         Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
5252         asection *got2 = bfd_get_section_by_name (ibfd, ".got2");
5253
5254         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5255           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
5256             {
5257               Elf_Internal_Rela *relstart, *rel, *relend;
5258               int expecting_tls_get_addr = 0;
5259
5260               /* Read the relocations.  */
5261               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
5262                                                     info->keep_memory);
5263               if (relstart == NULL)
5264                 return FALSE;
5265
5266               relend = relstart + sec->reloc_count;
5267               for (rel = relstart; rel < relend; rel++)
5268                 {
5269                   enum elf_ppc_reloc_type r_type;
5270                   unsigned long r_symndx;
5271                   struct elf_link_hash_entry *h = NULL;
5272                   char *tls_mask;
5273                   char tls_set, tls_clear;
5274                   bfd_boolean is_local;
5275                   bfd_signed_vma *got_count;
5276
5277                   r_symndx = ELF32_R_SYM (rel->r_info);
5278                   if (r_symndx >= symtab_hdr->sh_info)
5279                     {
5280                       struct elf_link_hash_entry **sym_hashes;
5281
5282                       sym_hashes = elf_sym_hashes (ibfd);
5283                       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5284                       while (h->root.type == bfd_link_hash_indirect
5285                              || h->root.type == bfd_link_hash_warning)
5286                         h = (struct elf_link_hash_entry *) h->root.u.i.link;
5287                     }
5288
5289                   is_local = FALSE;
5290                   if (h == NULL
5291                       || !h->def_dynamic)
5292                     is_local = TRUE;
5293
5294                   r_type = ELF32_R_TYPE (rel->r_info);
5295                   /* If this section has old-style __tls_get_addr calls
5296                      without marker relocs, then check that each
5297                      __tls_get_addr call reloc is preceded by a reloc
5298                      that conceivably belongs to the __tls_get_addr arg
5299                      setup insn.  If we don't find matching arg setup
5300                      relocs, don't do any tls optimization.  */
5301                   if (pass == 0
5302                       && sec->has_tls_get_addr_call
5303                       && h != NULL
5304                       && h == htab->tls_get_addr
5305                       && !expecting_tls_get_addr
5306                       && is_branch_reloc (r_type))
5307                     {
5308                       info->callbacks->minfo ("%H __tls_get_addr lost arg, "
5309                                               "TLS optimization disabled\n",
5310                                               ibfd, sec, rel->r_offset);
5311                       if (elf_section_data (sec)->relocs != relstart)
5312                         free (relstart);
5313                       return TRUE;
5314                     }
5315
5316                   expecting_tls_get_addr = 0;
5317                   switch (r_type)
5318                     {
5319                     case R_PPC_GOT_TLSLD16:
5320                     case R_PPC_GOT_TLSLD16_LO:
5321                       expecting_tls_get_addr = 1;
5322                       /* Fall thru */
5323
5324                     case R_PPC_GOT_TLSLD16_HI:
5325                     case R_PPC_GOT_TLSLD16_HA:
5326                       /* These relocs should never be against a symbol
5327                          defined in a shared lib.  Leave them alone if
5328                          that turns out to be the case.  */
5329                       if (!is_local)
5330                         continue;
5331
5332                       /* LD -> LE */
5333                       tls_set = 0;
5334                       tls_clear = TLS_LD;
5335                       break;
5336
5337                     case R_PPC_GOT_TLSGD16:
5338                     case R_PPC_GOT_TLSGD16_LO:
5339                       expecting_tls_get_addr = 1;
5340                       /* Fall thru */
5341
5342                     case R_PPC_GOT_TLSGD16_HI:
5343                     case R_PPC_GOT_TLSGD16_HA:
5344                       if (is_local)
5345                         /* GD -> LE */
5346                         tls_set = 0;
5347                       else
5348                         /* GD -> IE */
5349                         tls_set = TLS_TLS | TLS_TPRELGD;
5350                       tls_clear = TLS_GD;
5351                       break;
5352
5353                     case R_PPC_GOT_TPREL16:
5354                     case R_PPC_GOT_TPREL16_LO:
5355                     case R_PPC_GOT_TPREL16_HI:
5356                     case R_PPC_GOT_TPREL16_HA:
5357                       if (is_local)
5358                         {
5359                           /* IE -> LE */
5360                           tls_set = 0;
5361                           tls_clear = TLS_TPREL;
5362                           break;
5363                         }
5364                       else
5365                         continue;
5366
5367                     case R_PPC_TLSGD:
5368                     case R_PPC_TLSLD:
5369                       expecting_tls_get_addr = 2;
5370                       tls_set = 0;
5371                       tls_clear = 0;
5372                       break;
5373
5374                     default:
5375                       continue;
5376                     }
5377
5378                   if (pass == 0)
5379                     {
5380                       if (!expecting_tls_get_addr
5381                           || (expecting_tls_get_addr == 1
5382                               && !sec->has_tls_get_addr_call))
5383                         continue;
5384
5385                       if (rel + 1 < relend
5386                           && branch_reloc_hash_match (ibfd, rel + 1,
5387                                                       htab->tls_get_addr))
5388                         continue;
5389
5390                       /* Uh oh, we didn't find the expected call.  We
5391                          could just mark this symbol to exclude it
5392                          from tls optimization but it's safer to skip
5393                          the entire optimization.  */
5394                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
5395                                                 "TLS optimization disabled\n"),
5396                                               ibfd, sec, rel->r_offset);
5397                       if (elf_section_data (sec)->relocs != relstart)
5398                         free (relstart);
5399                       return TRUE;
5400                     }
5401
5402                   if (expecting_tls_get_addr)
5403                     {
5404                       struct plt_entry *ent;
5405                       bfd_vma addend = 0;
5406
5407                       if (bfd_link_pic (info)
5408                           && ELF32_R_TYPE (rel[1].r_info) == R_PPC_PLTREL24)
5409                         addend = rel[1].r_addend;
5410                       ent = find_plt_ent (&htab->tls_get_addr->plt.plist,
5411                                           got2, addend);
5412                       if (ent != NULL && ent->plt.refcount > 0)
5413                         ent->plt.refcount -= 1;
5414
5415                       if (expecting_tls_get_addr == 2)
5416                         continue;
5417                     }
5418
5419                   if (h != NULL)
5420                     {
5421                       tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
5422                       got_count = &h->got.refcount;
5423                     }
5424                   else
5425                     {
5426                       bfd_signed_vma *lgot_refs;
5427                       struct plt_entry **local_plt;
5428                       char *lgot_masks;
5429
5430                       if (locsyms == NULL)
5431                         {
5432                           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
5433                           if (locsyms == NULL)
5434                             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
5435                                                             symtab_hdr->sh_info,
5436                                                             0, NULL, NULL, NULL);
5437                           if (locsyms == NULL)
5438                             {
5439                               if (elf_section_data (sec)->relocs != relstart)
5440                                 free (relstart);
5441                               return FALSE;
5442                             }
5443                         }
5444                       lgot_refs = elf_local_got_refcounts (ibfd);
5445                       if (lgot_refs == NULL)
5446                         abort ();
5447                       local_plt = (struct plt_entry **)
5448                         (lgot_refs + symtab_hdr->sh_info);
5449                       lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
5450                       tls_mask = &lgot_masks[r_symndx];
5451                       got_count = &lgot_refs[r_symndx];
5452                     }
5453
5454                   if (tls_set == 0)
5455                     {
5456                       /* We managed to get rid of a got entry.  */
5457                       if (*got_count > 0)
5458                         *got_count -= 1;
5459                     }
5460
5461                   *tls_mask |= tls_set;
5462                   *tls_mask &= ~tls_clear;
5463                 }
5464
5465               if (elf_section_data (sec)->relocs != relstart)
5466                 free (relstart);
5467             }
5468
5469         if (locsyms != NULL
5470             && (symtab_hdr->contents != (unsigned char *) locsyms))
5471           {
5472             if (!info->keep_memory)
5473               free (locsyms);
5474             else
5475               symtab_hdr->contents = (unsigned char *) locsyms;
5476           }
5477       }
5478   return TRUE;
5479 }
5480 \f
5481 /* Return true if we have dynamic relocs that apply to read-only sections.  */
5482
5483 static bfd_boolean
5484 readonly_dynrelocs (struct elf_link_hash_entry *h)
5485 {
5486   struct elf_dyn_relocs *p;
5487
5488   for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
5489     {
5490       asection *s = p->sec->output_section;
5491
5492       if (s != NULL
5493           && ((s->flags & (SEC_READONLY | SEC_ALLOC))
5494               == (SEC_READONLY | SEC_ALLOC)))
5495         return TRUE;
5496     }
5497   return FALSE;
5498 }
5499
5500 /* Adjust a symbol defined by a dynamic object and referenced by a
5501    regular object.  The current definition is in some section of the
5502    dynamic object, but we're not including those sections.  We have to
5503    change the definition to something the rest of the link can
5504    understand.  */
5505
5506 static bfd_boolean
5507 ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5508                                struct elf_link_hash_entry *h)
5509 {
5510   struct ppc_elf_link_hash_table *htab;
5511   asection *s;
5512
5513 #ifdef DEBUG
5514   fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n",
5515            h->root.root.string);
5516 #endif
5517
5518   /* Make sure we know what is going on here.  */
5519   htab = ppc_elf_hash_table (info);
5520   BFD_ASSERT (htab->elf.dynobj != NULL
5521               && (h->needs_plt
5522                   || h->type == STT_GNU_IFUNC
5523                   || h->u.weakdef != NULL
5524                   || (h->def_dynamic
5525                       && h->ref_regular
5526                       && !h->def_regular)));
5527
5528   /* Deal with function syms.  */
5529   if (h->type == STT_FUNC
5530       || h->type == STT_GNU_IFUNC
5531       || h->needs_plt)
5532     {
5533       /* Clear procedure linkage table information for any symbol that
5534          won't need a .plt entry.  */
5535       struct plt_entry *ent;
5536       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5537         if (ent->plt.refcount > 0)
5538           break;
5539       if (ent == NULL
5540           || (h->type != STT_GNU_IFUNC
5541               && (SYMBOL_CALLS_LOCAL (info, h)
5542                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5543                       && h->root.type == bfd_link_hash_undefweak))))
5544         {
5545           /* A PLT entry is not required/allowed when:
5546
5547              1. We are not using ld.so; because then the PLT entry
5548              can't be set up, so we can't use one.  In this case,
5549              ppc_elf_adjust_dynamic_symbol won't even be called.
5550
5551              2. GC has rendered the entry unused.
5552
5553              3. We know for certain that a call to this symbol
5554              will go to this object, or will remain undefined.  */
5555           h->plt.plist = NULL;
5556           h->needs_plt = 0;
5557           h->pointer_equality_needed = 0;
5558         }
5559       else
5560         {
5561           /* Taking a function's address in a read/write section
5562              doesn't require us to define the function symbol in the
5563              executable on a plt call stub.  A dynamic reloc can
5564              be used instead.  */
5565           if (h->pointer_equality_needed
5566               && h->type != STT_GNU_IFUNC
5567               && !htab->is_vxworks
5568               && !ppc_elf_hash_entry (h)->has_sda_refs
5569               && !readonly_dynrelocs (h))
5570             {
5571               h->pointer_equality_needed = 0;
5572               h->non_got_ref = 0;
5573             }
5574
5575           /* After adjust_dynamic_symbol, non_got_ref set in the
5576              non-shared case means that we have allocated space in
5577              .dynbss for the symbol and thus dyn_relocs for this
5578              symbol should be discarded.
5579              If we get here we know we are making a PLT entry for this
5580              symbol, and in an executable we'd normally resolve
5581              relocations against this symbol to the PLT entry.  Allow
5582              dynamic relocs if the reference is weak, and the dynamic
5583              relocs will not cause text relocation.  */
5584           else if (!h->ref_regular_nonweak
5585                    && h->non_got_ref
5586                    && h->type != STT_GNU_IFUNC
5587                    && !htab->is_vxworks
5588                    && !ppc_elf_hash_entry (h)->has_sda_refs
5589                    && !readonly_dynrelocs (h))
5590             h->non_got_ref = 0;
5591         }
5592       h->protected_def = 0;
5593       return TRUE;
5594     }
5595   else
5596     h->plt.plist = NULL;
5597
5598   /* If this is a weak symbol, and there is a real definition, the
5599      processor independent code will have arranged for us to see the
5600      real definition first, and we can just use the same value.  */
5601   if (h->u.weakdef != NULL)
5602     {
5603       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5604                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5605       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5606       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5607       if (ELIMINATE_COPY_RELOCS)
5608         h->non_got_ref = h->u.weakdef->non_got_ref;
5609       return TRUE;
5610     }
5611
5612   /* This is a reference to a symbol defined by a dynamic object which
5613      is not a function.  */
5614
5615   /* If we are creating a shared library, we must presume that the
5616      only references to the symbol are via the global offset table.
5617      For such cases we need not do anything here; the relocations will
5618      be handled correctly by relocate_section.  */
5619   if (bfd_link_pic (info))
5620     {
5621       h->protected_def = 0;
5622       return TRUE;
5623     }
5624
5625   /* If there are no references to this symbol that do not use the
5626      GOT, we don't need to generate a copy reloc.  */
5627   if (!h->non_got_ref)
5628     {
5629       h->protected_def = 0;
5630       return TRUE;
5631     }
5632
5633   /* Protected variables do not work with .dynbss.  The copy in
5634      .dynbss won't be used by the shared library with the protected
5635      definition for the variable.  Editing to PIC, or text relocations
5636      are preferable to an incorrect program.  */
5637   if (h->protected_def)
5638     {
5639       if (ELIMINATE_COPY_RELOCS
5640           && ppc_elf_hash_entry (h)->has_addr16_ha
5641           && ppc_elf_hash_entry (h)->has_addr16_lo
5642           && htab->params->pic_fixup == 0
5643           && info->disable_target_specific_optimizations <= 1)
5644         htab->params->pic_fixup = 1;
5645       h->non_got_ref = 0;
5646       return TRUE;
5647     }
5648
5649   /* If -z nocopyreloc was given, we won't generate them either.  */
5650   if (info->nocopyreloc)
5651     {
5652       h->non_got_ref = 0;
5653       return TRUE;
5654     }
5655
5656    /* If we didn't find any dynamic relocs in read-only sections, then
5657       we'll be keeping the dynamic relocs and avoiding the copy reloc.
5658       We can't do this if there are any small data relocations.  This
5659       doesn't work on VxWorks, where we can not have dynamic
5660       relocations (other than copy and jump slot relocations) in an
5661       executable.  */
5662   if (ELIMINATE_COPY_RELOCS
5663       && !ppc_elf_hash_entry (h)->has_sda_refs
5664       && !htab->is_vxworks
5665       && !h->def_regular
5666       && !readonly_dynrelocs (h))
5667     {
5668       h->non_got_ref = 0;
5669       return TRUE;
5670     }
5671
5672   /* We must allocate the symbol in our .dynbss section, which will
5673      become part of the .bss section of the executable.  There will be
5674      an entry for this symbol in the .dynsym section.  The dynamic
5675      object will contain position independent code, so all references
5676      from the dynamic object to this symbol will go through the global
5677      offset table.  The dynamic linker will use the .dynsym entry to
5678      determine the address it must put in the global offset table, so
5679      both the dynamic object and the regular object will refer to the
5680      same memory location for the variable.
5681
5682      Of course, if the symbol is referenced using SDAREL relocs, we
5683      must instead allocate it in .sbss.  */
5684
5685   if (ppc_elf_hash_entry (h)->has_sda_refs)
5686     s = htab->dynsbss;
5687   else
5688     s = htab->dynbss;
5689   BFD_ASSERT (s != NULL);
5690
5691   /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
5692      copy the initial value out of the dynamic object and into the
5693      runtime process image.  We need to remember the offset into the
5694      .rela.bss section we are going to use.  */
5695   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5696     {
5697       asection *srel;
5698
5699       if (ppc_elf_hash_entry (h)->has_sda_refs)
5700         srel = htab->relsbss;
5701       else
5702         srel = htab->relbss;
5703       BFD_ASSERT (srel != NULL);
5704       srel->size += sizeof (Elf32_External_Rela);
5705       h->needs_copy = 1;
5706     }
5707
5708   return _bfd_elf_adjust_dynamic_copy (info, h, s);
5709 }
5710 \f
5711 /* Generate a symbol to mark plt call stubs.  For non-PIC code the sym is
5712    xxxxxxxx.plt_call32.<callee> where xxxxxxxx is a hex number, usually 0,
5713    specifying the addend on the plt relocation.  For -fpic code, the sym
5714    is xxxxxxxx.plt_pic32.<callee>, and for -fPIC
5715    xxxxxxxx.got2.plt_pic32.<callee>.  */
5716
5717 static bfd_boolean
5718 add_stub_sym (struct plt_entry *ent,
5719               struct elf_link_hash_entry *h,
5720               struct bfd_link_info *info)
5721 {
5722   struct elf_link_hash_entry *sh;
5723   size_t len1, len2, len3;
5724   char *name;
5725   const char *stub;
5726   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
5727
5728   if (bfd_link_pic (info))
5729     stub = ".plt_pic32.";
5730   else
5731     stub = ".plt_call32.";
5732
5733   len1 = strlen (h->root.root.string);
5734   len2 = strlen (stub);
5735   len3 = 0;
5736   if (ent->sec)
5737     len3 = strlen (ent->sec->name);
5738   name = bfd_malloc (len1 + len2 + len3 + 9);
5739   if (name == NULL)
5740     return FALSE;
5741   sprintf (name, "%08x", (unsigned) ent->addend & 0xffffffff);
5742   if (ent->sec)
5743     memcpy (name + 8, ent->sec->name, len3);
5744   memcpy (name + 8 + len3, stub, len2);
5745   memcpy (name + 8 + len3 + len2, h->root.root.string, len1 + 1);
5746   sh = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
5747   if (sh == NULL)
5748     return FALSE;
5749   if (sh->root.type == bfd_link_hash_new)
5750     {
5751       sh->root.type = bfd_link_hash_defined;
5752       sh->root.u.def.section = htab->glink;
5753       sh->root.u.def.value = ent->glink_offset;
5754       sh->ref_regular = 1;
5755       sh->def_regular = 1;
5756       sh->ref_regular_nonweak = 1;
5757       sh->forced_local = 1;
5758       sh->non_elf = 0;
5759       sh->root.linker_def = 1;
5760     }
5761   return TRUE;
5762 }
5763
5764 /* Allocate NEED contiguous space in .got, and return the offset.
5765    Handles allocation of the got header when crossing 32k.  */
5766
5767 static bfd_vma
5768 allocate_got (struct ppc_elf_link_hash_table *htab, unsigned int need)
5769 {
5770   bfd_vma where;
5771   unsigned int max_before_header;
5772
5773   if (htab->plt_type == PLT_VXWORKS)
5774     {
5775       where = htab->got->size;
5776       htab->got->size += need;
5777     }
5778   else
5779     {
5780       max_before_header = htab->plt_type == PLT_NEW ? 32768 : 32764;
5781       if (need <= htab->got_gap)
5782         {
5783           where = max_before_header - htab->got_gap;
5784           htab->got_gap -= need;
5785         }
5786       else
5787         {
5788           if (htab->got->size + need > max_before_header
5789               && htab->got->size <= max_before_header)
5790             {
5791               htab->got_gap = max_before_header - htab->got->size;
5792               htab->got->size = max_before_header + htab->got_header_size;
5793             }
5794           where = htab->got->size;
5795           htab->got->size += need;
5796         }
5797     }
5798   return where;
5799 }
5800
5801 /* Allocate space in associated reloc sections for dynamic relocs.  */
5802
5803 static bfd_boolean
5804 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5805 {
5806   struct bfd_link_info *info = inf;
5807   struct ppc_elf_link_hash_entry *eh;
5808   struct ppc_elf_link_hash_table *htab;
5809   struct elf_dyn_relocs *p;
5810
5811   if (h->root.type == bfd_link_hash_indirect)
5812     return TRUE;
5813
5814   htab = ppc_elf_hash_table (info);
5815   if (htab->elf.dynamic_sections_created
5816       || h->type == STT_GNU_IFUNC)
5817     {
5818       struct plt_entry *ent;
5819       bfd_boolean doneone = FALSE;
5820       bfd_vma plt_offset = 0, glink_offset = 0;
5821       bfd_boolean dyn;
5822
5823       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5824         if (ent->plt.refcount > 0)
5825           {
5826             /* Make sure this symbol is output as a dynamic symbol.  */
5827             if (h->dynindx == -1
5828                 && !h->forced_local
5829                 && !h->def_regular
5830                 && htab->elf.dynamic_sections_created)
5831               {
5832                 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5833                   return FALSE;
5834               }
5835
5836             dyn = htab->elf.dynamic_sections_created;
5837             if (bfd_link_pic (info)
5838                 || h->type == STT_GNU_IFUNC
5839                 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
5840               {
5841                 asection *s = htab->plt;
5842                 if (!dyn || h->dynindx == -1)
5843                   s = htab->iplt;
5844
5845                 if (htab->plt_type == PLT_NEW || !dyn || h->dynindx == -1)
5846                   {
5847                     if (!doneone)
5848                       {
5849                         plt_offset = s->size;
5850                         s->size += 4;
5851                       }
5852                     ent->plt.offset = plt_offset;
5853
5854                     s = htab->glink;
5855                     if (!doneone || bfd_link_pic (info))
5856                       {
5857                         glink_offset = s->size;
5858                         s->size += GLINK_ENTRY_SIZE;
5859                         if (h == htab->tls_get_addr
5860                             && !htab->params->no_tls_get_addr_opt)
5861                           s->size += TLS_GET_ADDR_GLINK_SIZE - GLINK_ENTRY_SIZE;
5862                       }
5863                     if (!doneone
5864                         && !bfd_link_pic (info)
5865                         && h->def_dynamic
5866                         && !h->def_regular)
5867                       {
5868                         h->root.u.def.section = s;
5869                         h->root.u.def.value = glink_offset;
5870                       }
5871                     ent->glink_offset = glink_offset;
5872
5873                     if (htab->params->emit_stub_syms
5874                         && !add_stub_sym (ent, h, info))
5875                       return FALSE;
5876                   }
5877                 else
5878                   {
5879                     if (!doneone)
5880                       {
5881                         /* If this is the first .plt entry, make room
5882                            for the special first entry.  */
5883                         if (s->size == 0)
5884                           s->size += htab->plt_initial_entry_size;
5885
5886                         /* The PowerPC PLT is actually composed of two
5887                            parts, the first part is 2 words (for a load
5888                            and a jump), and then there is a remaining
5889                            word available at the end.  */
5890                         plt_offset = (htab->plt_initial_entry_size
5891                                       + (htab->plt_slot_size
5892                                          * ((s->size
5893                                              - htab->plt_initial_entry_size)
5894                                             / htab->plt_entry_size)));
5895
5896                         /* If this symbol is not defined in a regular
5897                            file, and we are not generating a shared
5898                            library, then set the symbol to this location
5899                            in the .plt.  This is to avoid text
5900                            relocations, and is required to make
5901                            function pointers compare as equal between
5902                            the normal executable and the shared library.  */
5903                         if (! bfd_link_pic (info)
5904                             && h->def_dynamic
5905                             && !h->def_regular)
5906                           {
5907                             h->root.u.def.section = s;
5908                             h->root.u.def.value = plt_offset;
5909                           }
5910
5911                         /* Make room for this entry.  */
5912                         s->size += htab->plt_entry_size;
5913                         /* After the 8192nd entry, room for two entries
5914                            is allocated.  */
5915                         if (htab->plt_type == PLT_OLD
5916                             && (s->size - htab->plt_initial_entry_size)
5917                                 / htab->plt_entry_size
5918                                > PLT_NUM_SINGLE_ENTRIES)
5919                           s->size += htab->plt_entry_size;
5920                       }
5921                     ent->plt.offset = plt_offset;
5922                   }
5923
5924                 /* We also need to make an entry in the .rela.plt section.  */
5925                 if (!doneone)
5926                   {
5927                     if (!htab->elf.dynamic_sections_created
5928                         || h->dynindx == -1)
5929                       htab->reliplt->size += sizeof (Elf32_External_Rela);
5930                     else
5931                       {
5932                         htab->relplt->size += sizeof (Elf32_External_Rela);
5933
5934                         if (htab->plt_type == PLT_VXWORKS)
5935                           {
5936                             /* Allocate space for the unloaded relocations.  */
5937                             if (!bfd_link_pic (info)
5938                                 && htab->elf.dynamic_sections_created)
5939                               {
5940                                 if (ent->plt.offset
5941                                     == (bfd_vma) htab->plt_initial_entry_size)
5942                                   {
5943                                     htab->srelplt2->size
5944                                       += (sizeof (Elf32_External_Rela)
5945                                           * VXWORKS_PLTRESOLVE_RELOCS);
5946                                   }
5947
5948                                 htab->srelplt2->size
5949                                   += (sizeof (Elf32_External_Rela)
5950                                       * VXWORKS_PLT_NON_JMP_SLOT_RELOCS);
5951                               }
5952
5953                             /* Every PLT entry has an associated GOT entry in
5954                                .got.plt.  */
5955                             htab->sgotplt->size += 4;
5956                           }
5957                       }
5958                     doneone = TRUE;
5959                   }
5960               }
5961             else
5962               ent->plt.offset = (bfd_vma) -1;
5963           }
5964         else
5965           ent->plt.offset = (bfd_vma) -1;
5966
5967       if (!doneone)
5968         {
5969           h->plt.plist = NULL;
5970           h->needs_plt = 0;
5971         }
5972     }
5973   else
5974     {
5975       h->plt.plist = NULL;
5976       h->needs_plt = 0;
5977     }
5978
5979   eh = (struct ppc_elf_link_hash_entry *) h;
5980   if (eh->elf.got.refcount > 0
5981       || (ELIMINATE_COPY_RELOCS
5982           && !eh->elf.def_regular
5983           && eh->elf.protected_def
5984           && eh->has_addr16_ha
5985           && eh->has_addr16_lo
5986           && htab->params->pic_fixup > 0))
5987     {
5988       bfd_boolean dyn;
5989       unsigned int need;
5990
5991       /* Make sure this symbol is output as a dynamic symbol.  */
5992       if (eh->elf.dynindx == -1
5993           && !eh->elf.forced_local
5994           && eh->elf.type != STT_GNU_IFUNC
5995           && htab->elf.dynamic_sections_created)
5996         {
5997           if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf))
5998             return FALSE;
5999         }
6000
6001       need = 0;
6002       if ((eh->tls_mask & TLS_TLS) != 0)
6003         {
6004           if ((eh->tls_mask & TLS_LD) != 0)
6005             {
6006               if (!eh->elf.def_dynamic)
6007                 /* We'll just use htab->tlsld_got.offset.  This should
6008                    always be the case.  It's a little odd if we have
6009                    a local dynamic reloc against a non-local symbol.  */
6010                 htab->tlsld_got.refcount += 1;
6011               else
6012                 need += 8;
6013             }
6014           if ((eh->tls_mask & TLS_GD) != 0)
6015             need += 8;
6016           if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
6017             need += 4;
6018           if ((eh->tls_mask & TLS_DTPREL) != 0)
6019             need += 4;
6020         }
6021       else
6022         need += 4;
6023       if (need == 0)
6024         eh->elf.got.offset = (bfd_vma) -1;
6025       else
6026         {
6027           eh->elf.got.offset = allocate_got (htab, need);
6028           dyn = htab->elf.dynamic_sections_created;
6029           if ((bfd_link_pic (info)
6030                || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf))
6031               && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT
6032                   || eh->elf.root.type != bfd_link_hash_undefweak))
6033             {
6034               asection *rsec = htab->relgot;
6035
6036               if (eh->elf.type == STT_GNU_IFUNC)
6037                 rsec = htab->reliplt;
6038               /* All the entries we allocated need relocs.
6039                  Except LD only needs one.  */
6040               if ((eh->tls_mask & TLS_LD) != 0
6041                   && eh->elf.def_dynamic)
6042                 need -= 4;
6043               rsec->size += need * (sizeof (Elf32_External_Rela) / 4);
6044             }
6045         }
6046     }
6047   else
6048     eh->elf.got.offset = (bfd_vma) -1;
6049
6050   if (eh->dyn_relocs == NULL
6051       || !htab->elf.dynamic_sections_created)
6052     return TRUE;
6053
6054   /* In the shared -Bsymbolic case, discard space allocated for
6055      dynamic pc-relative relocs against symbols which turn out to be
6056      defined in regular objects.  For the normal shared case, discard
6057      space for relocs that have become local due to symbol visibility
6058      changes.  */
6059
6060   if (bfd_link_pic (info))
6061     {
6062       /* Relocs that use pc_count are those that appear on a call insn,
6063          or certain REL relocs (see must_be_dyn_reloc) that can be
6064          generated via assembly.  We want calls to protected symbols to
6065          resolve directly to the function rather than going via the plt.
6066          If people want function pointer comparisons to work as expected
6067          then they should avoid writing weird assembly.  */
6068       if (SYMBOL_CALLS_LOCAL (info, h))
6069         {
6070           struct elf_dyn_relocs **pp;
6071
6072           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
6073             {
6074               p->count -= p->pc_count;
6075               p->pc_count = 0;
6076               if (p->count == 0)
6077                 *pp = p->next;
6078               else
6079                 pp = &p->next;
6080             }
6081         }
6082
6083       if (htab->is_vxworks)
6084         {
6085           struct elf_dyn_relocs **pp;
6086
6087           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
6088             {
6089               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
6090                 *pp = p->next;
6091               else
6092                 pp = &p->next;
6093             }
6094         }
6095
6096       /* Discard relocs on undefined symbols that must be local.  */
6097       if (eh->dyn_relocs != NULL
6098           && h->root.type == bfd_link_hash_undefined
6099           && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
6100               || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
6101         eh->dyn_relocs = NULL;
6102
6103       /* Also discard relocs on undefined weak syms with non-default
6104          visibility.  */
6105       if (eh->dyn_relocs != NULL
6106           && h->root.type == bfd_link_hash_undefweak)
6107         {
6108           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
6109             eh->dyn_relocs = NULL;
6110
6111           /* Make sure undefined weak symbols are output as a dynamic
6112              symbol in PIEs.  */
6113           else if (h->dynindx == -1
6114                    && !h->forced_local
6115                    && !h->def_regular)
6116             {
6117               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6118                 return FALSE;
6119             }
6120         }
6121     }
6122   else if (ELIMINATE_COPY_RELOCS)
6123     {
6124       /* For the non-shared case, discard space for relocs against
6125          symbols which turn out to need copy relocs or are not
6126          dynamic.  */
6127
6128       if (!h->non_got_ref
6129           && !h->def_regular
6130           && !(h->protected_def
6131                && eh->has_addr16_ha
6132                && eh->has_addr16_lo
6133                && htab->params->pic_fixup > 0))
6134         {
6135           /* Make sure this symbol is output as a dynamic symbol.
6136              Undefined weak syms won't yet be marked as dynamic.  */
6137           if (h->dynindx == -1
6138               && !h->forced_local)
6139             {
6140               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6141                 return FALSE;
6142             }
6143
6144           /* If that succeeded, we know we'll be keeping all the
6145              relocs.  */
6146           if (h->dynindx != -1)
6147             goto keep;
6148         }
6149
6150       eh->dyn_relocs = NULL;
6151
6152     keep: ;
6153     }
6154
6155   /* Finally, allocate space.  */
6156   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6157     {
6158       asection *sreloc = elf_section_data (p->sec)->sreloc;
6159       if (eh->elf.type == STT_GNU_IFUNC)
6160         sreloc = htab->reliplt;
6161       sreloc->size += p->count * sizeof (Elf32_External_Rela);
6162     }
6163
6164   return TRUE;
6165 }
6166
6167 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
6168    read-only sections.  */
6169
6170 static bfd_boolean
6171 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
6172 {
6173   if (h->root.type == bfd_link_hash_indirect)
6174     return TRUE;
6175
6176   if (readonly_dynrelocs (h))
6177     {
6178       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
6179
6180       /* Not an error, just cut short the traversal.  */
6181       return FALSE;
6182     }
6183   return TRUE;
6184 }
6185
6186 static const unsigned char glink_eh_frame_cie[] =
6187 {
6188   0, 0, 0, 16,                          /* length.  */
6189   0, 0, 0, 0,                           /* id.  */
6190   1,                                    /* CIE version.  */
6191   'z', 'R', 0,                          /* Augmentation string.  */
6192   4,                                    /* Code alignment.  */
6193   0x7c,                                 /* Data alignment.  */
6194   65,                                   /* RA reg.  */
6195   1,                                    /* Augmentation size.  */
6196   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
6197   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
6198 };
6199
6200 /* Set the sizes of the dynamic sections.  */
6201
6202 static bfd_boolean
6203 ppc_elf_size_dynamic_sections (bfd *output_bfd,
6204                                struct bfd_link_info *info)
6205 {
6206   struct ppc_elf_link_hash_table *htab;
6207   asection *s;
6208   bfd_boolean relocs;
6209   bfd *ibfd;
6210
6211 #ifdef DEBUG
6212   fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
6213 #endif
6214
6215   htab = ppc_elf_hash_table (info);
6216   BFD_ASSERT (htab->elf.dynobj != NULL);
6217
6218   if (elf_hash_table (info)->dynamic_sections_created)
6219     {
6220       /* Set the contents of the .interp section to the interpreter.  */
6221       if (bfd_link_executable (info) && !info->nointerp)
6222         {
6223           s = bfd_get_linker_section (htab->elf.dynobj, ".interp");
6224           BFD_ASSERT (s != NULL);
6225           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6226           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6227         }
6228     }
6229
6230   if (htab->plt_type == PLT_OLD)
6231     htab->got_header_size = 16;
6232   else if (htab->plt_type == PLT_NEW)
6233     htab->got_header_size = 12;
6234
6235   /* Set up .got offsets for local syms, and space for local dynamic
6236      relocs.  */
6237   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6238     {
6239       bfd_signed_vma *local_got;
6240       bfd_signed_vma *end_local_got;
6241       struct plt_entry **local_plt;
6242       struct plt_entry **end_local_plt;
6243       char *lgot_masks;
6244       bfd_size_type locsymcount;
6245       Elf_Internal_Shdr *symtab_hdr;
6246
6247       if (!is_ppc_elf (ibfd))
6248         continue;
6249
6250       for (s = ibfd->sections; s != NULL; s = s->next)
6251         {
6252           struct ppc_dyn_relocs *p;
6253
6254           for (p = ((struct ppc_dyn_relocs *)
6255                     elf_section_data (s)->local_dynrel);
6256                p != NULL;
6257                p = p->next)
6258             {
6259               if (!bfd_is_abs_section (p->sec)
6260                   && bfd_is_abs_section (p->sec->output_section))
6261                 {
6262                   /* Input section has been discarded, either because
6263                      it is a copy of a linkonce section or due to
6264                      linker script /DISCARD/, so we'll be discarding
6265                      the relocs too.  */
6266                 }
6267               else if (htab->is_vxworks
6268                        && strcmp (p->sec->output_section->name,
6269                                   ".tls_vars") == 0)
6270                 {
6271                   /* Relocations in vxworks .tls_vars sections are
6272                      handled specially by the loader.  */
6273                 }
6274               else if (p->count != 0)
6275                 {
6276                   asection *sreloc = elf_section_data (p->sec)->sreloc;
6277                   if (p->ifunc)
6278                     sreloc = htab->reliplt;
6279                   sreloc->size += p->count * sizeof (Elf32_External_Rela);
6280                   if ((p->sec->output_section->flags
6281                        & (SEC_READONLY | SEC_ALLOC))
6282                       == (SEC_READONLY | SEC_ALLOC))
6283                     info->flags |= DF_TEXTREL;
6284                 }
6285             }
6286         }
6287
6288       local_got = elf_local_got_refcounts (ibfd);
6289       if (!local_got)
6290         continue;
6291
6292       symtab_hdr = &elf_symtab_hdr (ibfd);
6293       locsymcount = symtab_hdr->sh_info;
6294       end_local_got = local_got + locsymcount;
6295       local_plt = (struct plt_entry **) end_local_got;
6296       end_local_plt = local_plt + locsymcount;
6297       lgot_masks = (char *) end_local_plt;
6298
6299       for (; local_got < end_local_got; ++local_got, ++lgot_masks)
6300         if (*local_got > 0)
6301           {
6302             unsigned int need = 0;
6303             if ((*lgot_masks & TLS_TLS) != 0)
6304               {
6305                 if ((*lgot_masks & TLS_GD) != 0)
6306                   need += 8;
6307                 if ((*lgot_masks & TLS_LD) != 0)
6308                   htab->tlsld_got.refcount += 1;
6309                 if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
6310                   need += 4;
6311                 if ((*lgot_masks & TLS_DTPREL) != 0)
6312                   need += 4;
6313               }
6314             else
6315               need += 4;
6316             if (need == 0)
6317               *local_got = (bfd_vma) -1;
6318             else
6319               {
6320                 *local_got = allocate_got (htab, need);
6321                 if (bfd_link_pic (info))
6322                   {
6323                     asection *srel = htab->relgot;
6324                     if ((*lgot_masks & PLT_IFUNC) != 0)
6325                       srel = htab->reliplt;
6326                     srel->size += need * (sizeof (Elf32_External_Rela) / 4);
6327                   }
6328               }
6329           }
6330         else
6331           *local_got = (bfd_vma) -1;
6332
6333       if (htab->is_vxworks)
6334         continue;
6335
6336       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
6337       for (; local_plt < end_local_plt; ++local_plt)
6338         {
6339           struct plt_entry *ent;
6340           bfd_boolean doneone = FALSE;
6341           bfd_vma plt_offset = 0, glink_offset = 0;
6342
6343           for (ent = *local_plt; ent != NULL; ent = ent->next)
6344             if (ent->plt.refcount > 0)
6345               {
6346                 s = htab->iplt;
6347
6348                 if (!doneone)
6349                   {
6350                     plt_offset = s->size;
6351                     s->size += 4;
6352                   }
6353                 ent->plt.offset = plt_offset;
6354
6355                 s = htab->glink;
6356                 if (!doneone || bfd_link_pic (info))
6357                   {
6358                     glink_offset = s->size;
6359                     s->size += GLINK_ENTRY_SIZE;
6360                   }
6361                 ent->glink_offset = glink_offset;
6362
6363                 if (!doneone)
6364                   {
6365                     htab->reliplt->size += sizeof (Elf32_External_Rela);
6366                     doneone = TRUE;
6367                   }
6368               }
6369             else
6370               ent->plt.offset = (bfd_vma) -1;
6371         }
6372     }
6373
6374   /* Allocate space for global sym dynamic relocs.  */
6375   elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
6376
6377   if (htab->tlsld_got.refcount > 0)
6378     {
6379       htab->tlsld_got.offset = allocate_got (htab, 8);
6380       if (bfd_link_pic (info))
6381         htab->relgot->size += sizeof (Elf32_External_Rela);
6382     }
6383   else
6384     htab->tlsld_got.offset = (bfd_vma) -1;
6385
6386   if (htab->got != NULL && htab->plt_type != PLT_VXWORKS)
6387     {
6388       unsigned int g_o_t = 32768;
6389
6390       /* If we haven't allocated the header, do so now.  When we get here,
6391          for old plt/got the got size will be 0 to 32764 (not allocated),
6392          or 32780 to 65536 (header allocated).  For new plt/got, the
6393          corresponding ranges are 0 to 32768 and 32780 to 65536.  */
6394       if (htab->got->size <= 32768)
6395         {
6396           g_o_t = htab->got->size;
6397           if (htab->plt_type == PLT_OLD)
6398             g_o_t += 4;
6399           htab->got->size += htab->got_header_size;
6400         }
6401
6402       htab->elf.hgot->root.u.def.value = g_o_t;
6403     }
6404   if (bfd_link_pic (info))
6405     {
6406       struct elf_link_hash_entry *sda = htab->sdata[0].sym;
6407
6408       sda->root.u.def.section = htab->elf.hgot->root.u.def.section;
6409       sda->root.u.def.value = htab->elf.hgot->root.u.def.value;
6410     }
6411   if (info->emitrelocations)
6412     {
6413       struct elf_link_hash_entry *sda = htab->sdata[0].sym;
6414
6415       if (sda != NULL && sda->ref_regular)
6416         sda->root.u.def.section->flags |= SEC_KEEP;
6417       sda = htab->sdata[1].sym;
6418       if (sda != NULL && sda->ref_regular)
6419         sda->root.u.def.section->flags |= SEC_KEEP;
6420     }
6421
6422   if (htab->glink != NULL
6423       && htab->glink->size != 0
6424       && htab->elf.dynamic_sections_created)
6425     {
6426       htab->glink_pltresolve = htab->glink->size;
6427       /* Space for the branch table.  */
6428       htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4;
6429       /* Pad out to align the start of PLTresolve.  */
6430       htab->glink->size += -htab->glink->size & (htab->params->ppc476_workaround
6431                                                  ? 63 : 15);
6432       htab->glink->size += GLINK_PLTRESOLVE;
6433
6434       if (htab->params->emit_stub_syms)
6435         {
6436           struct elf_link_hash_entry *sh;
6437           sh = elf_link_hash_lookup (&htab->elf, "__glink",
6438                                      TRUE, FALSE, FALSE);
6439           if (sh == NULL)
6440             return FALSE;
6441           if (sh->root.type == bfd_link_hash_new)
6442             {
6443               sh->root.type = bfd_link_hash_defined;
6444               sh->root.u.def.section = htab->glink;
6445               sh->root.u.def.value = htab->glink_pltresolve;
6446               sh->ref_regular = 1;
6447               sh->def_regular = 1;
6448               sh->ref_regular_nonweak = 1;
6449               sh->forced_local = 1;
6450               sh->non_elf = 0;
6451               sh->root.linker_def = 1;
6452             }
6453           sh = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
6454                                      TRUE, FALSE, FALSE);
6455           if (sh == NULL)
6456             return FALSE;
6457           if (sh->root.type == bfd_link_hash_new)
6458             {
6459               sh->root.type = bfd_link_hash_defined;
6460               sh->root.u.def.section = htab->glink;
6461               sh->root.u.def.value = htab->glink->size - GLINK_PLTRESOLVE;
6462               sh->ref_regular = 1;
6463               sh->def_regular = 1;
6464               sh->ref_regular_nonweak = 1;
6465               sh->forced_local = 1;
6466               sh->non_elf = 0;
6467               sh->root.linker_def = 1;
6468             }
6469         }
6470     }
6471
6472   if (htab->glink != NULL
6473       && htab->glink->size != 0
6474       && htab->glink_eh_frame != NULL
6475       && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
6476       && _bfd_elf_eh_frame_present (info))
6477     {
6478       s = htab->glink_eh_frame;
6479       s->size = sizeof (glink_eh_frame_cie) + 20;
6480       if (bfd_link_pic (info))
6481         {
6482           s->size += 4;
6483           if (htab->glink->size - GLINK_PLTRESOLVE + 8 >= 256)
6484             s->size += 4;
6485         }
6486     }
6487
6488   /* We've now determined the sizes of the various dynamic sections.
6489      Allocate memory for them.  */
6490   relocs = FALSE;
6491   for (s = htab->elf.dynobj->sections; s != NULL; s = s->next)
6492     {
6493       bfd_boolean strip_section = TRUE;
6494
6495       if ((s->flags & SEC_LINKER_CREATED) == 0)
6496         continue;
6497
6498       if (s == htab->plt
6499           || s == htab->got)
6500         {
6501           /* We'd like to strip these sections if they aren't needed, but if
6502              we've exported dynamic symbols from them we must leave them.
6503              It's too late to tell BFD to get rid of the symbols.  */
6504           if (htab->elf.hplt != NULL)
6505             strip_section = FALSE;
6506           /* Strip this section if we don't need it; see the
6507              comment below.  */
6508         }
6509       else if (s == htab->iplt
6510                || s == htab->glink
6511                || s == htab->glink_eh_frame
6512                || s == htab->sgotplt
6513                || s == htab->sbss
6514                || s == htab->dynbss
6515                || s == htab->dynsbss)
6516         {
6517           /* Strip these too.  */
6518         }
6519       else if (s == htab->sdata[0].section
6520                || s == htab->sdata[1].section)
6521         {
6522           strip_section = (s->flags & SEC_KEEP) == 0;
6523         }
6524       else if (CONST_STRNEQ (bfd_get_section_name (htab->elf.dynobj, s),
6525                              ".rela"))
6526         {
6527           if (s->size != 0)
6528             {
6529               /* Remember whether there are any relocation sections.  */
6530               relocs = TRUE;
6531
6532               /* We use the reloc_count field as a counter if we need
6533                  to copy relocs into the output file.  */
6534               s->reloc_count = 0;
6535             }
6536         }
6537       else
6538         {
6539           /* It's not one of our sections, so don't allocate space.  */
6540           continue;
6541         }
6542
6543       if (s->size == 0 && strip_section)
6544         {
6545           /* If we don't need this section, strip it from the
6546              output file.  This is mostly to handle .rela.bss and
6547              .rela.plt.  We must create both sections in
6548              create_dynamic_sections, because they must be created
6549              before the linker maps input sections to output
6550              sections.  The linker does that before
6551              adjust_dynamic_symbol is called, and it is that
6552              function which decides whether anything needs to go
6553              into these sections.  */
6554           s->flags |= SEC_EXCLUDE;
6555           continue;
6556         }
6557
6558       if ((s->flags & SEC_HAS_CONTENTS) == 0)
6559         continue;
6560
6561       /* Allocate memory for the section contents.  */
6562       s->contents = bfd_zalloc (htab->elf.dynobj, s->size);
6563       if (s->contents == NULL)
6564         return FALSE;
6565     }
6566
6567   if (htab->elf.dynamic_sections_created)
6568     {
6569       /* Add some entries to the .dynamic section.  We fill in the
6570          values later, in ppc_elf_finish_dynamic_sections, but we
6571          must add the entries now so that we get the correct size for
6572          the .dynamic section.  The DT_DEBUG entry is filled in by the
6573          dynamic linker and used by the debugger.  */
6574 #define add_dynamic_entry(TAG, VAL) \
6575   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6576
6577       if (bfd_link_executable (info))
6578         {
6579           if (!add_dynamic_entry (DT_DEBUG, 0))
6580             return FALSE;
6581         }
6582
6583       if (htab->plt != NULL && htab->plt->size != 0)
6584         {
6585           if (!add_dynamic_entry (DT_PLTGOT, 0)
6586               || !add_dynamic_entry (DT_PLTRELSZ, 0)
6587               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
6588               || !add_dynamic_entry (DT_JMPREL, 0))
6589             return FALSE;
6590         }
6591
6592       if (htab->plt_type == PLT_NEW
6593           && htab->glink != NULL
6594           && htab->glink->size != 0)
6595         {
6596           if (!add_dynamic_entry (DT_PPC_GOT, 0))
6597             return FALSE;
6598           if (!htab->params->no_tls_get_addr_opt
6599               && htab->tls_get_addr != NULL
6600               && htab->tls_get_addr->plt.plist != NULL
6601               && !add_dynamic_entry (DT_PPC_OPT, PPC_OPT_TLS))
6602             return FALSE;
6603         }
6604
6605       if (relocs)
6606         {
6607           if (!add_dynamic_entry (DT_RELA, 0)
6608               || !add_dynamic_entry (DT_RELASZ, 0)
6609               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
6610             return FALSE;
6611         }
6612
6613       /* If any dynamic relocs apply to a read-only section, then we
6614          need a DT_TEXTREL entry.  */
6615       if ((info->flags & DF_TEXTREL) == 0)
6616         elf_link_hash_traverse (elf_hash_table (info), maybe_set_textrel,
6617                                 info);
6618
6619       if ((info->flags & DF_TEXTREL) != 0)
6620         {
6621           if (!add_dynamic_entry (DT_TEXTREL, 0))
6622             return FALSE;
6623         }
6624       if (htab->is_vxworks
6625           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
6626         return FALSE;
6627    }
6628 #undef add_dynamic_entry
6629
6630   if (htab->glink_eh_frame != NULL
6631       && htab->glink_eh_frame->contents != NULL)
6632     {
6633       unsigned char *p = htab->glink_eh_frame->contents;
6634       bfd_vma val;
6635
6636       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
6637       /* CIE length (rewrite in case little-endian).  */
6638       bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
6639       p += sizeof (glink_eh_frame_cie);
6640       /* FDE length.  */
6641       val = htab->glink_eh_frame->size - 4 - sizeof (glink_eh_frame_cie);
6642       bfd_put_32 (htab->elf.dynobj, val, p);
6643       p += 4;
6644       /* CIE pointer.  */
6645       val = p - htab->glink_eh_frame->contents;
6646       bfd_put_32 (htab->elf.dynobj, val, p);
6647       p += 4;
6648       /* Offset to .glink.  Set later.  */
6649       p += 4;
6650       /* .glink size.  */
6651       bfd_put_32 (htab->elf.dynobj, htab->glink->size, p);
6652       p += 4;
6653       /* Augmentation.  */
6654       p += 1;
6655
6656       if (bfd_link_pic (info)
6657           && htab->elf.dynamic_sections_created)
6658         {
6659           bfd_vma adv = (htab->glink->size - GLINK_PLTRESOLVE + 8) >> 2;
6660           if (adv < 64)
6661             *p++ = DW_CFA_advance_loc + adv;
6662           else if (adv < 256)
6663             {
6664               *p++ = DW_CFA_advance_loc1;
6665               *p++ = adv;
6666             }
6667           else if (adv < 65536)
6668             {
6669               *p++ = DW_CFA_advance_loc2;
6670               bfd_put_16 (htab->elf.dynobj, adv, p);
6671               p += 2;
6672             }
6673           else
6674             {
6675               *p++ = DW_CFA_advance_loc4;
6676               bfd_put_32 (htab->elf.dynobj, adv, p);
6677               p += 4;
6678             }
6679           *p++ = DW_CFA_register;
6680           *p++ = 65;
6681           p++;
6682           *p++ = DW_CFA_advance_loc + 4;
6683           *p++ = DW_CFA_restore_extended;
6684           *p++ = 65;
6685         }
6686       BFD_ASSERT ((bfd_vma) ((p + 3 - htab->glink_eh_frame->contents) & -4)
6687                   == htab->glink_eh_frame->size);
6688     }
6689
6690   return TRUE;
6691 }
6692
6693 /* Arrange to have _SDA_BASE_ or _SDA2_BASE_ stripped from the output
6694    if it looks like nothing is using them.  */
6695
6696 static void
6697 maybe_strip_sdasym (bfd *output_bfd, elf_linker_section_t *lsect)
6698 {
6699   struct elf_link_hash_entry *sda = lsect->sym;
6700
6701   if (sda != NULL && !sda->ref_regular && sda->dynindx == -1)
6702     {
6703       asection *s;
6704
6705       s = bfd_get_section_by_name (output_bfd, lsect->name);
6706       if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
6707         {
6708           s = bfd_get_section_by_name (output_bfd, lsect->bss_name);
6709           if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
6710             {
6711               sda->def_regular = 0;
6712               /* This is somewhat magic.  See elf_link_output_extsym.  */
6713               sda->ref_dynamic = 1;
6714               sda->forced_local = 0;
6715             }
6716         }
6717     }
6718 }
6719
6720 void
6721 ppc_elf_maybe_strip_sdata_syms (struct bfd_link_info *info)
6722 {
6723   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
6724
6725   if (htab != NULL)
6726     {
6727       maybe_strip_sdasym (info->output_bfd, &htab->sdata[0]);
6728       maybe_strip_sdasym (info->output_bfd, &htab->sdata[1]);
6729     }
6730 }
6731
6732
6733 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
6734
6735 static bfd_boolean
6736 ppc_elf_hash_symbol (struct elf_link_hash_entry *h)
6737 {
6738   if (h->plt.plist != NULL
6739       && !h->def_regular
6740       && (!h->pointer_equality_needed
6741           || !h->ref_regular_nonweak))
6742     return FALSE;
6743
6744   return _bfd_elf_hash_symbol (h);
6745 }
6746 \f
6747 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
6748
6749 /* Relaxation trampolines.  r12 is available for clobbering (r11, is
6750    used for some functions that are allowed to break the ABI).  */
6751 static const int shared_stub_entry[] =
6752   {
6753     0x7c0802a6, /* mflr 0 */
6754     0x429f0005, /* bcl 20, 31, .Lxxx */
6755     0x7d8802a6, /* mflr 12 */
6756     0x3d8c0000, /* addis 12, 12, (xxx-.Lxxx)@ha */
6757     0x398c0000, /* addi 12, 12, (xxx-.Lxxx)@l */
6758     0x7c0803a6, /* mtlr 0 */
6759     0x7d8903a6, /* mtctr 12 */
6760     0x4e800420, /* bctr */
6761   };
6762
6763 static const int stub_entry[] =
6764   {
6765     0x3d800000, /* lis 12,xxx@ha */
6766     0x398c0000, /* addi 12,12,xxx@l */
6767     0x7d8903a6, /* mtctr 12 */
6768     0x4e800420, /* bctr */
6769   };
6770
6771 struct ppc_elf_relax_info
6772 {
6773   unsigned int workaround_size;
6774   unsigned int picfixup_size;
6775 };
6776
6777 /* This function implements long branch trampolines, and the ppc476
6778    icache bug workaround.  Any section needing trampolines or patch
6779    space for the workaround has its size extended so that we can
6780    add trampolines at the end of the section.  */
6781
6782 static bfd_boolean
6783 ppc_elf_relax_section (bfd *abfd,
6784                        asection *isec,
6785                        struct bfd_link_info *link_info,
6786                        bfd_boolean *again)
6787 {
6788   struct one_branch_fixup
6789   {
6790     struct one_branch_fixup *next;
6791     asection *tsec;
6792     /* Final link, can use the symbol offset.  For a
6793        relocatable link we use the symbol's index.  */
6794     bfd_vma toff;
6795     bfd_vma trampoff;
6796   };
6797
6798   Elf_Internal_Shdr *symtab_hdr;
6799   bfd_byte *contents = NULL;
6800   Elf_Internal_Sym *isymbuf = NULL;
6801   Elf_Internal_Rela *internal_relocs = NULL;
6802   Elf_Internal_Rela *irel, *irelend = NULL;
6803   struct one_branch_fixup *branch_fixups = NULL;
6804   struct ppc_elf_relax_info *relax_info = NULL;
6805   unsigned changes = 0;
6806   bfd_boolean workaround_change;
6807   struct ppc_elf_link_hash_table *htab;
6808   bfd_size_type trampbase, trampoff, newsize, picfixup_size;
6809   asection *got2;
6810   bfd_boolean maybe_pasted;
6811
6812   *again = FALSE;
6813
6814   /* No need to do anything with non-alloc or non-code sections.  */
6815   if ((isec->flags & SEC_ALLOC) == 0
6816       || (isec->flags & SEC_CODE) == 0
6817       || (isec->flags & SEC_LINKER_CREATED) != 0
6818       || isec->size < 4)
6819     return TRUE;
6820
6821   /* We cannot represent the required PIC relocs in the output, so don't
6822      do anything.  The linker doesn't support mixing -shared and -r
6823      anyway.  */
6824   if (bfd_link_relocatable (link_info) && bfd_link_pic (link_info))
6825     return TRUE;
6826
6827   htab = ppc_elf_hash_table (link_info);
6828   if (htab == NULL)
6829     return TRUE;
6830
6831   isec->size = (isec->size + 3) & -4;
6832   if (isec->rawsize == 0)
6833     isec->rawsize = isec->size;
6834   trampbase = isec->size;
6835
6836   BFD_ASSERT (isec->sec_info_type == SEC_INFO_TYPE_NONE
6837               || isec->sec_info_type == SEC_INFO_TYPE_TARGET);
6838   isec->sec_info_type = SEC_INFO_TYPE_TARGET;
6839
6840   if (htab->params->ppc476_workaround
6841       || htab->params->pic_fixup > 0)
6842     {
6843       if (elf_section_data (isec)->sec_info == NULL)
6844         {
6845           elf_section_data (isec)->sec_info
6846             = bfd_zalloc (abfd, sizeof (struct ppc_elf_relax_info));
6847           if (elf_section_data (isec)->sec_info == NULL)
6848             return FALSE;
6849         }
6850       relax_info = elf_section_data (isec)->sec_info;
6851       trampbase -= relax_info->workaround_size;
6852     }
6853
6854   maybe_pasted = (strcmp (isec->output_section->name, ".init") == 0
6855                   || strcmp (isec->output_section->name, ".fini") == 0);
6856   /* Space for a branch around any trampolines.  */
6857   trampoff = trampbase;
6858   if (maybe_pasted && trampbase == isec->rawsize)
6859     trampoff += 4;
6860
6861   symtab_hdr = &elf_symtab_hdr (abfd);
6862   picfixup_size = 0;
6863   if (htab->params->branch_trampolines
6864       || htab->params->pic_fixup > 0)
6865     {
6866       /* Get a copy of the native relocations.  */
6867       if (isec->reloc_count != 0)
6868         {
6869           internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL,
6870                                                        link_info->keep_memory);
6871           if (internal_relocs == NULL)
6872             goto error_return;
6873         }
6874
6875       got2 = bfd_get_section_by_name (abfd, ".got2");
6876
6877       irelend = internal_relocs + isec->reloc_count;
6878       for (irel = internal_relocs; irel < irelend; irel++)
6879         {
6880           unsigned long r_type = ELF32_R_TYPE (irel->r_info);
6881           bfd_vma toff, roff;
6882           asection *tsec;
6883           struct one_branch_fixup *f;
6884           size_t insn_offset = 0;
6885           bfd_vma max_branch_offset = 0, val;
6886           bfd_byte *hit_addr;
6887           unsigned long t0;
6888           struct elf_link_hash_entry *h;
6889           struct plt_entry **plist;
6890           unsigned char sym_type;
6891
6892           switch (r_type)
6893             {
6894             case R_PPC_REL24:
6895             case R_PPC_LOCAL24PC:
6896             case R_PPC_PLTREL24:
6897               max_branch_offset = 1 << 25;
6898               break;
6899
6900             case R_PPC_REL14:
6901             case R_PPC_REL14_BRTAKEN:
6902             case R_PPC_REL14_BRNTAKEN:
6903               max_branch_offset = 1 << 15;
6904               break;
6905
6906             case R_PPC_ADDR16_HA:
6907               if (htab->params->pic_fixup > 0)
6908                 break;
6909               continue;
6910
6911             default:
6912               continue;
6913             }
6914
6915           /* Get the value of the symbol referred to by the reloc.  */
6916           h = NULL;
6917           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6918             {
6919               /* A local symbol.  */
6920               Elf_Internal_Sym *isym;
6921
6922               /* Read this BFD's local symbols.  */
6923               if (isymbuf == NULL)
6924                 {
6925                   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6926                   if (isymbuf == NULL)
6927                     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
6928                                                     symtab_hdr->sh_info, 0,
6929                                                     NULL, NULL, NULL);
6930                   if (isymbuf == 0)
6931                     goto error_return;
6932                 }
6933               isym = isymbuf + ELF32_R_SYM (irel->r_info);
6934               if (isym->st_shndx == SHN_UNDEF)
6935                 tsec = bfd_und_section_ptr;
6936               else if (isym->st_shndx == SHN_ABS)
6937                 tsec = bfd_abs_section_ptr;
6938               else if (isym->st_shndx == SHN_COMMON)
6939                 tsec = bfd_com_section_ptr;
6940               else
6941                 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6942
6943               toff = isym->st_value;
6944               sym_type = ELF_ST_TYPE (isym->st_info);
6945             }
6946           else
6947             {
6948               /* Global symbol handling.  */
6949               unsigned long indx;
6950
6951               indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6952               h = elf_sym_hashes (abfd)[indx];
6953
6954               while (h->root.type == bfd_link_hash_indirect
6955                      || h->root.type == bfd_link_hash_warning)
6956                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6957
6958               if (h->root.type == bfd_link_hash_defined
6959                   || h->root.type == bfd_link_hash_defweak)
6960                 {
6961                   tsec = h->root.u.def.section;
6962                   toff = h->root.u.def.value;
6963                 }
6964               else if (h->root.type == bfd_link_hash_undefined
6965                        || h->root.type == bfd_link_hash_undefweak)
6966                 {
6967                   tsec = bfd_und_section_ptr;
6968                   toff = bfd_link_relocatable (link_info) ? indx : 0;
6969                 }
6970               else
6971                 continue;
6972
6973               /* If this branch is to __tls_get_addr then we may later
6974                  optimise away the call.  We won't be needing a long-
6975                  branch stub in that case.  */
6976               if (bfd_link_executable (link_info)
6977                   && h == htab->tls_get_addr
6978                   && irel != internal_relocs)
6979                 {
6980                   unsigned long t_symndx = ELF32_R_SYM (irel[-1].r_info);
6981                   unsigned long t_rtype = ELF32_R_TYPE (irel[-1].r_info);
6982                   unsigned int tls_mask = 0;
6983
6984                   /* The previous reloc should be one of R_PPC_TLSGD or
6985                      R_PPC_TLSLD, or for older object files, a reloc
6986                      on the __tls_get_addr arg setup insn.  Get tls
6987                      mask bits from the symbol on that reloc.  */
6988                   if (t_symndx < symtab_hdr->sh_info)
6989                     {
6990                       bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
6991
6992                       if (local_got_offsets != NULL)
6993                         {
6994                           struct plt_entry **local_plt = (struct plt_entry **)
6995                             (local_got_offsets + symtab_hdr->sh_info);
6996                           char *lgot_masks = (char *)
6997                             (local_plt + symtab_hdr->sh_info);
6998                           tls_mask = lgot_masks[t_symndx];
6999                         }
7000                     }
7001                   else
7002                     {
7003                       struct elf_link_hash_entry *th
7004                         = elf_sym_hashes (abfd)[t_symndx - symtab_hdr->sh_info];
7005
7006                       while (th->root.type == bfd_link_hash_indirect
7007                              || th->root.type == bfd_link_hash_warning)
7008                         th = (struct elf_link_hash_entry *) th->root.u.i.link;
7009
7010                       tls_mask
7011                         = ((struct ppc_elf_link_hash_entry *) th)->tls_mask;
7012                     }
7013
7014                   /* The mask bits tell us if the call will be
7015                      optimised away.  */
7016                   if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
7017                       && (t_rtype == R_PPC_TLSGD
7018                           || t_rtype == R_PPC_GOT_TLSGD16
7019                           || t_rtype == R_PPC_GOT_TLSGD16_LO))
7020                     continue;
7021                   if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
7022                       && (t_rtype == R_PPC_TLSLD
7023                           || t_rtype == R_PPC_GOT_TLSLD16
7024                           || t_rtype == R_PPC_GOT_TLSLD16_LO))
7025                     continue;
7026                 }
7027
7028               sym_type = h->type;
7029             }
7030
7031           if (r_type == R_PPC_ADDR16_HA)
7032             {
7033               if (h != NULL
7034                   && !h->def_regular
7035                   && h->protected_def
7036                   && ppc_elf_hash_entry (h)->has_addr16_ha
7037                   && ppc_elf_hash_entry (h)->has_addr16_lo)
7038                 picfixup_size += 12;
7039               continue;
7040             }
7041
7042           /* The condition here under which we call find_plt_ent must
7043              match that in relocate_section.  If we call find_plt_ent here
7044              but not in relocate_section, or vice versa, then the branch
7045              destination used here may be incorrect.  */
7046           plist = NULL;
7047           if (h != NULL)
7048             {
7049               /* We know is_branch_reloc (r_type) is true.  */
7050               if (h->type == STT_GNU_IFUNC
7051                   || r_type == R_PPC_PLTREL24)
7052                 plist = &h->plt.plist;
7053             }
7054           else if (sym_type == STT_GNU_IFUNC
7055                    && elf_local_got_offsets (abfd) != NULL)
7056             {
7057               bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
7058               struct plt_entry **local_plt = (struct plt_entry **)
7059                 (local_got_offsets + symtab_hdr->sh_info);
7060               plist = local_plt + ELF32_R_SYM (irel->r_info);
7061             }
7062           if (plist != NULL)
7063             {
7064               bfd_vma addend = 0;
7065               struct plt_entry *ent;
7066
7067               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (link_info))
7068                 addend = irel->r_addend;
7069               ent = find_plt_ent (plist, got2, addend);
7070               if (ent != NULL)
7071                 {
7072                   if (htab->plt_type == PLT_NEW
7073                       || h == NULL
7074                       || !htab->elf.dynamic_sections_created
7075                       || h->dynindx == -1)
7076                     {
7077                       tsec = htab->glink;
7078                       toff = ent->glink_offset;
7079                     }
7080                   else
7081                     {
7082                       tsec = htab->plt;
7083                       toff = ent->plt.offset;
7084                     }
7085                 }
7086             }
7087
7088           /* If the branch and target are in the same section, you have
7089              no hope of adding stubs.  We'll error out later should the
7090              branch overflow.  */
7091           if (tsec == isec)
7092             continue;
7093
7094           /* There probably isn't any reason to handle symbols in
7095              SEC_MERGE sections;  SEC_MERGE doesn't seem a likely
7096              attribute for a code section, and we are only looking at
7097              branches.  However, implement it correctly here as a
7098              reference for other target relax_section functions.  */
7099           if (0 && tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
7100             {
7101               /* At this stage in linking, no SEC_MERGE symbol has been
7102                  adjusted, so all references to such symbols need to be
7103                  passed through _bfd_merged_section_offset.  (Later, in
7104                  relocate_section, all SEC_MERGE symbols *except* for
7105                  section symbols have been adjusted.)
7106
7107                  gas may reduce relocations against symbols in SEC_MERGE
7108                  sections to a relocation against the section symbol when
7109                  the original addend was zero.  When the reloc is against
7110                  a section symbol we should include the addend in the
7111                  offset passed to _bfd_merged_section_offset, since the
7112                  location of interest is the original symbol.  On the
7113                  other hand, an access to "sym+addend" where "sym" is not
7114                  a section symbol should not include the addend;  Such an
7115                  access is presumed to be an offset from "sym";  The
7116                  location of interest is just "sym".  */
7117               if (sym_type == STT_SECTION)
7118                 toff += irel->r_addend;
7119
7120               toff
7121                 = _bfd_merged_section_offset (abfd, &tsec,
7122                                               elf_section_data (tsec)->sec_info,
7123                                               toff);
7124
7125               if (sym_type != STT_SECTION)
7126                 toff += irel->r_addend;
7127             }
7128           /* PLTREL24 addends are special.  */
7129           else if (r_type != R_PPC_PLTREL24)
7130             toff += irel->r_addend;
7131
7132           /* Attempted -shared link of non-pic code loses.  */
7133           if ((!bfd_link_relocatable (link_info)
7134                && tsec == bfd_und_section_ptr)
7135               || tsec->output_section == NULL
7136               || (tsec->owner != NULL
7137                   && (tsec->owner->flags & BFD_PLUGIN) != 0))
7138             continue;
7139
7140           roff = irel->r_offset;
7141
7142           /* If the branch is in range, no need to do anything.  */
7143           if (tsec != bfd_und_section_ptr
7144               && (!bfd_link_relocatable (link_info)
7145                   /* A relocatable link may have sections moved during
7146                      final link, so do not presume they remain in range.  */
7147                   || tsec->output_section == isec->output_section))
7148             {
7149               bfd_vma symaddr, reladdr;
7150
7151               symaddr = tsec->output_section->vma + tsec->output_offset + toff;
7152               reladdr = isec->output_section->vma + isec->output_offset + roff;
7153               if (symaddr - reladdr + max_branch_offset
7154                   < 2 * max_branch_offset)
7155                 continue;
7156             }
7157
7158           /* Look for an existing fixup to this address.  */
7159           for (f = branch_fixups; f ; f = f->next)
7160             if (f->tsec == tsec && f->toff == toff)
7161               break;
7162
7163           if (f == NULL)
7164             {
7165               size_t size;
7166               unsigned long stub_rtype;
7167
7168               val = trampoff - roff;
7169               if (val >= max_branch_offset)
7170                 /* Oh dear, we can't reach a trampoline.  Don't try to add
7171                    one.  We'll report an error later.  */
7172                 continue;
7173
7174               if (bfd_link_pic (link_info))
7175                 {
7176                   size = 4 * ARRAY_SIZE (shared_stub_entry);
7177                   insn_offset = 12;
7178                 }
7179               else
7180                 {
7181                   size = 4 * ARRAY_SIZE (stub_entry);
7182                   insn_offset = 0;
7183                 }
7184               stub_rtype = R_PPC_RELAX;
7185               if (tsec == htab->plt
7186                   || tsec == htab->glink)
7187                 {
7188                   stub_rtype = R_PPC_RELAX_PLT;
7189                   if (r_type == R_PPC_PLTREL24)
7190                     stub_rtype = R_PPC_RELAX_PLTREL24;
7191                 }
7192
7193               /* Hijack the old relocation.  Since we need two
7194                  relocations for this use a "composite" reloc.  */
7195               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7196                                            stub_rtype);
7197               irel->r_offset = trampoff + insn_offset;
7198               if (r_type == R_PPC_PLTREL24
7199                   && stub_rtype != R_PPC_RELAX_PLTREL24)
7200                 irel->r_addend = 0;
7201
7202               /* Record the fixup so we don't do it again this section.  */
7203               f = bfd_malloc (sizeof (*f));
7204               f->next = branch_fixups;
7205               f->tsec = tsec;
7206               f->toff = toff;
7207               f->trampoff = trampoff;
7208               branch_fixups = f;
7209
7210               trampoff += size;
7211               changes++;
7212             }
7213           else
7214             {
7215               val = f->trampoff - roff;
7216               if (val >= max_branch_offset)
7217                 continue;
7218
7219               /* Nop out the reloc, since we're finalizing things here.  */
7220               irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
7221             }
7222
7223           /* Get the section contents.  */
7224           if (contents == NULL)
7225             {
7226               /* Get cached copy if it exists.  */
7227               if (elf_section_data (isec)->this_hdr.contents != NULL)
7228                 contents = elf_section_data (isec)->this_hdr.contents;
7229               /* Go get them off disk.  */
7230               else if (!bfd_malloc_and_get_section (abfd, isec, &contents))
7231                 goto error_return;
7232             }
7233
7234           /* Fix up the existing branch to hit the trampoline.  */
7235           hit_addr = contents + roff;
7236           switch (r_type)
7237             {
7238             case R_PPC_REL24:
7239             case R_PPC_LOCAL24PC:
7240             case R_PPC_PLTREL24:
7241               t0 = bfd_get_32 (abfd, hit_addr);
7242               t0 &= ~0x3fffffc;
7243               t0 |= val & 0x3fffffc;
7244               bfd_put_32 (abfd, t0, hit_addr);
7245               break;
7246
7247             case R_PPC_REL14:
7248             case R_PPC_REL14_BRTAKEN:
7249             case R_PPC_REL14_BRNTAKEN:
7250               t0 = bfd_get_32 (abfd, hit_addr);
7251               t0 &= ~0xfffc;
7252               t0 |= val & 0xfffc;
7253               bfd_put_32 (abfd, t0, hit_addr);
7254               break;
7255             }
7256         }
7257
7258       while (branch_fixups != NULL)
7259         {
7260           struct one_branch_fixup *f = branch_fixups;
7261           branch_fixups = branch_fixups->next;
7262           free (f);
7263         }
7264     }
7265
7266   workaround_change = FALSE;
7267   newsize = trampoff;
7268   if (htab->params->ppc476_workaround
7269       && (!bfd_link_relocatable (link_info)
7270           || isec->output_section->alignment_power >= htab->params->pagesize_p2))
7271     {
7272       bfd_vma addr, end_addr;
7273       unsigned int crossings;
7274       bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
7275
7276       addr = isec->output_section->vma + isec->output_offset;
7277       end_addr = addr + trampoff;
7278       addr &= -pagesize;
7279       crossings = ((end_addr & -pagesize) - addr) >> htab->params->pagesize_p2;
7280       if (crossings != 0)
7281         {
7282           /* Keep space aligned, to ensure the patch code itself does
7283              not cross a page.  Don't decrease size calculated on a
7284              previous pass as otherwise we might never settle on a layout.  */
7285           newsize = 15 - ((end_addr - 1) & 15);
7286           newsize += crossings * 16;
7287           if (relax_info->workaround_size < newsize)
7288             {
7289               relax_info->workaround_size = newsize;
7290               workaround_change = TRUE;
7291             }
7292           /* Ensure relocate_section is called.  */
7293           isec->flags |= SEC_RELOC;
7294         }
7295       newsize = trampoff + relax_info->workaround_size;
7296     }
7297
7298   if (htab->params->pic_fixup > 0)
7299     {
7300       picfixup_size -= relax_info->picfixup_size;
7301       if (picfixup_size != 0)
7302         relax_info->picfixup_size += picfixup_size;
7303       newsize += relax_info->picfixup_size;
7304     }
7305
7306   if (changes != 0 || picfixup_size != 0 || workaround_change)
7307     isec->size = newsize;
7308
7309   if (isymbuf != NULL
7310       && symtab_hdr->contents != (unsigned char *) isymbuf)
7311     {
7312       if (! link_info->keep_memory)
7313         free (isymbuf);
7314       else
7315         {
7316           /* Cache the symbols for elf_link_input_bfd.  */
7317           symtab_hdr->contents = (unsigned char *) isymbuf;
7318         }
7319     }
7320
7321   if (contents != NULL
7322       && elf_section_data (isec)->this_hdr.contents != contents)
7323     {
7324       if (!changes && !link_info->keep_memory)
7325         free (contents);
7326       else
7327         {
7328           /* Cache the section contents for elf_link_input_bfd.  */
7329           elf_section_data (isec)->this_hdr.contents = contents;
7330         }
7331     }
7332
7333   changes += picfixup_size;
7334   if (changes != 0)
7335     {
7336       /* Append sufficient NOP relocs so we can write out relocation
7337          information for the trampolines.  */
7338       Elf_Internal_Shdr *rel_hdr;
7339       Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count)
7340                                                   * sizeof (*new_relocs));
7341       unsigned ix;
7342
7343       if (!new_relocs)
7344         goto error_return;
7345       memcpy (new_relocs, internal_relocs,
7346               isec->reloc_count * sizeof (*new_relocs));
7347       for (ix = changes; ix--;)
7348         {
7349           irel = new_relocs + ix + isec->reloc_count;
7350
7351           irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
7352         }
7353       if (internal_relocs != elf_section_data (isec)->relocs)
7354         free (internal_relocs);
7355       elf_section_data (isec)->relocs = new_relocs;
7356       isec->reloc_count += changes;
7357       rel_hdr = _bfd_elf_single_rel_hdr (isec);
7358       rel_hdr->sh_size += changes * rel_hdr->sh_entsize;
7359     }
7360   else if (internal_relocs != NULL
7361            && elf_section_data (isec)->relocs != internal_relocs)
7362     free (internal_relocs);
7363
7364   *again = changes != 0 || workaround_change;
7365   return TRUE;
7366
7367  error_return:
7368   while (branch_fixups != NULL)
7369     {
7370       struct one_branch_fixup *f = branch_fixups;
7371       branch_fixups = branch_fixups->next;
7372       free (f);
7373     }
7374   if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
7375     free (isymbuf);
7376   if (contents != NULL
7377       && elf_section_data (isec)->this_hdr.contents != contents)
7378     free (contents);
7379   if (internal_relocs != NULL
7380       && elf_section_data (isec)->relocs != internal_relocs)
7381     free (internal_relocs);
7382   return FALSE;
7383 }
7384 \f
7385 /* What to do when ld finds relocations against symbols defined in
7386    discarded sections.  */
7387
7388 static unsigned int
7389 ppc_elf_action_discarded (asection *sec)
7390 {
7391   if (strcmp (".fixup", sec->name) == 0)
7392     return 0;
7393
7394   if (strcmp (".got2", sec->name) == 0)
7395     return 0;
7396
7397   return _bfd_elf_default_action_discarded (sec);
7398 }
7399 \f
7400 /* Fill in the address for a pointer generated in a linker section.  */
7401
7402 static bfd_vma
7403 elf_finish_pointer_linker_section (bfd *input_bfd,
7404                                    elf_linker_section_t *lsect,
7405                                    struct elf_link_hash_entry *h,
7406                                    bfd_vma relocation,
7407                                    const Elf_Internal_Rela *rel)
7408 {
7409   elf_linker_section_pointers_t *linker_section_ptr;
7410
7411   BFD_ASSERT (lsect != NULL);
7412
7413   if (h != NULL)
7414     {
7415       /* Handle global symbol.  */
7416       struct ppc_elf_link_hash_entry *eh;
7417
7418       eh = (struct ppc_elf_link_hash_entry *) h;
7419       BFD_ASSERT (eh->elf.def_regular);
7420       linker_section_ptr = eh->linker_section_pointer;
7421     }
7422   else
7423     {
7424       /* Handle local symbol.  */
7425       unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
7426
7427       BFD_ASSERT (is_ppc_elf (input_bfd));
7428       BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
7429       linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx];
7430     }
7431
7432   linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr,
7433                                                         rel->r_addend,
7434                                                         lsect);
7435   BFD_ASSERT (linker_section_ptr != NULL);
7436
7437   /* Offset will always be a multiple of four, so use the bottom bit
7438      as a "written" flag.  */
7439   if ((linker_section_ptr->offset & 1) == 0)
7440     {
7441       bfd_put_32 (lsect->section->owner,
7442                   relocation + linker_section_ptr->addend,
7443                   lsect->section->contents + linker_section_ptr->offset);
7444       linker_section_ptr->offset += 1;
7445     }
7446
7447   relocation = (lsect->section->output_section->vma
7448                 + lsect->section->output_offset
7449                 + linker_section_ptr->offset - 1
7450                 - SYM_VAL (lsect->sym));
7451
7452 #ifdef DEBUG
7453   fprintf (stderr,
7454            "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
7455            lsect->name, (long) relocation, (long) relocation);
7456 #endif
7457
7458   return relocation;
7459 }
7460
7461 #define PPC_LO(v) ((v) & 0xffff)
7462 #define PPC_HI(v) (((v) >> 16) & 0xffff)
7463 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
7464
7465 static void
7466 write_glink_stub (struct plt_entry *ent, asection *plt_sec, unsigned char *p,
7467                   struct bfd_link_info *info)
7468 {
7469   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
7470   bfd *output_bfd = info->output_bfd;
7471   bfd_vma plt;
7472
7473   plt = ((ent->plt.offset & ~1)
7474          + plt_sec->output_section->vma
7475          + plt_sec->output_offset);
7476
7477   if (bfd_link_pic (info))
7478     {
7479       bfd_vma got = 0;
7480
7481       if (ent->addend >= 32768)
7482         got = (ent->addend
7483                + ent->sec->output_section->vma
7484                + ent->sec->output_offset);
7485       else if (htab->elf.hgot != NULL)
7486         got = SYM_VAL (htab->elf.hgot);
7487
7488       plt -= got;
7489
7490       if (plt + 0x8000 < 0x10000)
7491         {
7492           bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p);
7493           p += 4;
7494           bfd_put_32 (output_bfd, MTCTR_11, p);
7495           p += 4;
7496           bfd_put_32 (output_bfd, BCTR, p);
7497           p += 4;
7498           bfd_put_32 (output_bfd, htab->params->ppc476_workaround ? BA : NOP, p);
7499           p += 4;
7500         }
7501       else
7502         {
7503           bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p);
7504           p += 4;
7505           bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
7506           p += 4;
7507           bfd_put_32 (output_bfd, MTCTR_11, p);
7508           p += 4;
7509           bfd_put_32 (output_bfd, BCTR, p);
7510           p += 4;
7511         }
7512     }
7513   else
7514     {
7515       bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p);
7516       p += 4;
7517       bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
7518       p += 4;
7519       bfd_put_32 (output_bfd, MTCTR_11, p);
7520       p += 4;
7521       bfd_put_32 (output_bfd, BCTR, p);
7522       p += 4;
7523     }
7524 }
7525
7526 /* Return true if symbol is defined statically.  */
7527
7528 static bfd_boolean
7529 is_static_defined (struct elf_link_hash_entry *h)
7530 {
7531   return ((h->root.type == bfd_link_hash_defined
7532            || h->root.type == bfd_link_hash_defweak)
7533           && h->root.u.def.section != NULL
7534           && h->root.u.def.section->output_section != NULL);
7535 }
7536
7537 /* If INSN is an opcode that may be used with an @tls operand, return
7538    the transformed insn for TLS optimisation, otherwise return 0.  If
7539    REG is non-zero only match an insn with RB or RA equal to REG.  */
7540
7541 unsigned int
7542 _bfd_elf_ppc_at_tls_transform (unsigned int insn, unsigned int reg)
7543 {
7544   unsigned int rtra;
7545
7546   if ((insn & (0x3f << 26)) != 31 << 26)
7547     return 0;
7548
7549   if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
7550     rtra = insn & ((1 << 26) - (1 << 16));
7551   else if (((insn >> 16) & 0x1f) == reg)
7552     rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
7553   else
7554     return 0;
7555
7556   if ((insn & (0x3ff << 1)) == 266 << 1)
7557     /* add -> addi.  */
7558     insn = 14 << 26;
7559   else if ((insn & (0x1f << 1)) == 23 << 1
7560            && ((insn & (0x1f << 6)) < 14 << 6
7561                || ((insn & (0x1f << 6)) >= 16 << 6
7562                    && (insn & (0x1f << 6)) < 24 << 6)))
7563     /* load and store indexed -> dform.  */
7564     insn = (32 | ((insn >> 6) & 0x1f)) << 26;
7565   else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
7566     /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
7567     insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
7568   else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
7569     /* lwax -> lwa.  */
7570     insn = (58 << 26) | 2;
7571   else
7572     return 0;
7573   insn |= rtra;
7574   return insn;
7575 }
7576
7577 /* If INSN is an opcode that may be used with an @tprel operand, return
7578    the transformed insn for an undefined weak symbol, ie. with the
7579    thread pointer REG operand removed.  Otherwise return 0.  */
7580
7581 unsigned int
7582 _bfd_elf_ppc_at_tprel_transform (unsigned int insn, unsigned int reg)
7583 {
7584   if ((insn & (0x1f << 16)) == reg << 16
7585       && ((insn & (0x3f << 26)) == 14u << 26 /* addi */
7586           || (insn & (0x3f << 26)) == 15u << 26 /* addis */
7587           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
7588           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
7589           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
7590           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
7591           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
7592           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
7593           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
7594           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
7595           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
7596           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
7597           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
7598           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
7599           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
7600           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
7601               && (insn & 3) != 1)
7602           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
7603               && ((insn & 3) == 0 || (insn & 3) == 3))))
7604     {
7605       insn &= ~(0x1f << 16);
7606     }
7607   else if ((insn & (0x1f << 21)) == reg << 21
7608            && ((insn & (0x3e << 26)) == 24u << 26 /* ori, oris */
7609                || (insn & (0x3e << 26)) == 26u << 26 /* xori,xoris */
7610                || (insn & (0x3e << 26)) == 28u << 26 /* andi,andis */))
7611     {
7612       insn &= ~(0x1f << 21);
7613       insn |= (insn & (0x1f << 16)) << 5;
7614       if ((insn & (0x3e << 26)) == 26 << 26 /* xori,xoris */)
7615         insn -= 2 >> 26;  /* convert to ori,oris */
7616     }
7617   else
7618     insn = 0;
7619   return insn;
7620 }
7621
7622 static bfd_boolean
7623 is_insn_ds_form (unsigned int insn)
7624 {
7625   return ((insn & (0x3f << 26)) == 58u << 26 /* ld,ldu,lwa */
7626           || (insn & (0x3f << 26)) == 62u << 26 /* std,stdu,stq */
7627           || (insn & (0x3f << 26)) == 57u << 26 /* lfdp */
7628           || (insn & (0x3f << 26)) == 61u << 26 /* stfdp */);
7629 }
7630
7631 static bfd_boolean
7632 is_insn_dq_form (unsigned int insn)
7633 {
7634   return ((insn & (0x3f << 26)) == 56u << 26 /* lq */
7635           || ((insn & (0x3f << 26)) == (61u << 26) /* lxv, stxv */
7636               && (insn & 3) == 1));
7637 }
7638
7639 /* The RELOCATE_SECTION function is called by the ELF backend linker
7640    to handle the relocations for a section.
7641
7642    The relocs are always passed as Rela structures; if the section
7643    actually uses Rel structures, the r_addend field will always be
7644    zero.
7645
7646    This function is responsible for adjust the section contents as
7647    necessary, and (if using Rela relocs and generating a
7648    relocatable output file) adjusting the reloc addend as
7649    necessary.
7650
7651    This function does not have to worry about setting the reloc
7652    address or the reloc symbol index.
7653
7654    LOCAL_SYMS is a pointer to the swapped in local symbols.
7655
7656    LOCAL_SECTIONS is an array giving the section in the input file
7657    corresponding to the st_shndx field of each local symbol.
7658
7659    The global hash table entry for the global symbols can be found
7660    via elf_sym_hashes (input_bfd).
7661
7662    When generating relocatable output, this function must handle
7663    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
7664    going to be the section symbol corresponding to the output
7665    section, which means that the addend must be adjusted
7666    accordingly.  */
7667
7668 static bfd_boolean
7669 ppc_elf_relocate_section (bfd *output_bfd,
7670                           struct bfd_link_info *info,
7671                           bfd *input_bfd,
7672                           asection *input_section,
7673                           bfd_byte *contents,
7674                           Elf_Internal_Rela *relocs,
7675                           Elf_Internal_Sym *local_syms,
7676                           asection **local_sections)
7677 {
7678   Elf_Internal_Shdr *symtab_hdr;
7679   struct elf_link_hash_entry **sym_hashes;
7680   struct ppc_elf_link_hash_table *htab;
7681   Elf_Internal_Rela *rel;
7682   Elf_Internal_Rela *wrel;
7683   Elf_Internal_Rela *relend;
7684   Elf_Internal_Rela outrel;
7685   asection *got2;
7686   bfd_vma *local_got_offsets;
7687   bfd_boolean ret = TRUE;
7688   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
7689   bfd_boolean is_vxworks_tls;
7690   unsigned int picfixup_size = 0;
7691   struct ppc_elf_relax_info *relax_info = NULL;
7692
7693 #ifdef DEBUG
7694   _bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, "
7695                       "%ld relocations%s",
7696                       input_bfd, input_section,
7697                       (long) input_section->reloc_count,
7698                       (bfd_link_relocatable (info)) ? " (relocatable)" : "");
7699 #endif
7700
7701   got2 = bfd_get_section_by_name (input_bfd, ".got2");
7702
7703   /* Initialize howto table if not already done.  */
7704   if (!ppc_elf_howto_table[R_PPC_ADDR32])
7705     ppc_elf_howto_init ();
7706
7707   htab = ppc_elf_hash_table (info);
7708   local_got_offsets = elf_local_got_offsets (input_bfd);
7709   symtab_hdr = &elf_symtab_hdr (input_bfd);
7710   sym_hashes = elf_sym_hashes (input_bfd);
7711   /* We have to handle relocations in vxworks .tls_vars sections
7712      specially, because the dynamic loader is 'weird'.  */
7713   is_vxworks_tls = (htab->is_vxworks && bfd_link_pic (info)
7714                     && !strcmp (input_section->output_section->name,
7715                                 ".tls_vars"));
7716   if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET)
7717     relax_info = elf_section_data (input_section)->sec_info;
7718   rel = wrel = relocs;
7719   relend = relocs + input_section->reloc_count;
7720   for (; rel < relend; wrel++, rel++)
7721     {
7722       enum elf_ppc_reloc_type r_type;
7723       bfd_vma addend;
7724       bfd_reloc_status_type r;
7725       Elf_Internal_Sym *sym;
7726       asection *sec;
7727       struct elf_link_hash_entry *h;
7728       const char *sym_name;
7729       reloc_howto_type *howto;
7730       unsigned long r_symndx;
7731       bfd_vma relocation;
7732       bfd_vma branch_bit, from;
7733       bfd_boolean unresolved_reloc;
7734       bfd_boolean warned;
7735       unsigned int tls_type, tls_mask, tls_gd;
7736       struct plt_entry **ifunc;
7737       struct reloc_howto_struct alt_howto;
7738
7739     again:
7740       r_type = ELF32_R_TYPE (rel->r_info);
7741       sym = NULL;
7742       sec = NULL;
7743       h = NULL;
7744       unresolved_reloc = FALSE;
7745       warned = FALSE;
7746       r_symndx = ELF32_R_SYM (rel->r_info);
7747
7748       if (r_symndx < symtab_hdr->sh_info)
7749         {
7750           sym = local_syms + r_symndx;
7751           sec = local_sections[r_symndx];
7752           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
7753
7754           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
7755         }
7756       else
7757         {
7758           bfd_boolean ignored;
7759
7760           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
7761                                    r_symndx, symtab_hdr, sym_hashes,
7762                                    h, sec, relocation,
7763                                    unresolved_reloc, warned, ignored);
7764
7765           sym_name = h->root.root.string;
7766         }
7767
7768       if (sec != NULL && discarded_section (sec))
7769         {
7770           /* For relocs against symbols from removed linkonce sections,
7771              or sections discarded by a linker script, we just want the
7772              section contents zeroed.  Avoid any special processing.  */
7773           howto = NULL;
7774           if (r_type < R_PPC_max)
7775             howto = ppc_elf_howto_table[r_type];
7776
7777           _bfd_clear_contents (howto, input_bfd, input_section,
7778                                contents + rel->r_offset);
7779           wrel->r_offset = rel->r_offset;
7780           wrel->r_info = 0;
7781           wrel->r_addend = 0;
7782
7783           /* For ld -r, remove relocations in debug sections against
7784              sections defined in discarded sections.  Not done for
7785              non-debug to preserve relocs in .eh_frame which the
7786              eh_frame editing code expects to be present.  */
7787           if (bfd_link_relocatable (info)
7788               && (input_section->flags & SEC_DEBUGGING))
7789             wrel--;
7790
7791           continue;
7792         }
7793
7794       if (bfd_link_relocatable (info))
7795         {
7796           if (got2 != NULL
7797               && r_type == R_PPC_PLTREL24
7798               && rel->r_addend != 0)
7799             {
7800               /* R_PPC_PLTREL24 is rather special.  If non-zero, the
7801                  addend specifies the GOT pointer offset within .got2.  */
7802               rel->r_addend += got2->output_offset;
7803             }
7804           if (r_type != R_PPC_RELAX_PLT
7805               && r_type != R_PPC_RELAX_PLTREL24
7806               && r_type != R_PPC_RELAX)
7807             goto copy_reloc;
7808         }
7809
7810       /* TLS optimizations.  Replace instruction sequences and relocs
7811          based on information we collected in tls_optimize.  We edit
7812          RELOCS so that --emit-relocs will output something sensible
7813          for the final instruction stream.  */
7814       tls_mask = 0;
7815       tls_gd = 0;
7816       if (h != NULL)
7817         tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
7818       else if (local_got_offsets != NULL)
7819         {
7820           struct plt_entry **local_plt;
7821           char *lgot_masks;
7822           local_plt
7823             = (struct plt_entry **) (local_got_offsets + symtab_hdr->sh_info);
7824           lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
7825           tls_mask = lgot_masks[r_symndx];
7826         }
7827
7828       /* Ensure reloc mapping code below stays sane.  */
7829       if ((R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TLSGD16 & 3)
7830           || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
7831           || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
7832           || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3)
7833           || (R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TPREL16 & 3)
7834           || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3)
7835           || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3)
7836           || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3))
7837         abort ();
7838       switch (r_type)
7839         {
7840         default:
7841           break;
7842
7843         case R_PPC_GOT_TPREL16:
7844         case R_PPC_GOT_TPREL16_LO:
7845           if ((tls_mask & TLS_TLS) != 0
7846               && (tls_mask & TLS_TPREL) == 0)
7847             {
7848               bfd_vma insn;
7849
7850               insn = bfd_get_32 (output_bfd,
7851                                  contents + rel->r_offset - d_offset);
7852               insn &= 31 << 21;
7853               insn |= 0x3c020000;       /* addis 0,2,0 */
7854               bfd_put_32 (output_bfd, insn,
7855                           contents + rel->r_offset - d_offset);
7856               r_type = R_PPC_TPREL16_HA;
7857               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7858             }
7859           break;
7860
7861         case R_PPC_TLS:
7862           if ((tls_mask & TLS_TLS) != 0
7863               && (tls_mask & TLS_TPREL) == 0)
7864             {
7865               bfd_vma insn;
7866
7867               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
7868               insn = _bfd_elf_ppc_at_tls_transform (insn, 2);
7869               if (insn == 0)
7870                 abort ();
7871               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
7872               r_type = R_PPC_TPREL16_LO;
7873               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7874
7875               /* Was PPC_TLS which sits on insn boundary, now
7876                  PPC_TPREL16_LO which is at low-order half-word.  */
7877               rel->r_offset += d_offset;
7878             }
7879           break;
7880
7881         case R_PPC_GOT_TLSGD16_HI:
7882         case R_PPC_GOT_TLSGD16_HA:
7883           tls_gd = TLS_TPRELGD;
7884           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7885             goto tls_gdld_hi;
7886           break;
7887
7888         case R_PPC_GOT_TLSLD16_HI:
7889         case R_PPC_GOT_TLSLD16_HA:
7890           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7891             {
7892             tls_gdld_hi:
7893               if ((tls_mask & tls_gd) != 0)
7894                 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7895                           + R_PPC_GOT_TPREL16);
7896               else
7897                 {
7898                   rel->r_offset -= d_offset;
7899                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
7900                   r_type = R_PPC_NONE;
7901                 }
7902               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7903             }
7904           break;
7905
7906         case R_PPC_GOT_TLSGD16:
7907         case R_PPC_GOT_TLSGD16_LO:
7908           tls_gd = TLS_TPRELGD;
7909           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7910             goto tls_ldgd_opt;
7911           break;
7912
7913         case R_PPC_GOT_TLSLD16:
7914         case R_PPC_GOT_TLSLD16_LO:
7915           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7916             {
7917               unsigned int insn1, insn2;
7918               bfd_vma offset;
7919
7920             tls_ldgd_opt:
7921               offset = (bfd_vma) -1;
7922               /* If not using the newer R_PPC_TLSGD/LD to mark
7923                  __tls_get_addr calls, we must trust that the call
7924                  stays with its arg setup insns, ie. that the next
7925                  reloc is the __tls_get_addr call associated with
7926                  the current reloc.  Edit both insns.  */
7927               if (input_section->has_tls_get_addr_call
7928                   && rel + 1 < relend
7929                   && branch_reloc_hash_match (input_bfd, rel + 1,
7930                                               htab->tls_get_addr))
7931                 offset = rel[1].r_offset;
7932               /* We read the low GOT_TLS insn because we need to keep
7933                  the destination reg.  It may be something other than
7934                  the usual r3, and moved to r3 before the call by
7935                  intervening code.  */
7936               insn1 = bfd_get_32 (output_bfd,
7937                                   contents + rel->r_offset - d_offset);
7938               if ((tls_mask & tls_gd) != 0)
7939                 {
7940                   /* IE */
7941                   insn1 &= (0x1f << 21) | (0x1f << 16);
7942                   insn1 |= 32 << 26;    /* lwz */
7943                   if (offset != (bfd_vma) -1)
7944                     {
7945                       rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7946                       insn2 = 0x7c631214;       /* add 3,3,2 */
7947                       bfd_put_32 (output_bfd, insn2, contents + offset);
7948                     }
7949                   r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7950                             + R_PPC_GOT_TPREL16);
7951                   rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7952                 }
7953               else
7954                 {
7955                   /* LE */
7956                   insn1 &= 0x1f << 21;
7957                   insn1 |= 0x3c020000;  /* addis r,2,0 */
7958                   if (tls_gd == 0)
7959                     {
7960                       /* Was an LD reloc.  */
7961                       for (r_symndx = 0;
7962                            r_symndx < symtab_hdr->sh_info;
7963                            r_symndx++)
7964                         if (local_sections[r_symndx] == sec)
7965                           break;
7966                       if (r_symndx >= symtab_hdr->sh_info)
7967                         r_symndx = STN_UNDEF;
7968                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
7969                       if (r_symndx != STN_UNDEF)
7970                         rel->r_addend -= (local_syms[r_symndx].st_value
7971                                           + sec->output_offset
7972                                           + sec->output_section->vma);
7973                     }
7974                   r_type = R_PPC_TPREL16_HA;
7975                   rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7976                   if (offset != (bfd_vma) -1)
7977                     {
7978                       rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7979                       rel[1].r_offset = offset + d_offset;
7980                       rel[1].r_addend = rel->r_addend;
7981                       insn2 = 0x38630000;       /* addi 3,3,0 */
7982                       bfd_put_32 (output_bfd, insn2, contents + offset);
7983                     }
7984                 }
7985               bfd_put_32 (output_bfd, insn1,
7986                           contents + rel->r_offset - d_offset);
7987               if (tls_gd == 0)
7988                 {
7989                   /* We changed the symbol on an LD reloc.  Start over
7990                      in order to get h, sym, sec etc. right.  */
7991                   goto again;
7992                 }
7993             }
7994           break;
7995
7996         case R_PPC_TLSGD:
7997           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7998             {
7999               unsigned int insn2;
8000               bfd_vma offset = rel->r_offset;
8001
8002               if ((tls_mask & TLS_TPRELGD) != 0)
8003                 {
8004                   /* IE */
8005                   r_type = R_PPC_NONE;
8006                   insn2 = 0x7c631214;   /* add 3,3,2 */
8007                 }
8008               else
8009                 {
8010                   /* LE */
8011                   r_type = R_PPC_TPREL16_LO;
8012                   rel->r_offset += d_offset;
8013                   insn2 = 0x38630000;   /* addi 3,3,0 */
8014                 }
8015               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
8016               bfd_put_32 (output_bfd, insn2, contents + offset);
8017               /* Zap the reloc on the _tls_get_addr call too.  */
8018               BFD_ASSERT (offset == rel[1].r_offset);
8019               rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
8020             }
8021           break;
8022
8023         case R_PPC_TLSLD:
8024           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
8025             {
8026               unsigned int insn2;
8027
8028               for (r_symndx = 0;
8029                    r_symndx < symtab_hdr->sh_info;
8030                    r_symndx++)
8031                 if (local_sections[r_symndx] == sec)
8032                   break;
8033               if (r_symndx >= symtab_hdr->sh_info)
8034                 r_symndx = STN_UNDEF;
8035               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
8036               if (r_symndx != STN_UNDEF)
8037                 rel->r_addend -= (local_syms[r_symndx].st_value
8038                                   + sec->output_offset
8039                                   + sec->output_section->vma);
8040
8041               rel->r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
8042               rel->r_offset += d_offset;
8043               insn2 = 0x38630000;       /* addi 3,3,0 */
8044               bfd_put_32 (output_bfd, insn2,
8045                           contents + rel->r_offset - d_offset);
8046               /* Zap the reloc on the _tls_get_addr call too.  */
8047               BFD_ASSERT (rel->r_offset - d_offset == rel[1].r_offset);
8048               rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
8049               goto again;
8050             }
8051           break;
8052         }
8053
8054       /* Handle other relocations that tweak non-addend part of insn.  */
8055       branch_bit = 0;
8056       switch (r_type)
8057         {
8058         default:
8059           break;
8060
8061           /* Branch taken prediction relocations.  */
8062         case R_PPC_ADDR14_BRTAKEN:
8063         case R_PPC_REL14_BRTAKEN:
8064           branch_bit = BRANCH_PREDICT_BIT;
8065           /* Fall thru */
8066
8067           /* Branch not taken prediction relocations.  */
8068         case R_PPC_ADDR14_BRNTAKEN:
8069         case R_PPC_REL14_BRNTAKEN:
8070           {
8071             bfd_vma insn;
8072
8073             insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
8074             insn &= ~BRANCH_PREDICT_BIT;
8075             insn |= branch_bit;
8076
8077             from = (rel->r_offset
8078                     + input_section->output_offset
8079                     + input_section->output_section->vma);
8080
8081             /* Invert 'y' bit if not the default.  */
8082             if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
8083               insn ^= BRANCH_PREDICT_BIT;
8084
8085             bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
8086             break;
8087           }
8088         }
8089
8090       if (ELIMINATE_COPY_RELOCS
8091           && h != NULL
8092           && !h->def_regular
8093           && h->protected_def
8094           && ppc_elf_hash_entry (h)->has_addr16_ha
8095           && ppc_elf_hash_entry (h)->has_addr16_lo
8096           && htab->params->pic_fixup > 0)
8097         {
8098           /* Convert lis;addi or lis;load/store accessing a protected
8099              variable defined in a shared library to PIC.  */
8100           unsigned int insn;
8101
8102           if (r_type == R_PPC_ADDR16_HA)
8103             {
8104               insn = bfd_get_32 (output_bfd,
8105                                  contents + rel->r_offset - d_offset);
8106               if ((insn & (0x3f << 26)) == (15u << 26)
8107                   && (insn & (0x1f << 16)) == 0 /* lis */)
8108                 {
8109                   bfd_byte *p;
8110                   bfd_vma off;
8111                   bfd_vma got_addr;
8112
8113                   p = (contents + input_section->size
8114                        - relax_info->workaround_size
8115                        - relax_info->picfixup_size
8116                        + picfixup_size);
8117                   off = (p - contents) - (rel->r_offset - d_offset);
8118                   if (off > 0x1fffffc || (off & 3) != 0)
8119                     info->callbacks->einfo
8120                       (_("%P: %H: fixup branch overflow\n"),
8121                        input_bfd, input_section, rel->r_offset);
8122
8123                   bfd_put_32 (output_bfd, B | off,
8124                               contents + rel->r_offset - d_offset);
8125                   got_addr = (htab->got->output_section->vma
8126                               + htab->got->output_offset
8127                               + (h->got.offset & ~1));
8128                   wrel->r_offset = (p - contents) + d_offset;
8129                   wrel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_HA);
8130                   wrel->r_addend = got_addr;
8131                   insn &= ~0xffff;
8132                   insn |= ((unsigned int )(got_addr + 0x8000) >> 16) & 0xffff;
8133                   bfd_put_32 (output_bfd, insn, p);
8134
8135                   /* Convert lis to lwz, loading address from GOT.  */
8136                   insn &= ~0xffff;
8137                   insn ^= (32u ^ 15u) << 26;
8138                   insn |= (insn & (0x1f << 21)) >> 5;
8139                   insn |= got_addr & 0xffff;
8140                   bfd_put_32 (output_bfd, insn, p + 4);
8141
8142                   bfd_put_32 (output_bfd, B | ((-4 - off) & 0x3ffffff), p + 8);
8143                   picfixup_size += 12;
8144
8145                   /* Use one of the spare relocs, so --emit-relocs
8146                      output is reasonable.  */
8147                   memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel));
8148                   wrel++, rel++;
8149                   rel->r_offset = wrel[-1].r_offset + 4;
8150                   rel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_LO);
8151                   rel->r_addend = wrel[-1].r_addend;
8152
8153                   /* Continue on as if we had a got reloc, to output
8154                      dynamic reloc.  */
8155                   r_type = R_PPC_GOT16_LO;
8156                 }
8157               else
8158                 info->callbacks->einfo
8159                   (_("%P: %H: error: %s with unexpected instruction %x\n"),
8160                    input_bfd, input_section, rel->r_offset,
8161                    "R_PPC_ADDR16_HA", insn);
8162             }
8163           else if (r_type == R_PPC_ADDR16_LO)
8164             {
8165               insn = bfd_get_32 (output_bfd,
8166                                  contents + rel->r_offset - d_offset);
8167               if ((insn & (0x3f << 26)) == 14u << 26    /* addi */
8168                   || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8169                   || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8170                   || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8171                   || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8172                   || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8173                   || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8174                   || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8175                   || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8176                   || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8177                   || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8178                   || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8179                   || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8180                   || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8181                   || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8182                       && (insn & 3) != 1)
8183                   || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8184                       && ((insn & 3) == 0 || (insn & 3) == 3)))
8185                 {
8186                   /* Arrange to apply the reloc addend, if any.  */
8187                   relocation = 0;
8188                   unresolved_reloc = FALSE;
8189                   rel->r_info = ELF32_R_INFO (0, r_type);
8190                 }
8191               else
8192                 info->callbacks->einfo
8193                   (_("%P: %H: error: %s with unexpected instruction %x\n"),
8194                    input_bfd, input_section, rel->r_offset,
8195                    "R_PPC_ADDR16_LO", insn);
8196             }
8197         }
8198
8199       ifunc = NULL;
8200       if (!htab->is_vxworks)
8201         {
8202           struct plt_entry *ent;
8203
8204           if (h != NULL)
8205             {
8206               if (h->type == STT_GNU_IFUNC)
8207                 ifunc = &h->plt.plist;
8208             }
8209           else if (local_got_offsets != NULL
8210                    && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8211             {
8212               struct plt_entry **local_plt;
8213
8214               local_plt = (struct plt_entry **) (local_got_offsets
8215                                                  + symtab_hdr->sh_info);
8216               ifunc = local_plt + r_symndx;
8217             }
8218
8219           ent = NULL;
8220           if (ifunc != NULL
8221               && (!bfd_link_pic (info)
8222                   || is_branch_reloc (r_type)))
8223             {
8224               addend = 0;
8225               if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info))
8226                 addend = rel->r_addend;
8227               ent = find_plt_ent (ifunc, got2, addend);
8228             }
8229           if (ent != NULL)
8230             {
8231               if (h == NULL && (ent->plt.offset & 1) == 0)
8232                 {
8233                   Elf_Internal_Rela rela;
8234                   bfd_byte *loc;
8235
8236                   rela.r_offset = (htab->iplt->output_section->vma
8237                                    + htab->iplt->output_offset
8238                                    + ent->plt.offset);
8239                   rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8240                   rela.r_addend = relocation;
8241                   loc = htab->reliplt->contents;
8242                   loc += (htab->reliplt->reloc_count++
8243                           * sizeof (Elf32_External_Rela));
8244                   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8245
8246                   ent->plt.offset |= 1;
8247                 }
8248               if (h == NULL && (ent->glink_offset & 1) == 0)
8249                 {
8250                   unsigned char *p = ((unsigned char *) htab->glink->contents
8251                                       + ent->glink_offset);
8252                   write_glink_stub (ent, htab->iplt, p, info);
8253                   ent->glink_offset |= 1;
8254                 }
8255
8256               unresolved_reloc = FALSE;
8257               if (htab->plt_type == PLT_NEW
8258                   || !htab->elf.dynamic_sections_created
8259                   || h == NULL
8260                   || h->dynindx == -1)
8261                 relocation = (htab->glink->output_section->vma
8262                               + htab->glink->output_offset
8263                               + (ent->glink_offset & ~1));
8264               else
8265                 relocation = (htab->plt->output_section->vma
8266                               + htab->plt->output_offset
8267                               + ent->plt.offset);
8268             }
8269         }
8270
8271       addend = rel->r_addend;
8272       tls_type = 0;
8273       howto = NULL;
8274       if (r_type < R_PPC_max)
8275         howto = ppc_elf_howto_table[r_type];
8276       switch (r_type)
8277         {
8278         default:
8279           info->callbacks->einfo
8280             (_("%P: %B: unknown relocation type %d for symbol %s\n"),
8281              input_bfd, (int) r_type, sym_name);
8282
8283           bfd_set_error (bfd_error_bad_value);
8284           ret = FALSE;
8285           goto copy_reloc;
8286
8287         case R_PPC_NONE:
8288         case R_PPC_TLS:
8289         case R_PPC_TLSGD:
8290         case R_PPC_TLSLD:
8291         case R_PPC_EMB_MRKREF:
8292         case R_PPC_GNU_VTINHERIT:
8293         case R_PPC_GNU_VTENTRY:
8294           goto copy_reloc;
8295
8296           /* GOT16 relocations.  Like an ADDR16 using the symbol's
8297              address in the GOT as relocation value instead of the
8298              symbol's value itself.  Also, create a GOT entry for the
8299              symbol and put the symbol value there.  */
8300         case R_PPC_GOT_TLSGD16:
8301         case R_PPC_GOT_TLSGD16_LO:
8302         case R_PPC_GOT_TLSGD16_HI:
8303         case R_PPC_GOT_TLSGD16_HA:
8304           tls_type = TLS_TLS | TLS_GD;
8305           goto dogot;
8306
8307         case R_PPC_GOT_TLSLD16:
8308         case R_PPC_GOT_TLSLD16_LO:
8309         case R_PPC_GOT_TLSLD16_HI:
8310         case R_PPC_GOT_TLSLD16_HA:
8311           tls_type = TLS_TLS | TLS_LD;
8312           goto dogot;
8313
8314         case R_PPC_GOT_TPREL16:
8315         case R_PPC_GOT_TPREL16_LO:
8316         case R_PPC_GOT_TPREL16_HI:
8317         case R_PPC_GOT_TPREL16_HA:
8318           tls_type = TLS_TLS | TLS_TPREL;
8319           goto dogot;
8320
8321         case R_PPC_GOT_DTPREL16:
8322         case R_PPC_GOT_DTPREL16_LO:
8323         case R_PPC_GOT_DTPREL16_HI:
8324         case R_PPC_GOT_DTPREL16_HA:
8325           tls_type = TLS_TLS | TLS_DTPREL;
8326           goto dogot;
8327
8328         case R_PPC_GOT16:
8329         case R_PPC_GOT16_LO:
8330         case R_PPC_GOT16_HI:
8331         case R_PPC_GOT16_HA:
8332           tls_mask = 0;
8333         dogot:
8334           {
8335             /* Relocation is to the entry for this symbol in the global
8336                offset table.  */
8337             bfd_vma off;
8338             bfd_vma *offp;
8339             unsigned long indx;
8340
8341             if (htab->got == NULL)
8342               abort ();
8343
8344             indx = 0;
8345             if (tls_type == (TLS_TLS | TLS_LD)
8346                 && (h == NULL
8347                     || !h->def_dynamic))
8348               offp = &htab->tlsld_got.offset;
8349             else if (h != NULL)
8350               {
8351                 bfd_boolean dyn;
8352                 dyn = htab->elf.dynamic_sections_created;
8353                 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
8354                     || (bfd_link_pic (info)
8355                         && SYMBOL_REFERENCES_LOCAL (info, h)))
8356                   /* This is actually a static link, or it is a
8357                      -Bsymbolic link and the symbol is defined
8358                      locally, or the symbol was forced to be local
8359                      because of a version file.  */
8360                   ;
8361                 else
8362                   {
8363                     BFD_ASSERT (h->dynindx != -1);
8364                     indx = h->dynindx;
8365                     unresolved_reloc = FALSE;
8366                   }
8367                 offp = &h->got.offset;
8368               }
8369             else
8370               {
8371                 if (local_got_offsets == NULL)
8372                   abort ();
8373                 offp = &local_got_offsets[r_symndx];
8374               }
8375
8376             /* The offset must always be a multiple of 4.  We use the
8377                least significant bit to record whether we have already
8378                processed this entry.  */
8379             off = *offp;
8380             if ((off & 1) != 0)
8381               off &= ~1;
8382             else
8383               {
8384                 unsigned int tls_m = (tls_mask
8385                                       & (TLS_LD | TLS_GD | TLS_DTPREL
8386                                          | TLS_TPREL | TLS_TPRELGD));
8387
8388                 if (offp == &htab->tlsld_got.offset)
8389                   tls_m = TLS_LD;
8390                 else if (h == NULL
8391                          || !h->def_dynamic)
8392                   tls_m &= ~TLS_LD;
8393
8394                 /* We might have multiple got entries for this sym.
8395                    Initialize them all.  */
8396                 do
8397                   {
8398                     int tls_ty = 0;
8399
8400                     if ((tls_m & TLS_LD) != 0)
8401                       {
8402                         tls_ty = TLS_TLS | TLS_LD;
8403                         tls_m &= ~TLS_LD;
8404                       }
8405                     else if ((tls_m & TLS_GD) != 0)
8406                       {
8407                         tls_ty = TLS_TLS | TLS_GD;
8408                         tls_m &= ~TLS_GD;
8409                       }
8410                     else if ((tls_m & TLS_DTPREL) != 0)
8411                       {
8412                         tls_ty = TLS_TLS | TLS_DTPREL;
8413                         tls_m &= ~TLS_DTPREL;
8414                       }
8415                     else if ((tls_m & (TLS_TPREL | TLS_TPRELGD)) != 0)
8416                       {
8417                         tls_ty = TLS_TLS | TLS_TPREL;
8418                         tls_m = 0;
8419                       }
8420
8421                     /* Generate relocs for the dynamic linker.  */
8422                     if ((bfd_link_pic (info) || indx != 0)
8423                         && (offp == &htab->tlsld_got.offset
8424                             || h == NULL
8425                             || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8426                             || h->root.type != bfd_link_hash_undefweak))
8427                       {
8428                         asection *rsec = htab->relgot;
8429                         bfd_byte * loc;
8430
8431                         if (ifunc != NULL)
8432                           rsec = htab->reliplt;
8433                         outrel.r_offset = (htab->got->output_section->vma
8434                                            + htab->got->output_offset
8435                                            + off);
8436                         outrel.r_addend = 0;
8437                         if (tls_ty & (TLS_LD | TLS_GD))
8438                           {
8439                             outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
8440                             if (tls_ty == (TLS_TLS | TLS_GD))
8441                               {
8442                                 loc = rsec->contents;
8443                                 loc += (rsec->reloc_count++
8444                                         * sizeof (Elf32_External_Rela));
8445                                 bfd_elf32_swap_reloca_out (output_bfd,
8446                                                            &outrel, loc);
8447                                 outrel.r_offset += 4;
8448                                 outrel.r_info
8449                                   = ELF32_R_INFO (indx, R_PPC_DTPREL32);
8450                               }
8451                           }
8452                         else if (tls_ty == (TLS_TLS | TLS_DTPREL))
8453                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
8454                         else if (tls_ty == (TLS_TLS | TLS_TPREL))
8455                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
8456                         else if (indx != 0)
8457                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
8458                         else if (ifunc != NULL)
8459                           outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8460                         else
8461                           outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
8462                         if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD))
8463                           {
8464                             outrel.r_addend += relocation;
8465                             if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
8466                               {
8467                                 if (htab->elf.tls_sec == NULL)
8468                                   outrel.r_addend = 0;
8469                                 else
8470                                   outrel.r_addend -= htab->elf.tls_sec->vma;
8471                               }
8472                           }
8473                         loc = rsec->contents;
8474                         loc += (rsec->reloc_count++
8475                                 * sizeof (Elf32_External_Rela));
8476                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
8477                       }
8478
8479                     /* Init the .got section contents if we're not
8480                        emitting a reloc.  */
8481                     else
8482                       {
8483                         bfd_vma value = relocation;
8484
8485                         if (tls_ty == (TLS_TLS | TLS_LD))
8486                           value = 1;
8487                         else if (tls_ty != 0)
8488                           {
8489                             if (htab->elf.tls_sec == NULL)
8490                               value = 0;
8491                             else
8492                               {
8493                                 value -= htab->elf.tls_sec->vma + DTP_OFFSET;
8494                                 if (tls_ty == (TLS_TLS | TLS_TPREL))
8495                                   value += DTP_OFFSET - TP_OFFSET;
8496                               }
8497
8498                             if (tls_ty == (TLS_TLS | TLS_GD))
8499                               {
8500                                 bfd_put_32 (output_bfd, value,
8501                                             htab->got->contents + off + 4);
8502                                 value = 1;
8503                               }
8504                           }
8505                         bfd_put_32 (output_bfd, value,
8506                                     htab->got->contents + off);
8507                       }
8508
8509                     off += 4;
8510                     if (tls_ty & (TLS_LD | TLS_GD))
8511                       off += 4;
8512                   }
8513                 while (tls_m != 0);
8514
8515                 off = *offp;
8516                 *offp = off | 1;
8517               }
8518
8519             if (off >= (bfd_vma) -2)
8520               abort ();
8521
8522             if ((tls_type & TLS_TLS) != 0)
8523               {
8524                 if (tls_type != (TLS_TLS | TLS_LD))
8525                   {
8526                     if ((tls_mask & TLS_LD) != 0
8527                         && !(h == NULL
8528                              || !h->def_dynamic))
8529                       off += 8;
8530                     if (tls_type != (TLS_TLS | TLS_GD))
8531                       {
8532                         if ((tls_mask & TLS_GD) != 0)
8533                           off += 8;
8534                         if (tls_type != (TLS_TLS | TLS_DTPREL))
8535                           {
8536                             if ((tls_mask & TLS_DTPREL) != 0)
8537                               off += 4;
8538                           }
8539                       }
8540                   }
8541               }
8542
8543             /* If here for a picfixup, we're done.  */
8544             if (r_type != ELF32_R_TYPE (rel->r_info))
8545               goto copy_reloc;
8546
8547             relocation = (htab->got->output_section->vma
8548                           + htab->got->output_offset
8549                           + off
8550                           - SYM_VAL (htab->elf.hgot));
8551
8552             /* Addends on got relocations don't make much sense.
8553                x+off@got is actually x@got+off, and since the got is
8554                generated by a hash table traversal, the value in the
8555                got at entry m+n bears little relation to the entry m.  */
8556             if (addend != 0)
8557               info->callbacks->einfo
8558                 (_("%P: %H: non-zero addend on %s reloc against `%s'\n"),
8559                  input_bfd, input_section, rel->r_offset,
8560                  howto->name,
8561                  sym_name);
8562           }
8563           break;
8564
8565           /* Relocations that need no special processing.  */
8566         case R_PPC_LOCAL24PC:
8567           /* It makes no sense to point a local relocation
8568              at a symbol not in this object.  */
8569           if (unresolved_reloc)
8570             {
8571               if (! (*info->callbacks->undefined_symbol) (info,
8572                                                           h->root.root.string,
8573                                                           input_bfd,
8574                                                           input_section,
8575                                                           rel->r_offset,
8576                                                           TRUE))
8577                 return FALSE;
8578               goto copy_reloc;
8579             }
8580           break;
8581
8582         case R_PPC_DTPREL16:
8583         case R_PPC_DTPREL16_LO:
8584         case R_PPC_DTPREL16_HI:
8585         case R_PPC_DTPREL16_HA:
8586           if (htab->elf.tls_sec != NULL)
8587             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
8588           break;
8589
8590           /* Relocations that may need to be propagated if this is a shared
8591              object.  */
8592         case R_PPC_TPREL16:
8593         case R_PPC_TPREL16_LO:
8594         case R_PPC_TPREL16_HI:
8595         case R_PPC_TPREL16_HA:
8596           if (h != NULL
8597               && h->root.type == bfd_link_hash_undefweak
8598               && h->dynindx == -1)
8599             {
8600               /* Make this relocation against an undefined weak symbol
8601                  resolve to zero.  This is really just a tweak, since
8602                  code using weak externs ought to check that they are
8603                  defined before using them.  */
8604               bfd_byte *p = contents + rel->r_offset - d_offset;
8605               unsigned int insn = bfd_get_32 (output_bfd, p);
8606               insn = _bfd_elf_ppc_at_tprel_transform (insn, 2);
8607               if (insn != 0)
8608                 bfd_put_32 (output_bfd, insn, p);
8609               break;
8610             }
8611           if (htab->elf.tls_sec != NULL)
8612             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
8613           /* The TPREL16 relocs shouldn't really be used in shared
8614              libs as they will result in DT_TEXTREL being set, but
8615              support them anyway.  */
8616           goto dodyn;
8617
8618         case R_PPC_TPREL32:
8619           if (htab->elf.tls_sec != NULL)
8620             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
8621           goto dodyn;
8622
8623         case R_PPC_DTPREL32:
8624           if (htab->elf.tls_sec != NULL)
8625             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
8626           goto dodyn;
8627
8628         case R_PPC_DTPMOD32:
8629           relocation = 1;
8630           addend = 0;
8631           goto dodyn;
8632
8633         case R_PPC_REL16:
8634         case R_PPC_REL16_LO:
8635         case R_PPC_REL16_HI:
8636         case R_PPC_REL16_HA:
8637         case R_PPC_REL16DX_HA:
8638           break;
8639
8640         case R_PPC_REL32:
8641           if (h == NULL || h == htab->elf.hgot)
8642             break;
8643           /* fall through */
8644
8645         case R_PPC_ADDR32:
8646         case R_PPC_ADDR16:
8647         case R_PPC_ADDR16_LO:
8648         case R_PPC_ADDR16_HI:
8649         case R_PPC_ADDR16_HA:
8650         case R_PPC_UADDR32:
8651         case R_PPC_UADDR16:
8652           goto dodyn;
8653
8654         case R_PPC_VLE_REL8:
8655         case R_PPC_VLE_REL15:
8656         case R_PPC_VLE_REL24:
8657         case R_PPC_REL24:
8658         case R_PPC_REL14:
8659         case R_PPC_REL14_BRTAKEN:
8660         case R_PPC_REL14_BRNTAKEN:
8661           /* If these relocations are not to a named symbol, they can be
8662              handled right here, no need to bother the dynamic linker.  */
8663           if (SYMBOL_CALLS_LOCAL (info, h)
8664               || h == htab->elf.hgot)
8665             break;
8666           /* fall through */
8667
8668         case R_PPC_ADDR24:
8669         case R_PPC_ADDR14:
8670         case R_PPC_ADDR14_BRTAKEN:
8671         case R_PPC_ADDR14_BRNTAKEN:
8672           if (h != NULL && !bfd_link_pic (info))
8673             break;
8674           /* fall through */
8675
8676         dodyn:
8677           if ((input_section->flags & SEC_ALLOC) == 0
8678               || is_vxworks_tls)
8679             break;
8680
8681           if ((bfd_link_pic (info)
8682                && !(h != NULL
8683                     && ((h->root.type == bfd_link_hash_undefined
8684                          && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
8685                              || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
8686                         || (h->root.type == bfd_link_hash_undefweak
8687                             && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)))
8688                && (must_be_dyn_reloc (info, r_type)
8689                    || !SYMBOL_CALLS_LOCAL (info, h)))
8690               || (ELIMINATE_COPY_RELOCS
8691                   && !bfd_link_pic (info)
8692                   && h != NULL
8693                   && h->dynindx != -1
8694                   && !h->non_got_ref
8695                   && !h->def_regular
8696                   && !(h->protected_def
8697                        && ppc_elf_hash_entry (h)->has_addr16_ha
8698                        && ppc_elf_hash_entry (h)->has_addr16_lo
8699                        && htab->params->pic_fixup > 0)))
8700             {
8701               int skip;
8702               bfd_byte *loc;
8703               asection *sreloc;
8704 #ifdef DEBUG
8705               fprintf (stderr, "ppc_elf_relocate_section needs to "
8706                        "create relocation for %s\n",
8707                        (h && h->root.root.string
8708                         ? h->root.root.string : "<unknown>"));
8709 #endif
8710
8711               /* When generating a shared object, these relocations
8712                  are copied into the output file to be resolved at run
8713                  time.  */
8714               sreloc = elf_section_data (input_section)->sreloc;
8715               if (ifunc)
8716                 sreloc = htab->reliplt;
8717               if (sreloc == NULL)
8718                 return FALSE;
8719
8720               skip = 0;
8721               outrel.r_offset = _bfd_elf_section_offset (output_bfd, info,
8722                                                          input_section,
8723                                                          rel->r_offset);
8724               if (outrel.r_offset == (bfd_vma) -1
8725                   || outrel.r_offset == (bfd_vma) -2)
8726                 skip = (int) outrel.r_offset;
8727               outrel.r_offset += (input_section->output_section->vma
8728                                   + input_section->output_offset);
8729
8730               if (skip)
8731                 memset (&outrel, 0, sizeof outrel);
8732               else if ((h != NULL
8733                         && (h->root.type == bfd_link_hash_undefined
8734                             || h->root.type == bfd_link_hash_undefweak))
8735                        || !SYMBOL_REFERENCES_LOCAL (info, h))
8736                 {
8737                   BFD_ASSERT (h->dynindx != -1);
8738                   unresolved_reloc = FALSE;
8739                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
8740                   outrel.r_addend = rel->r_addend;
8741                 }
8742               else
8743                 {
8744                   outrel.r_addend = relocation + rel->r_addend;
8745
8746                   if (r_type != R_PPC_ADDR32)
8747                     {
8748                       long indx = 0;
8749
8750                       if (ifunc != NULL)
8751                         {
8752                           /* If we get here when building a static
8753                              executable, then the libc startup function
8754                              responsible for applying indirect function
8755                              relocations is going to complain about
8756                              the reloc type.
8757                              If we get here when building a dynamic
8758                              executable, it will be because we have
8759                              a text relocation.  The dynamic loader
8760                              will set the text segment writable and
8761                              non-executable to apply text relocations.
8762                              So we'll segfault when trying to run the
8763                              indirection function to resolve the reloc.  */
8764                           info->callbacks->einfo
8765                             (_("%P: %H: relocation %s for indirect "
8766                                "function %s unsupported\n"),
8767                              input_bfd, input_section, rel->r_offset,
8768                              howto->name,
8769                              sym_name);
8770                           ret = FALSE;
8771                         }
8772                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
8773                         ;
8774                       else if (sec == NULL || sec->owner == NULL)
8775                         {
8776                           bfd_set_error (bfd_error_bad_value);
8777                           ret = FALSE;
8778                         }
8779                       else
8780                         {
8781                           asection *osec;
8782
8783                           /* We are turning this relocation into one
8784                              against a section symbol.  It would be
8785                              proper to subtract the symbol's value,
8786                              osec->vma, from the emitted reloc addend,
8787                              but ld.so expects buggy relocs.
8788                              FIXME: Why not always use a zero index?  */
8789                           osec = sec->output_section;
8790                           indx = elf_section_data (osec)->dynindx;
8791                           if (indx == 0)
8792                             {
8793                               osec = htab->elf.text_index_section;
8794                               indx = elf_section_data (osec)->dynindx;
8795                             }
8796                           BFD_ASSERT (indx != 0);
8797 #ifdef DEBUG
8798                           if (indx == 0)
8799                             printf ("indx=%ld section=%s flags=%08x name=%s\n",
8800                                     indx, osec->name, osec->flags,
8801                                     h->root.root.string);
8802 #endif
8803                         }
8804
8805                       outrel.r_info = ELF32_R_INFO (indx, r_type);
8806                     }
8807                   else if (ifunc != NULL)
8808                     outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8809                   else
8810                     outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
8811                 }
8812
8813               loc = sreloc->contents;
8814               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
8815               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
8816
8817               if (skip == -1)
8818                 goto copy_reloc;
8819
8820               /* This reloc will be computed at runtime.  We clear the memory
8821                  so that it contains predictable value.  */
8822               if (! skip
8823                   && ((input_section->flags & SEC_ALLOC) != 0
8824                       || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE))
8825                 {
8826                   relocation = howto->pc_relative ? outrel.r_offset : 0;
8827                   addend = 0;
8828                   break;
8829                 }
8830             }
8831           break;
8832
8833         case R_PPC_RELAX_PLT:
8834         case R_PPC_RELAX_PLTREL24:
8835           if (h != NULL)
8836             {
8837               struct plt_entry *ent;
8838               bfd_vma got2_addend = 0;
8839
8840               if (r_type == R_PPC_RELAX_PLTREL24)
8841                 {
8842                   if (bfd_link_pic (info))
8843                     got2_addend = addend;
8844                   addend = 0;
8845                 }
8846               ent = find_plt_ent (&h->plt.plist, got2, got2_addend);
8847               if (htab->plt_type == PLT_NEW)
8848                 relocation = (htab->glink->output_section->vma
8849                               + htab->glink->output_offset
8850                               + ent->glink_offset);
8851               else
8852                 relocation = (htab->plt->output_section->vma
8853                               + htab->plt->output_offset
8854                               + ent->plt.offset);
8855             }
8856           /* Fall thru */
8857
8858         case R_PPC_RELAX:
8859           {
8860             const int *stub;
8861             size_t size;
8862             size_t insn_offset = rel->r_offset;
8863             unsigned int insn;
8864
8865             if (bfd_link_pic (info))
8866               {
8867                 relocation -= (input_section->output_section->vma
8868                                + input_section->output_offset
8869                                + rel->r_offset - 4);
8870                 stub = shared_stub_entry;
8871                 bfd_put_32 (output_bfd, stub[0], contents + insn_offset - 12);
8872                 bfd_put_32 (output_bfd, stub[1], contents + insn_offset - 8);
8873                 bfd_put_32 (output_bfd, stub[2], contents + insn_offset - 4);
8874                 stub += 3;
8875                 size = ARRAY_SIZE (shared_stub_entry) - 3;
8876               }
8877             else
8878               {
8879                 stub = stub_entry;
8880                 size = ARRAY_SIZE (stub_entry);
8881               }
8882
8883             relocation += addend;
8884             if (bfd_link_relocatable (info))
8885               relocation = 0;
8886
8887             /* First insn is HA, second is LO.  */
8888             insn = *stub++;
8889             insn |= ((relocation + 0x8000) >> 16) & 0xffff;
8890             bfd_put_32 (output_bfd, insn, contents + insn_offset);
8891             insn_offset += 4;
8892
8893             insn = *stub++;
8894             insn |= relocation & 0xffff;
8895             bfd_put_32 (output_bfd, insn, contents + insn_offset);
8896             insn_offset += 4;
8897             size -= 2;
8898
8899             while (size != 0)
8900               {
8901                 insn = *stub++;
8902                 --size;
8903                 bfd_put_32 (output_bfd, insn, contents + insn_offset);
8904                 insn_offset += 4;
8905               }
8906
8907             /* Rewrite the reloc and convert one of the trailing nop
8908                relocs to describe this relocation.  */
8909             BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE);
8910             /* The relocs are at the bottom 2 bytes */
8911             wrel->r_offset = rel->r_offset + d_offset;
8912             wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
8913             wrel->r_addend = rel->r_addend;
8914             memmove (wrel + 1, wrel, (relend - wrel - 1) * sizeof (*wrel));
8915             wrel++, rel++;
8916             wrel->r_offset += 4;
8917             wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
8918           }
8919           continue;
8920
8921           /* Indirect .sdata relocation.  */
8922         case R_PPC_EMB_SDAI16:
8923           BFD_ASSERT (htab->sdata[0].section != NULL);
8924           if (!is_static_defined (htab->sdata[0].sym))
8925             {
8926               unresolved_reloc = TRUE;
8927               break;
8928             }
8929           relocation
8930             = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0],
8931                                                  h, relocation, rel);
8932           addend = 0;
8933           break;
8934
8935           /* Indirect .sdata2 relocation.  */
8936         case R_PPC_EMB_SDA2I16:
8937           BFD_ASSERT (htab->sdata[1].section != NULL);
8938           if (!is_static_defined (htab->sdata[1].sym))
8939             {
8940               unresolved_reloc = TRUE;
8941               break;
8942             }
8943           relocation
8944             = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1],
8945                                                  h, relocation, rel);
8946           addend = 0;
8947           break;
8948
8949           /* Handle the TOC16 reloc.  We want to use the offset within the .got
8950              section, not the actual VMA.  This is appropriate when generating
8951              an embedded ELF object, for which the .got section acts like the
8952              AIX .toc section.  */
8953         case R_PPC_TOC16:                       /* phony GOT16 relocations */
8954           if (sec == NULL || sec->output_section == NULL)
8955             {
8956               unresolved_reloc = TRUE;
8957               break;
8958             }
8959           BFD_ASSERT (strcmp (bfd_get_section_name (sec->owner, sec),
8960                               ".got") == 0
8961                       || strcmp (bfd_get_section_name (sec->owner, sec),
8962                                  ".cgot") == 0);
8963
8964           addend -= sec->output_section->vma + sec->output_offset + 0x8000;
8965           break;
8966
8967         case R_PPC_PLTREL24:
8968           if (h != NULL && ifunc == NULL)
8969             {
8970               struct plt_entry *ent;
8971
8972               ent = find_plt_ent (&h->plt.plist, got2,
8973                                   bfd_link_pic (info) ? addend : 0);
8974               if (ent == NULL
8975                   || htab->plt == NULL)
8976                 {
8977                   /* We didn't make a PLT entry for this symbol.  This
8978                      happens when statically linking PIC code, or when
8979                      using -Bsymbolic.  */
8980                 }
8981               else
8982                 {
8983                   /* Relocation is to the entry for this symbol in the
8984                      procedure linkage table.  */
8985                   unresolved_reloc = FALSE;
8986                   if (htab->plt_type == PLT_NEW)
8987                     relocation = (htab->glink->output_section->vma
8988                                   + htab->glink->output_offset
8989                                   + ent->glink_offset);
8990                   else
8991                     relocation = (htab->plt->output_section->vma
8992                                   + htab->plt->output_offset
8993                                   + ent->plt.offset);
8994                 }
8995             }
8996
8997           /* R_PPC_PLTREL24 is rather special.  If non-zero, the
8998              addend specifies the GOT pointer offset within .got2.
8999              Don't apply it to the relocation field.  */
9000           addend = 0;
9001           break;
9002
9003           /* Relocate against _SDA_BASE_.  */
9004         case R_PPC_SDAREL16:
9005           {
9006             const char *name;
9007             struct elf_link_hash_entry *sda = htab->sdata[0].sym;
9008
9009             if (sec == NULL
9010                 || sec->output_section == NULL
9011                 || !is_static_defined (sda))
9012               {
9013                 unresolved_reloc = TRUE;
9014                 break;
9015               }
9016             addend -= SYM_VAL (sda);
9017
9018             name = bfd_get_section_name (output_bfd, sec->output_section);
9019             if (!(strcmp (name, ".sdata") == 0
9020                   || strcmp (name, ".sbss") == 0))
9021               {
9022                 info->callbacks->einfo
9023                   (_("%P: %B: the target (%s) of a %s relocation is "
9024                      "in the wrong output section (%s)\n"),
9025                    input_bfd,
9026                    sym_name,
9027                    howto->name,
9028                    name);
9029               }
9030           }
9031           break;
9032
9033           /* Relocate against _SDA2_BASE_.  */
9034         case R_PPC_EMB_SDA2REL:
9035           {
9036             const char *name;
9037             struct elf_link_hash_entry *sda = htab->sdata[1].sym;
9038
9039             if (sec == NULL
9040                 || sec->output_section == NULL
9041                 || !is_static_defined (sda))
9042               {
9043                 unresolved_reloc = TRUE;
9044                 break;
9045               }
9046             addend -= SYM_VAL (sda);
9047
9048             name = bfd_get_section_name (output_bfd, sec->output_section);
9049             if (!(strcmp (name, ".sdata2") == 0
9050                   || strcmp (name, ".sbss2") == 0))
9051               {
9052                 info->callbacks->einfo
9053                   (_("%P: %B: the target (%s) of a %s relocation is "
9054                      "in the wrong output section (%s)\n"),
9055                    input_bfd,
9056                    sym_name,
9057                    howto->name,
9058                    name);
9059               }
9060           }
9061           break;
9062
9063         case R_PPC_VLE_LO16A:
9064           relocation = relocation + addend;
9065           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9066                                relocation, split16a_type);
9067           goto copy_reloc;
9068
9069         case R_PPC_VLE_LO16D:
9070           relocation = relocation + addend;
9071           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9072                                relocation, split16d_type);
9073           goto copy_reloc;
9074
9075         case R_PPC_VLE_HI16A:
9076           relocation = (relocation + addend) >> 16;
9077           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9078                                relocation, split16a_type);
9079           goto copy_reloc;
9080
9081         case R_PPC_VLE_HI16D:
9082           relocation = (relocation + addend) >> 16;
9083           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9084                                relocation, split16d_type);
9085           goto copy_reloc;
9086
9087         case R_PPC_VLE_HA16A:
9088           relocation = (relocation + addend + 0x8000) >> 16;
9089           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9090                                relocation, split16a_type);
9091           goto copy_reloc;
9092
9093         case R_PPC_VLE_HA16D:
9094           relocation = (relocation + addend + 0x8000) >> 16;
9095           ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9096                                relocation, split16d_type);
9097           goto copy_reloc;
9098
9099           /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0.  */
9100         case R_PPC_EMB_SDA21:
9101         case R_PPC_VLE_SDA21:
9102         case R_PPC_EMB_RELSDA:
9103         case R_PPC_VLE_SDA21_LO:
9104           {
9105             const char *name;
9106             int reg;
9107             unsigned int insn;
9108             struct elf_link_hash_entry *sda = NULL;
9109
9110             if (sec == NULL || sec->output_section == NULL)
9111               {
9112                 unresolved_reloc = TRUE;
9113                 break;
9114               }
9115
9116             name = bfd_get_section_name (output_bfd, sec->output_section);
9117             if (strcmp (name, ".sdata") == 0
9118                 || strcmp (name, ".sbss") == 0)
9119               {
9120                 reg = 13;
9121                 sda = htab->sdata[0].sym;
9122               }
9123             else if (strcmp (name, ".sdata2") == 0
9124                      || strcmp (name, ".sbss2") == 0)
9125               {
9126                 reg = 2;
9127                 sda = htab->sdata[1].sym;
9128               }
9129             else if (strcmp (name, ".PPC.EMB.sdata0") == 0
9130                      || strcmp (name, ".PPC.EMB.sbss0") == 0)
9131               {
9132                 reg = 0;
9133               }
9134             else
9135               {
9136                 info->callbacks->einfo
9137                   (_("%P: %B: the target (%s) of a %s relocation is "
9138                      "in the wrong output section (%s)\n"),
9139                    input_bfd,
9140                    sym_name,
9141                    howto->name,
9142                    name);
9143
9144                 bfd_set_error (bfd_error_bad_value);
9145                 ret = FALSE;
9146                 goto copy_reloc;
9147               }
9148
9149             if (sda != NULL)
9150               {
9151                 if (!is_static_defined (sda))
9152                   {
9153                     unresolved_reloc = TRUE;
9154                     break;
9155                   }
9156                 addend -= SYM_VAL (sda);
9157               }
9158
9159             insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
9160             if (reg == 0
9161                 && (r_type == R_PPC_VLE_SDA21
9162                     || r_type == R_PPC_VLE_SDA21_LO))
9163               {
9164                 relocation = relocation + addend;
9165                 addend = 0;
9166
9167                 /* Force e_li insn, keeping RT from original insn.  */
9168                 insn &= 0x1f << 21;
9169                 insn |= 28u << 26;
9170
9171                 /* We have an li20 field, bits 17..20, 11..15, 21..31.  */
9172                 /* Top 4 bits of value to 17..20.  */
9173                 insn |= (relocation & 0xf0000) >> 5;
9174                 /* Next 5 bits of the value to 11..15.  */
9175                 insn |= (relocation & 0xf800) << 5;
9176                 /* And the final 11 bits of the value to bits 21 to 31.  */
9177                 insn |= relocation & 0x7ff;
9178
9179                 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9180
9181                 if (r_type == R_PPC_VLE_SDA21
9182                     && ((relocation + 0x80000) & 0xffffffff) > 0x100000)
9183                   goto overflow;
9184                 goto copy_reloc;
9185               }
9186             else if (r_type == R_PPC_EMB_SDA21
9187                      || r_type == R_PPC_VLE_SDA21
9188                      || r_type == R_PPC_VLE_SDA21_LO)
9189               {
9190                 /* Fill in register field.  */
9191                 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
9192               }
9193             bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9194           }
9195           break;
9196
9197         case R_PPC_VLE_SDAREL_LO16A:
9198         case R_PPC_VLE_SDAREL_LO16D:
9199         case R_PPC_VLE_SDAREL_HI16A:
9200         case R_PPC_VLE_SDAREL_HI16D:
9201         case R_PPC_VLE_SDAREL_HA16A:
9202         case R_PPC_VLE_SDAREL_HA16D:
9203           {
9204             bfd_vma value;
9205             const char *name;
9206             //int reg;
9207             struct elf_link_hash_entry *sda = NULL;
9208
9209             if (sec == NULL || sec->output_section == NULL)
9210               {
9211                 unresolved_reloc = TRUE;
9212                 break;
9213               }
9214
9215             name = bfd_get_section_name (output_bfd, sec->output_section);
9216             if (strcmp (name, ".sdata") == 0
9217                 || strcmp (name, ".sbss") == 0)
9218               {
9219                 //reg = 13;
9220                 sda = htab->sdata[0].sym;
9221               }
9222             else if (strcmp (name, ".sdata2") == 0
9223                      || strcmp (name, ".sbss2") == 0)
9224               {
9225                 //reg = 2;
9226                 sda = htab->sdata[1].sym;
9227               }
9228             else
9229               {
9230                 (*_bfd_error_handler)
9231                   (_("%B: the target (%s) of a %s relocation is "
9232                      "in the wrong output section (%s)"),
9233                    input_bfd,
9234                    sym_name,
9235                    howto->name,
9236                    name);
9237
9238                 bfd_set_error (bfd_error_bad_value);
9239                 ret = FALSE;
9240                 goto copy_reloc;
9241               }
9242
9243             if (sda != NULL)
9244               {
9245                 if (!is_static_defined (sda))
9246                   {
9247                     unresolved_reloc = TRUE;
9248                     break;
9249                   }
9250               }
9251
9252             value = (sda->root.u.def.section->output_section->vma
9253                      + sda->root.u.def.section->output_offset
9254                      + addend);
9255
9256             if (r_type == R_PPC_VLE_SDAREL_LO16A)
9257               ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9258                                    value, split16a_type);
9259             else if (r_type == R_PPC_VLE_SDAREL_LO16D)
9260               ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9261                                    value, split16d_type);
9262             else if (r_type == R_PPC_VLE_SDAREL_HI16A)
9263               {
9264                 value = value >> 16;
9265                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9266                                      value, split16a_type);
9267               }
9268             else if (r_type == R_PPC_VLE_SDAREL_HI16D)
9269               {
9270                 value = value >> 16;
9271                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9272                                      value, split16d_type);
9273               }
9274             else if (r_type == R_PPC_VLE_SDAREL_HA16A)
9275               {
9276                 value = (value + 0x8000) >> 16;
9277                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9278                                      value, split16a_type);
9279               }
9280             else if (r_type == R_PPC_VLE_SDAREL_HA16D)
9281               {
9282                 value = (value + 0x8000) >> 16;
9283                 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset,
9284                                      value, split16d_type);
9285               }
9286           }
9287           goto copy_reloc;
9288
9289           /* Relocate against the beginning of the section.  */
9290         case R_PPC_SECTOFF:
9291         case R_PPC_SECTOFF_LO:
9292         case R_PPC_SECTOFF_HI:
9293         case R_PPC_SECTOFF_HA:
9294           if (sec == NULL || sec->output_section == NULL)
9295             {
9296               unresolved_reloc = TRUE;
9297               break;
9298             }
9299           addend -= sec->output_section->vma;
9300           break;
9301
9302           /* Negative relocations.  */
9303         case R_PPC_EMB_NADDR32:
9304         case R_PPC_EMB_NADDR16:
9305         case R_PPC_EMB_NADDR16_LO:
9306         case R_PPC_EMB_NADDR16_HI:
9307         case R_PPC_EMB_NADDR16_HA:
9308           addend -= 2 * relocation;
9309           break;
9310
9311         case R_PPC_COPY:
9312         case R_PPC_GLOB_DAT:
9313         case R_PPC_JMP_SLOT:
9314         case R_PPC_RELATIVE:
9315         case R_PPC_IRELATIVE:
9316         case R_PPC_PLT32:
9317         case R_PPC_PLTREL32:
9318         case R_PPC_PLT16_LO:
9319         case R_PPC_PLT16_HI:
9320         case R_PPC_PLT16_HA:
9321         case R_PPC_ADDR30:
9322         case R_PPC_EMB_RELSEC16:
9323         case R_PPC_EMB_RELST_LO:
9324         case R_PPC_EMB_RELST_HI:
9325         case R_PPC_EMB_RELST_HA:
9326         case R_PPC_EMB_BIT_FLD:
9327           info->callbacks->einfo
9328             (_("%P: %B: relocation %s is not yet supported for symbol %s\n"),
9329              input_bfd,
9330              howto->name,
9331              sym_name);
9332
9333           bfd_set_error (bfd_error_invalid_operation);
9334           ret = FALSE;
9335           goto copy_reloc;
9336         }
9337
9338       /* Do any further special processing.  */
9339       switch (r_type)
9340         {
9341         default:
9342           break;
9343
9344         case R_PPC_ADDR16_HA:
9345         case R_PPC_REL16_HA:
9346         case R_PPC_REL16DX_HA:
9347         case R_PPC_SECTOFF_HA:
9348         case R_PPC_TPREL16_HA:
9349         case R_PPC_DTPREL16_HA:
9350         case R_PPC_EMB_NADDR16_HA:
9351         case R_PPC_EMB_RELST_HA:
9352           /* It's just possible that this symbol is a weak symbol
9353              that's not actually defined anywhere.  In that case,
9354              'sec' would be NULL, and we should leave the symbol
9355              alone (it will be set to zero elsewhere in the link).  */
9356           if (sec == NULL)
9357             break;
9358           /* Fall thru */
9359
9360         case R_PPC_PLT16_HA:
9361         case R_PPC_GOT16_HA:
9362         case R_PPC_GOT_TLSGD16_HA:
9363         case R_PPC_GOT_TLSLD16_HA:
9364         case R_PPC_GOT_TPREL16_HA:
9365         case R_PPC_GOT_DTPREL16_HA:
9366           /* Add 0x10000 if sign bit in 0:15 is set.
9367              Bits 0:15 are not used.  */
9368           addend += 0x8000;
9369           break;
9370
9371         case R_PPC_ADDR16:
9372         case R_PPC_ADDR16_LO:
9373         case R_PPC_GOT16:
9374         case R_PPC_GOT16_LO:
9375         case R_PPC_SDAREL16:
9376         case R_PPC_SECTOFF:
9377         case R_PPC_SECTOFF_LO:
9378         case R_PPC_DTPREL16:
9379         case R_PPC_DTPREL16_LO:
9380         case R_PPC_TPREL16:
9381         case R_PPC_TPREL16_LO:
9382         case R_PPC_GOT_TLSGD16:
9383         case R_PPC_GOT_TLSGD16_LO:
9384         case R_PPC_GOT_TLSLD16:
9385         case R_PPC_GOT_TLSLD16_LO:
9386         case R_PPC_GOT_DTPREL16:
9387         case R_PPC_GOT_DTPREL16_LO:
9388         case R_PPC_GOT_TPREL16:
9389         case R_PPC_GOT_TPREL16_LO:
9390           {
9391             /* The 32-bit ABI lacks proper relocations to deal with
9392                certain 64-bit instructions.  Prevent damage to bits
9393                that make up part of the insn opcode.  */
9394             unsigned int insn, mask, lobit;
9395
9396             insn = bfd_get_32 (output_bfd,
9397                                contents + rel->r_offset - d_offset);
9398             mask = 0;
9399             if (is_insn_ds_form (insn))
9400               mask = 3;
9401             else if (is_insn_dq_form (insn))
9402               mask = 15;
9403             else
9404               break;
9405             relocation += addend;
9406             addend = insn & mask;
9407             lobit = mask & relocation;
9408             if (lobit != 0)
9409               {
9410                 relocation ^= lobit;
9411                 info->callbacks->einfo
9412                   (_("%P: %H: error: %s against `%s' not a multiple of %u\n"),
9413                    input_bfd, input_section, rel->r_offset,
9414                    howto->name, sym_name, mask + 1);
9415                 bfd_set_error (bfd_error_bad_value);
9416                 ret = FALSE;
9417               }
9418           }
9419           break;
9420         }
9421
9422 #ifdef DEBUG
9423       fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, "
9424                "offset = %ld, addend = %ld\n",
9425                howto->name,
9426                (int) r_type,
9427                sym_name,
9428                r_symndx,
9429                (long) rel->r_offset,
9430                (long) addend);
9431 #endif
9432
9433       if (unresolved_reloc
9434           && !((input_section->flags & SEC_DEBUGGING) != 0
9435                && h->def_dynamic)
9436           && _bfd_elf_section_offset (output_bfd, info, input_section,
9437                                       rel->r_offset) != (bfd_vma) -1)
9438         {
9439           info->callbacks->einfo
9440             (_("%P: %H: unresolvable %s relocation against symbol `%s'\n"),
9441              input_bfd, input_section, rel->r_offset,
9442              howto->name,
9443              sym_name);
9444           ret = FALSE;
9445         }
9446
9447       /* 16-bit fields in insns mostly have signed values, but a
9448          few insns have 16-bit unsigned values.  Really, we should
9449          have different reloc types.  */
9450       if (howto->complain_on_overflow != complain_overflow_dont
9451           && howto->dst_mask == 0xffff
9452           && (input_section->flags & SEC_CODE) != 0)
9453         {
9454           enum complain_overflow complain = complain_overflow_signed;
9455
9456           if ((elf_section_flags (input_section) & SHF_PPC_VLE) == 0)
9457             {
9458               unsigned int insn;
9459
9460               insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
9461               if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
9462                 complain = complain_overflow_bitfield;
9463               else if ((insn & (0x3f << 26)) == 28u << 26 /* andi */
9464                        || (insn & (0x3f << 26)) == 24u << 26 /* ori */
9465                        || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
9466                 complain = complain_overflow_unsigned;
9467             }
9468           if (howto->complain_on_overflow != complain)
9469             {
9470               alt_howto = *howto;
9471               alt_howto.complain_on_overflow = complain;
9472               howto = &alt_howto;
9473             }
9474         }
9475
9476       if (r_type == R_PPC_REL16DX_HA)
9477         {
9478           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
9479           if (rel->r_offset + 4 > input_section->size)
9480             r = bfd_reloc_outofrange;
9481           else
9482             {
9483               unsigned int insn;
9484
9485               relocation += addend;
9486               relocation -= (rel->r_offset
9487                              + input_section->output_offset
9488                              + input_section->output_section->vma);
9489               relocation >>= 16;
9490               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
9491               insn &= ~0x1fffc1;
9492               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
9493               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
9494               r = bfd_reloc_ok;
9495             }
9496         }
9497       else
9498         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
9499                                       rel->r_offset, relocation, addend);
9500
9501       if (r != bfd_reloc_ok)
9502         {
9503           if (r == bfd_reloc_overflow)
9504             {
9505             overflow:
9506               /* On code like "if (foo) foo();" don't report overflow
9507                  on a branch to zero when foo is undefined.  */
9508               if (!warned
9509                   && !(h != NULL
9510                        && (h->root.type == bfd_link_hash_undefweak
9511                            || h->root.type == bfd_link_hash_undefined)
9512                        && is_branch_reloc (r_type)))
9513                 {
9514                   if (!((*info->callbacks->reloc_overflow)
9515                         (info, (h ? &h->root : NULL), sym_name,
9516                          howto->name, rel->r_addend,
9517                          input_bfd, input_section, rel->r_offset)))
9518                     return FALSE;
9519                 }
9520             }
9521           else
9522             {
9523               info->callbacks->einfo
9524                 (_("%P: %H: %s reloc against `%s': error %d\n"),
9525                  input_bfd, input_section, rel->r_offset,
9526                  howto->name, sym_name, (int) r);
9527               ret = FALSE;
9528             }
9529         }
9530     copy_reloc:
9531       if (wrel != rel)
9532         *wrel = *rel;
9533     }
9534
9535   if (wrel != rel)
9536     {
9537       Elf_Internal_Shdr *rel_hdr;
9538       size_t deleted = rel - wrel;
9539
9540       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
9541       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9542       if (rel_hdr->sh_size == 0)
9543         {
9544           /* It is too late to remove an empty reloc section.  Leave
9545              one NONE reloc.
9546              ??? What is wrong with an empty section???  */
9547           rel_hdr->sh_size = rel_hdr->sh_entsize;
9548           deleted -= 1;
9549           wrel++;
9550         }
9551       relend = wrel;
9552       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
9553       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9554       input_section->reloc_count -= deleted;
9555     }
9556
9557 #ifdef DEBUG
9558   fprintf (stderr, "\n");
9559 #endif
9560
9561   if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9562       && input_section->size != input_section->rawsize
9563       && (strcmp (input_section->output_section->name, ".init") == 0
9564           || strcmp (input_section->output_section->name, ".fini") == 0))
9565     {
9566       /* Branch around the trampolines.  */
9567       unsigned int insn = B + input_section->size - input_section->rawsize;
9568       bfd_put_32 (input_bfd, insn, contents + input_section->rawsize);
9569     }
9570
9571   if (htab->params->ppc476_workaround
9572       && input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9573       && (!bfd_link_relocatable (info)
9574           || (input_section->output_section->alignment_power
9575               >= htab->params->pagesize_p2)))
9576     {
9577       bfd_vma start_addr, end_addr, addr;
9578       bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
9579
9580       if (relax_info->workaround_size != 0)
9581         {
9582           bfd_byte *p;
9583           unsigned int n;
9584           bfd_byte fill[4];
9585
9586           bfd_put_32 (input_bfd, BA, fill);
9587           p = contents + input_section->size - relax_info->workaround_size;
9588           n = relax_info->workaround_size >> 2;
9589           while (n--)
9590             {
9591               memcpy (p, fill, 4);
9592               p += 4;
9593             }
9594         }
9595
9596       /* The idea is: Replace the last instruction on a page with a
9597          branch to a patch area.  Put the insn there followed by a
9598          branch back to the next page.  Complicated a little by
9599          needing to handle moved conditional branches, and by not
9600          wanting to touch data-in-text.  */
9601
9602       start_addr = (input_section->output_section->vma
9603                     + input_section->output_offset);
9604       end_addr = (start_addr + input_section->size
9605                   - relax_info->workaround_size);
9606       for (addr = ((start_addr & -pagesize) + pagesize - 4);
9607            addr < end_addr;
9608            addr += pagesize)
9609         {
9610           bfd_vma offset = addr - start_addr;
9611           Elf_Internal_Rela *lo, *hi;
9612           bfd_boolean is_data;
9613           bfd_vma patch_off, patch_addr;
9614           unsigned int insn;
9615
9616           /* Do we have a data reloc at this offset?  If so, leave
9617              the word alone.  */
9618           is_data = FALSE;
9619           lo = relocs;
9620           hi = relend;
9621           rel = NULL;
9622           while (lo < hi)
9623             {
9624               rel = lo + (hi - lo) / 2;
9625               if (rel->r_offset < offset)
9626                 lo = rel + 1;
9627               else if (rel->r_offset > offset + 3)
9628                 hi = rel;
9629               else
9630                 {
9631                   switch (ELF32_R_TYPE (rel->r_info))
9632                     {
9633                     case R_PPC_ADDR32:
9634                     case R_PPC_UADDR32:
9635                     case R_PPC_REL32:
9636                     case R_PPC_ADDR30:
9637                       is_data = TRUE;
9638                       break;
9639                     default:
9640                       break;
9641                     }
9642                   break;
9643                 }
9644             }
9645           if (is_data)
9646             continue;
9647
9648           /* Some instructions can be left alone too.  Unconditional
9649              branches, except for bcctr with BO=0x14 (bctr, bctrl),
9650              avoid the icache failure.
9651
9652              The problem occurs due to prefetch across a page boundary
9653              where stale instructions can be fetched from the next
9654              page, and the mechanism for flushing these bad
9655              instructions fails under certain circumstances.  The
9656              unconditional branches:
9657              1) Branch: b, bl, ba, bla,
9658              2) Branch Conditional: bc, bca, bcl, bcla,
9659              3) Branch Conditional to Link Register: bclr, bclrl,
9660              where (2) and (3) have BO=0x14 making them unconditional,
9661              prevent the bad prefetch because the prefetch itself is
9662              affected by these instructions.  This happens even if the
9663              instruction is not executed.
9664
9665              A bctr example:
9666              .
9667              .  lis 9,new_page@ha
9668              .  addi 9,9,new_page@l
9669              .  mtctr 9
9670              .  bctr
9671              .  nop
9672              .  nop
9673              . new_page:
9674              .
9675              The bctr is not predicted taken due to ctr not being
9676              ready, so prefetch continues on past the bctr into the
9677              new page which might have stale instructions.  If they
9678              fail to be flushed, then they will be executed after the
9679              bctr executes.  Either of the following modifications
9680              prevent the bad prefetch from happening in the first
9681              place:
9682              .
9683              .  lis 9,new_page@ha        lis 9,new_page@ha
9684              .  addi 9,9,new_page@l      addi 9,9,new_page@l
9685              .  mtctr 9                  mtctr 9
9686              .  bctr                     bctr
9687              .  nop                      b somewhere_else
9688              .  b somewhere_else         nop
9689              . new_page:                new_page:
9690              .  */
9691           insn = bfd_get_32 (input_bfd, contents + offset);
9692           if ((insn & (0x3f << 26)) == (18u << 26)          /* b,bl,ba,bla */
9693               || ((insn & (0x3f << 26)) == (16u << 26)      /* bc,bcl,bca,bcla*/
9694                   && (insn & (0x14 << 21)) == (0x14 << 21)) /*   with BO=0x14 */
9695               || ((insn & (0x3f << 26)) == (19u << 26)
9696                   && (insn & (0x3ff << 1)) == (16u << 1)    /* bclr,bclrl */
9697                   && (insn & (0x14 << 21)) == (0x14 << 21)))/*   with BO=0x14 */
9698             continue;
9699
9700           patch_addr = (start_addr + input_section->size
9701                         - relax_info->workaround_size);
9702           patch_addr = (patch_addr + 15) & -16;
9703           patch_off = patch_addr - start_addr;
9704           bfd_put_32 (input_bfd, B + patch_off - offset, contents + offset);
9705
9706           if (rel != NULL
9707               && rel->r_offset >= offset
9708               && rel->r_offset < offset + 4)
9709             {
9710               asection *sreloc;
9711
9712               /* If the insn we are patching had a reloc, adjust the
9713                  reloc r_offset so that the reloc applies to the moved
9714                  location.  This matters for -r and --emit-relocs.  */
9715               if (rel + 1 != relend)
9716                 {
9717                   Elf_Internal_Rela tmp = *rel;
9718
9719                   /* Keep the relocs sorted by r_offset.  */
9720                   memmove (rel, rel + 1, (relend - (rel + 1)) * sizeof (*rel));
9721                   relend[-1] = tmp;
9722                 }
9723               relend[-1].r_offset += patch_off - offset;
9724
9725               /* Adjust REL16 addends too.  */
9726               switch (ELF32_R_TYPE (relend[-1].r_info))
9727                 {
9728                 case R_PPC_REL16:
9729                 case R_PPC_REL16_LO:
9730                 case R_PPC_REL16_HI:
9731                 case R_PPC_REL16_HA:
9732                   relend[-1].r_addend += patch_off - offset;
9733                   break;
9734                 default:
9735                   break;
9736                 }
9737
9738               /* If we are building a PIE or shared library with
9739                  non-PIC objects, perhaps we had a dynamic reloc too?
9740                  If so, the dynamic reloc must move with the insn.  */
9741               sreloc = elf_section_data (input_section)->sreloc;
9742               if (sreloc != NULL)
9743                 {
9744                   Elf32_External_Rela *slo, *shi, *srelend;
9745                   bfd_vma soffset;
9746
9747                   slo = (Elf32_External_Rela *) sreloc->contents;
9748                   shi = srelend = slo + sreloc->reloc_count;
9749                   soffset = (offset + input_section->output_section->vma
9750                              + input_section->output_offset);
9751                   while (slo < shi)
9752                     {
9753                       Elf32_External_Rela *srel = slo + (shi - slo) / 2;
9754                       bfd_elf32_swap_reloca_in (output_bfd, (bfd_byte *) srel,
9755                                                 &outrel);
9756                       if (outrel.r_offset < soffset)
9757                         slo = srel + 1;
9758                       else if (outrel.r_offset > soffset + 3)
9759                         shi = srel;
9760                       else
9761                         {
9762                           if (srel + 1 != srelend)
9763                             {
9764                               memmove (srel, srel + 1,
9765                                        (srelend - (srel + 1)) * sizeof (*srel));
9766                               srel = srelend - 1;
9767                             }
9768                           outrel.r_offset += patch_off - offset;
9769                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,
9770                                                      (bfd_byte *) srel);
9771                           break;
9772                         }
9773                     }
9774                 }
9775             }
9776           else
9777             rel = NULL;
9778
9779           if ((insn & (0x3f << 26)) == (16u << 26) /* bc */
9780               && (insn & 2) == 0 /* relative */)
9781             {
9782               bfd_vma delta = ((insn & 0xfffc) ^ 0x8000) - 0x8000;
9783
9784               delta += offset - patch_off;
9785               if (bfd_link_relocatable (info) && rel != NULL)
9786                 delta = 0;
9787               if (!bfd_link_relocatable (info) && rel != NULL)
9788                 {
9789                   enum elf_ppc_reloc_type r_type;
9790
9791                   r_type = ELF32_R_TYPE (relend[-1].r_info);
9792                   if (r_type == R_PPC_REL14_BRTAKEN)
9793                     insn |= BRANCH_PREDICT_BIT;
9794                   else if (r_type == R_PPC_REL14_BRNTAKEN)
9795                     insn &= ~BRANCH_PREDICT_BIT;
9796                   else
9797                     BFD_ASSERT (r_type == R_PPC_REL14);
9798
9799                   if ((r_type == R_PPC_REL14_BRTAKEN
9800                        || r_type == R_PPC_REL14_BRNTAKEN)
9801                       && delta + 0x8000 < 0x10000
9802                       && (bfd_signed_vma) delta < 0)
9803                     insn ^= BRANCH_PREDICT_BIT;
9804                 }
9805               if (delta + 0x8000 < 0x10000)
9806                 {
9807                   bfd_put_32 (input_bfd,
9808                               (insn & ~0xfffc) | (delta & 0xfffc),
9809                               contents + patch_off);
9810                   patch_off += 4;
9811                   bfd_put_32 (input_bfd,
9812                               B | ((offset + 4 - patch_off) & 0x3fffffc),
9813                               contents + patch_off);
9814                   patch_off += 4;
9815                 }
9816               else
9817                 {
9818                   if (rel != NULL)
9819                     {
9820                       unsigned int r_sym = ELF32_R_SYM (relend[-1].r_info);
9821
9822                       relend[-1].r_offset += 8;
9823                       relend[-1].r_info = ELF32_R_INFO (r_sym, R_PPC_REL24);
9824                     }
9825                   bfd_put_32 (input_bfd,
9826                               (insn & ~0xfffc) | 8,
9827                               contents + patch_off);
9828                   patch_off += 4;
9829                   bfd_put_32 (input_bfd,
9830                               B | ((offset + 4 - patch_off) & 0x3fffffc),
9831                               contents + patch_off);
9832                   patch_off += 4;
9833                   bfd_put_32 (input_bfd,
9834                               B | ((delta - 8) & 0x3fffffc),
9835                               contents + patch_off);
9836                   patch_off += 4;
9837                 }
9838             }
9839           else
9840             {
9841               bfd_put_32 (input_bfd, insn, contents + patch_off);
9842               patch_off += 4;
9843               bfd_put_32 (input_bfd,
9844                           B | ((offset + 4 - patch_off) & 0x3fffffc),
9845                           contents + patch_off);
9846               patch_off += 4;
9847             }
9848           BFD_ASSERT (patch_off <= input_section->size);
9849           relax_info->workaround_size = input_section->size - patch_off;
9850         }
9851     }
9852
9853   return ret;
9854 }
9855 \f
9856 /* Finish up dynamic symbol handling.  We set the contents of various
9857    dynamic sections here.  */
9858
9859 static bfd_boolean
9860 ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
9861                                struct bfd_link_info *info,
9862                                struct elf_link_hash_entry *h,
9863                                Elf_Internal_Sym *sym)
9864 {
9865   struct ppc_elf_link_hash_table *htab;
9866   struct plt_entry *ent;
9867   bfd_boolean doneone;
9868
9869 #ifdef DEBUG
9870   fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
9871            h->root.root.string);
9872 #endif
9873
9874   htab = ppc_elf_hash_table (info);
9875   BFD_ASSERT (htab->elf.dynobj != NULL);
9876
9877   doneone = FALSE;
9878   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
9879     if (ent->plt.offset != (bfd_vma) -1)
9880       {
9881         if (!doneone)
9882           {
9883             Elf_Internal_Rela rela;
9884             bfd_byte *loc;
9885             bfd_vma reloc_index;
9886
9887             if (htab->plt_type == PLT_NEW
9888                 || !htab->elf.dynamic_sections_created
9889                 || h->dynindx == -1)
9890               reloc_index = ent->plt.offset / 4;
9891             else
9892               {
9893                 reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size)
9894                                / htab->plt_slot_size);
9895                 if (reloc_index > PLT_NUM_SINGLE_ENTRIES
9896                     && htab->plt_type == PLT_OLD)
9897                   reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
9898               }
9899
9900             /* This symbol has an entry in the procedure linkage table.
9901                Set it up.  */
9902             if (htab->plt_type == PLT_VXWORKS
9903                 && htab->elf.dynamic_sections_created
9904                 && h->dynindx != -1)
9905               {
9906                 bfd_vma got_offset;
9907                 const bfd_vma *plt_entry;
9908
9909                 /* The first three entries in .got.plt are reserved.  */
9910                 got_offset = (reloc_index + 3) * 4;
9911
9912                 /* Use the right PLT. */
9913                 plt_entry = bfd_link_pic (info) ? ppc_elf_vxworks_pic_plt_entry
9914                             : ppc_elf_vxworks_plt_entry;
9915
9916                 /* Fill in the .plt on VxWorks.  */
9917                 if (bfd_link_pic (info))
9918                   {
9919                     bfd_put_32 (output_bfd,
9920                                 plt_entry[0] | PPC_HA (got_offset),
9921                                 htab->plt->contents + ent->plt.offset + 0);
9922                     bfd_put_32 (output_bfd,
9923                                 plt_entry[1] | PPC_LO (got_offset),
9924                                 htab->plt->contents + ent->plt.offset + 4);
9925                   }
9926                 else
9927                   {
9928                     bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot);
9929
9930                     bfd_put_32 (output_bfd,
9931                                 plt_entry[0] | PPC_HA (got_loc),
9932                                 htab->plt->contents + ent->plt.offset + 0);
9933                     bfd_put_32 (output_bfd,
9934                                 plt_entry[1] | PPC_LO (got_loc),
9935                                 htab->plt->contents + ent->plt.offset + 4);
9936                   }
9937
9938                 bfd_put_32 (output_bfd, plt_entry[2],
9939                             htab->plt->contents + ent->plt.offset + 8);
9940                 bfd_put_32 (output_bfd, plt_entry[3],
9941                             htab->plt->contents + ent->plt.offset + 12);
9942
9943                 /* This instruction is an immediate load.  The value loaded is
9944                    the byte offset of the R_PPC_JMP_SLOT relocation from the
9945                    start of the .rela.plt section.  The value is stored in the
9946                    low-order 16 bits of the load instruction.  */
9947                 /* NOTE: It appears that this is now an index rather than a
9948                    prescaled offset.  */
9949                 bfd_put_32 (output_bfd,
9950                             plt_entry[4] | reloc_index,
9951                             htab->plt->contents + ent->plt.offset + 16);
9952                 /* This instruction is a PC-relative branch whose target is
9953                    the start of the PLT section.  The address of this branch
9954                    instruction is 20 bytes beyond the start of this PLT entry.
9955                    The address is encoded in bits 6-29, inclusive.  The value
9956                    stored is right-shifted by two bits, permitting a 26-bit
9957                    offset.  */
9958                 bfd_put_32 (output_bfd,
9959                             (plt_entry[5]
9960                              | (-(ent->plt.offset + 20) & 0x03fffffc)),
9961                             htab->plt->contents + ent->plt.offset + 20);
9962                 bfd_put_32 (output_bfd, plt_entry[6],
9963                             htab->plt->contents + ent->plt.offset + 24);
9964                 bfd_put_32 (output_bfd, plt_entry[7],
9965                             htab->plt->contents + ent->plt.offset + 28);
9966
9967                 /* Fill in the GOT entry corresponding to this PLT slot with
9968                    the address immediately after the "bctr" instruction
9969                    in this PLT entry.  */
9970                 bfd_put_32 (output_bfd, (htab->plt->output_section->vma
9971                                          + htab->plt->output_offset
9972                                          + ent->plt.offset + 16),
9973                             htab->sgotplt->contents + got_offset);
9974
9975                 if (!bfd_link_pic (info))
9976                   {
9977                     /* Fill in a couple of entries in .rela.plt.unloaded.  */
9978                     loc = htab->srelplt2->contents
9979                       + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index
9980                           * VXWORKS_PLT_NON_JMP_SLOT_RELOCS)
9981                          * sizeof (Elf32_External_Rela));
9982
9983                     /* Provide the @ha relocation for the first instruction.  */
9984                     rela.r_offset = (htab->plt->output_section->vma
9985                                      + htab->plt->output_offset
9986                                      + ent->plt.offset + 2);
9987                     rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9988                                                 R_PPC_ADDR16_HA);
9989                     rela.r_addend = got_offset;
9990                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9991                     loc += sizeof (Elf32_External_Rela);
9992
9993                     /* Provide the @l relocation for the second instruction.  */
9994                     rela.r_offset = (htab->plt->output_section->vma
9995                                      + htab->plt->output_offset
9996                                      + ent->plt.offset + 6);
9997                     rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9998                                                 R_PPC_ADDR16_LO);
9999                     rela.r_addend = got_offset;
10000                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10001                     loc += sizeof (Elf32_External_Rela);
10002
10003                     /* Provide a relocation for the GOT entry corresponding to this
10004                        PLT slot.  Point it at the middle of the .plt entry.  */
10005                     rela.r_offset = (htab->sgotplt->output_section->vma
10006                                      + htab->sgotplt->output_offset
10007                                      + got_offset);
10008                     rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
10009                                                 R_PPC_ADDR32);
10010                     rela.r_addend = ent->plt.offset + 16;
10011                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10012                   }
10013
10014                 /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT.
10015                    In particular, the offset for the relocation is not the
10016                    address of the PLT entry for this function, as specified
10017                    by the ABI.  Instead, the offset is set to the address of
10018                    the GOT slot for this function.  See EABI 4.4.4.1.  */
10019                 rela.r_offset = (htab->sgotplt->output_section->vma
10020                                  + htab->sgotplt->output_offset
10021                                  + got_offset);
10022
10023               }
10024             else
10025               {
10026                 asection *splt = htab->plt;
10027                 if (!htab->elf.dynamic_sections_created
10028                     || h->dynindx == -1)
10029                   splt = htab->iplt;
10030
10031                 rela.r_offset = (splt->output_section->vma
10032                                  + splt->output_offset
10033                                  + ent->plt.offset);
10034                 if (htab->plt_type == PLT_OLD
10035                     || !htab->elf.dynamic_sections_created
10036                     || h->dynindx == -1)
10037                   {
10038                     /* We don't need to fill in the .plt.  The ppc dynamic
10039                        linker will fill it in.  */
10040                   }
10041                 else
10042                   {
10043                     bfd_vma val = (htab->glink_pltresolve + ent->plt.offset
10044                                    + htab->glink->output_section->vma
10045                                    + htab->glink->output_offset);
10046                     bfd_put_32 (output_bfd, val,
10047                                 splt->contents + ent->plt.offset);
10048                   }
10049               }
10050
10051             /* Fill in the entry in the .rela.plt section.  */
10052             rela.r_addend = 0;
10053             if (!htab->elf.dynamic_sections_created
10054                 || h->dynindx == -1)
10055               {
10056                 BFD_ASSERT (h->type == STT_GNU_IFUNC
10057                             && h->def_regular
10058                             && (h->root.type == bfd_link_hash_defined
10059                                 || h->root.type == bfd_link_hash_defweak));
10060                 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
10061                 rela.r_addend = SYM_VAL (h);
10062               }
10063             else
10064               rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
10065
10066             if (!htab->elf.dynamic_sections_created
10067                 || h->dynindx == -1)
10068               loc = (htab->reliplt->contents
10069                      + (htab->reliplt->reloc_count++
10070                         * sizeof (Elf32_External_Rela)));
10071             else
10072               loc = (htab->relplt->contents
10073                      + reloc_index * sizeof (Elf32_External_Rela));
10074             bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10075
10076             if (!h->def_regular)
10077               {
10078                 /* Mark the symbol as undefined, rather than as
10079                    defined in the .plt section.  Leave the value if
10080                    there were any relocations where pointer equality
10081                    matters (this is a clue for the dynamic linker, to
10082                    make function pointer comparisons work between an
10083                    application and shared library), otherwise set it
10084                    to zero.  */
10085                 sym->st_shndx = SHN_UNDEF;
10086                 if (!h->pointer_equality_needed)
10087                   sym->st_value = 0;
10088                 else if (!h->ref_regular_nonweak)
10089                   {
10090                     /* This breaks function pointer comparisons, but
10091                        that is better than breaking tests for a NULL
10092                        function pointer.  */
10093                     sym->st_value = 0;
10094                   }
10095               }
10096             else if (h->type == STT_GNU_IFUNC
10097                      && !bfd_link_pic (info))
10098               {
10099                 /* Set the value of ifunc symbols in a non-pie
10100                    executable to the glink entry.  This is to avoid
10101                    text relocations.  We can't do this for ifunc in
10102                    allocate_dynrelocs, as we do for normal dynamic
10103                    function symbols with plt entries, because we need
10104                    to keep the original value around for the ifunc
10105                    relocation.  */
10106                 sym->st_shndx = (_bfd_elf_section_from_bfd_section
10107                                  (output_bfd, htab->glink->output_section));
10108                 sym->st_value = (ent->glink_offset
10109                                  + htab->glink->output_offset
10110                                  + htab->glink->output_section->vma);
10111               }
10112             doneone = TRUE;
10113           }
10114
10115         if (htab->plt_type == PLT_NEW
10116             || !htab->elf.dynamic_sections_created
10117             || h->dynindx == -1)
10118           {
10119             unsigned char *p;
10120             asection *splt = htab->plt;
10121             if (!htab->elf.dynamic_sections_created
10122                 || h->dynindx == -1)
10123               splt = htab->iplt;
10124
10125             p = (unsigned char *) htab->glink->contents + ent->glink_offset;
10126
10127             if (h == htab->tls_get_addr && !htab->params->no_tls_get_addr_opt)
10128               {
10129                 bfd_put_32 (output_bfd, LWZ_11_3, p);
10130                 p += 4;
10131                 bfd_put_32 (output_bfd, LWZ_12_3 + 4, p);
10132                 p += 4;
10133                 bfd_put_32 (output_bfd, MR_0_3, p);
10134                 p += 4;
10135                 bfd_put_32 (output_bfd, CMPWI_11_0, p);
10136                 p += 4;
10137                 bfd_put_32 (output_bfd, ADD_3_12_2, p);
10138                 p += 4;
10139                 bfd_put_32 (output_bfd, BEQLR, p);
10140                 p += 4;
10141                 bfd_put_32 (output_bfd, MR_3_0, p);
10142                 p += 4;
10143                 bfd_put_32 (output_bfd, NOP, p);
10144                 p += 4;
10145               }
10146
10147             write_glink_stub (ent, splt, p, info);
10148
10149             if (!bfd_link_pic (info))
10150               /* We only need one non-PIC glink stub.  */
10151               break;
10152           }
10153         else
10154           break;
10155       }
10156
10157   if (h->needs_copy)
10158     {
10159       asection *s;
10160       Elf_Internal_Rela rela;
10161       bfd_byte *loc;
10162
10163       /* This symbols needs a copy reloc.  Set it up.  */
10164
10165 #ifdef DEBUG
10166       fprintf (stderr, ", copy");
10167 #endif
10168
10169       BFD_ASSERT (h->dynindx != -1);
10170
10171       if (ppc_elf_hash_entry (h)->has_sda_refs)
10172         s = htab->relsbss;
10173       else
10174         s = htab->relbss;
10175       BFD_ASSERT (s != NULL);
10176
10177       rela.r_offset = SYM_VAL (h);
10178       rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
10179       rela.r_addend = 0;
10180       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
10181       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10182     }
10183
10184 #ifdef DEBUG
10185   fprintf (stderr, "\n");
10186 #endif
10187
10188   return TRUE;
10189 }
10190 \f
10191 static enum elf_reloc_type_class
10192 ppc_elf_reloc_type_class (const struct bfd_link_info *info,
10193                           const asection *rel_sec,
10194                           const Elf_Internal_Rela *rela)
10195 {
10196   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
10197
10198   if (rel_sec == htab->reliplt)
10199     return reloc_class_ifunc;
10200
10201   switch (ELF32_R_TYPE (rela->r_info))
10202     {
10203     case R_PPC_RELATIVE:
10204       return reloc_class_relative;
10205     case R_PPC_JMP_SLOT:
10206       return reloc_class_plt;
10207     case R_PPC_COPY:
10208       return reloc_class_copy;
10209     default:
10210       return reloc_class_normal;
10211     }
10212 }
10213 \f
10214 /* Finish up the dynamic sections.  */
10215
10216 static bfd_boolean
10217 ppc_elf_finish_dynamic_sections (bfd *output_bfd,
10218                                  struct bfd_link_info *info)
10219 {
10220   asection *sdyn;
10221   asection *splt;
10222   struct ppc_elf_link_hash_table *htab;
10223   bfd_vma got;
10224   bfd *dynobj;
10225   bfd_boolean ret = TRUE;
10226
10227 #ifdef DEBUG
10228   fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
10229 #endif
10230
10231   htab = ppc_elf_hash_table (info);
10232   dynobj = elf_hash_table (info)->dynobj;
10233   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
10234   if (htab->is_vxworks)
10235     splt = bfd_get_linker_section (dynobj, ".plt");
10236   else
10237     splt = NULL;
10238
10239   got = 0;
10240   if (htab->elf.hgot != NULL)
10241     got = SYM_VAL (htab->elf.hgot);
10242
10243   if (htab->elf.dynamic_sections_created)
10244     {
10245       Elf32_External_Dyn *dyncon, *dynconend;
10246
10247       BFD_ASSERT (htab->plt != NULL && sdyn != NULL);
10248
10249       dyncon = (Elf32_External_Dyn *) sdyn->contents;
10250       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
10251       for (; dyncon < dynconend; dyncon++)
10252         {
10253           Elf_Internal_Dyn dyn;
10254           asection *s;
10255
10256           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
10257
10258           switch (dyn.d_tag)
10259             {
10260             case DT_PLTGOT:
10261               if (htab->is_vxworks)
10262                 s = htab->sgotplt;
10263               else
10264                 s = htab->plt;
10265               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10266               break;
10267
10268             case DT_PLTRELSZ:
10269               dyn.d_un.d_val = htab->relplt->size;
10270               break;
10271
10272             case DT_JMPREL:
10273               s = htab->relplt;
10274               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10275               break;
10276
10277             case DT_PPC_GOT:
10278               dyn.d_un.d_ptr = got;
10279               break;
10280
10281             case DT_RELASZ:
10282               if (htab->is_vxworks)
10283                 {
10284                   if (htab->relplt)
10285                     dyn.d_un.d_ptr -= htab->relplt->size;
10286                   break;
10287                 }
10288               continue;
10289
10290             default:
10291               if (htab->is_vxworks
10292                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
10293                 break;
10294               continue;
10295             }
10296
10297           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
10298         }
10299     }
10300
10301   if (htab->got != NULL)
10302     {
10303       if (htab->elf.hgot->root.u.def.section == htab->got
10304           || htab->elf.hgot->root.u.def.section == htab->sgotplt)
10305         {
10306           unsigned char *p = htab->elf.hgot->root.u.def.section->contents;
10307
10308           p += htab->elf.hgot->root.u.def.value;
10309           if (htab->plt_type == PLT_OLD)
10310             {
10311               /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4
10312                  so that a function can easily find the address of
10313                  _GLOBAL_OFFSET_TABLE_.  */
10314               BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4
10315                           < htab->elf.hgot->root.u.def.section->size);
10316               bfd_put_32 (output_bfd, 0x4e800021, p - 4);
10317             }
10318
10319           if (sdyn != NULL)
10320             {
10321               bfd_vma val = sdyn->output_section->vma + sdyn->output_offset;
10322               BFD_ASSERT (htab->elf.hgot->root.u.def.value
10323                           < htab->elf.hgot->root.u.def.section->size);
10324               bfd_put_32 (output_bfd, val, p);
10325             }
10326         }
10327       else
10328         {
10329           info->callbacks->einfo (_("%P: %s not defined in linker created %s\n"),
10330                                   htab->elf.hgot->root.root.string,
10331                                   (htab->sgotplt != NULL
10332                                    ? htab->sgotplt->name : htab->got->name));
10333           bfd_set_error (bfd_error_bad_value);
10334           ret = FALSE;
10335         }
10336
10337       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
10338     }
10339
10340   /* Fill in the first entry in the VxWorks procedure linkage table.  */
10341   if (splt && splt->size > 0)
10342     {
10343       /* Use the right PLT. */
10344       const bfd_vma *plt_entry = (bfd_link_pic (info)
10345                                   ? ppc_elf_vxworks_pic_plt0_entry
10346                                   : ppc_elf_vxworks_plt0_entry);
10347
10348       if (!bfd_link_pic (info))
10349         {
10350           bfd_vma got_value = SYM_VAL (htab->elf.hgot);
10351
10352           bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value),
10353                       splt->contents +  0);
10354           bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value),
10355                       splt->contents +  4);
10356         }
10357       else
10358         {
10359           bfd_put_32 (output_bfd, plt_entry[0], splt->contents +  0);
10360           bfd_put_32 (output_bfd, plt_entry[1], splt->contents +  4);
10361         }
10362       bfd_put_32 (output_bfd, plt_entry[2], splt->contents +  8);
10363       bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12);
10364       bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16);
10365       bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20);
10366       bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24);
10367       bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28);
10368
10369       if (! bfd_link_pic (info))
10370         {
10371           Elf_Internal_Rela rela;
10372           bfd_byte *loc;
10373
10374           loc = htab->srelplt2->contents;
10375
10376           /* Output the @ha relocation for the first instruction.  */
10377           rela.r_offset = (htab->plt->output_section->vma
10378                            + htab->plt->output_offset
10379                            + 2);
10380           rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
10381           rela.r_addend = 0;
10382           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10383           loc += sizeof (Elf32_External_Rela);
10384
10385           /* Output the @l relocation for the second instruction.  */
10386           rela.r_offset = (htab->plt->output_section->vma
10387                            + htab->plt->output_offset
10388                            + 6);
10389           rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
10390           rela.r_addend = 0;
10391           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10392           loc += sizeof (Elf32_External_Rela);
10393
10394           /* Fix up the remaining relocations.  They may have the wrong
10395              symbol index for _G_O_T_ or _P_L_T_ depending on the order
10396              in which symbols were output.  */
10397           while (loc < htab->srelplt2->contents + htab->srelplt2->size)
10398             {
10399               Elf_Internal_Rela rel;
10400
10401               bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10402               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
10403               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10404               loc += sizeof (Elf32_External_Rela);
10405
10406               bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10407               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
10408               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10409               loc += sizeof (Elf32_External_Rela);
10410
10411               bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10412               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32);
10413               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10414               loc += sizeof (Elf32_External_Rela);
10415             }
10416         }
10417     }
10418
10419   if (htab->glink != NULL
10420       && htab->glink->contents != NULL
10421       && htab->elf.dynamic_sections_created)
10422     {
10423       unsigned char *p;
10424       unsigned char *endp;
10425       bfd_vma res0;
10426       unsigned int i;
10427
10428       /*
10429        * PIC glink code is the following:
10430        *
10431        * # ith PLT code stub.
10432        *   addis 11,30,(plt+(i-1)*4-got)@ha
10433        *   lwz 11,(plt+(i-1)*4-got)@l(11)
10434        *   mtctr 11
10435        *   bctr
10436        *
10437        * # A table of branches, one for each plt entry.
10438        * # The idea is that the plt call stub loads ctr and r11 with these
10439        * # addresses, so (r11 - res_0) gives the plt index * 4.
10440        * res_0: b PLTresolve
10441        * res_1: b PLTresolve
10442        * .
10443        * # Some number of entries towards the end can be nops
10444        * res_n_m3: nop
10445        * res_n_m2: nop
10446        * res_n_m1:
10447        *
10448        * PLTresolve:
10449        *    addis 11,11,(1f-res_0)@ha
10450        *    mflr 0
10451        *    bcl 20,31,1f
10452        * 1: addi 11,11,(1b-res_0)@l
10453        *    mflr 12
10454        *    mtlr 0
10455        *    sub 11,11,12                # r11 = index * 4
10456        *    addis 12,12,(got+4-1b)@ha
10457        *    lwz 0,(got+4-1b)@l(12)      # got[1] address of dl_runtime_resolve
10458        *    lwz 12,(got+8-1b)@l(12)     # got[2] contains the map address
10459        *    mtctr 0
10460        *    add 0,11,11
10461        *    add 11,0,11                 # r11 = index * 12 = reloc offset.
10462        *    bctr
10463        */
10464       static const unsigned int pic_plt_resolve[] =
10465         {
10466           ADDIS_11_11,
10467           MFLR_0,
10468           BCL_20_31,
10469           ADDI_11_11,
10470           MFLR_12,
10471           MTLR_0,
10472           SUB_11_11_12,
10473           ADDIS_12_12,
10474           LWZ_0_12,
10475           LWZ_12_12,
10476           MTCTR_0,
10477           ADD_0_11_11,
10478           ADD_11_0_11,
10479           BCTR,
10480           NOP,
10481           NOP
10482         };
10483
10484       /*
10485        * Non-PIC glink code is a little simpler.
10486        *
10487        * # ith PLT code stub.
10488        *   lis 11,(plt+(i-1)*4)@ha
10489        *   lwz 11,(plt+(i-1)*4)@l(11)
10490        *   mtctr 11
10491        *   bctr
10492        *
10493        * The branch table is the same, then comes
10494        *
10495        * PLTresolve:
10496        *    lis 12,(got+4)@ha
10497        *    addis 11,11,(-res_0)@ha
10498        *    lwz 0,(got+4)@l(12)         # got[1] address of dl_runtime_resolve
10499        *    addi 11,11,(-res_0)@l       # r11 = index * 4
10500        *    mtctr 0
10501        *    add 0,11,11
10502        *    lwz 12,(got+8)@l(12)        # got[2] contains the map address
10503        *    add 11,0,11                 # r11 = index * 12 = reloc offset.
10504        *    bctr
10505        */
10506       static const unsigned int plt_resolve[] =
10507         {
10508           LIS_12,
10509           ADDIS_11_11,
10510           LWZ_0_12,
10511           ADDI_11_11,
10512           MTCTR_0,
10513           ADD_0_11_11,
10514           LWZ_12_12,
10515           ADD_11_0_11,
10516           BCTR,
10517           NOP,
10518           NOP,
10519           NOP,
10520           NOP,
10521           NOP,
10522           NOP,
10523           NOP
10524         };
10525
10526       if (ARRAY_SIZE (pic_plt_resolve) != GLINK_PLTRESOLVE / 4)
10527         abort ();
10528       if (ARRAY_SIZE (plt_resolve) != GLINK_PLTRESOLVE / 4)
10529         abort ();
10530
10531       /* Build the branch table, one for each plt entry (less one),
10532          and perhaps some padding.  */
10533       p = htab->glink->contents;
10534       p += htab->glink_pltresolve;
10535       endp = htab->glink->contents;
10536       endp += htab->glink->size - GLINK_PLTRESOLVE;
10537       while (p < endp - (htab->params->ppc476_workaround ? 0 : 8 * 4))
10538         {
10539           bfd_put_32 (output_bfd, B + endp - p, p);
10540           p += 4;
10541         }
10542       while (p < endp)
10543         {
10544           bfd_put_32 (output_bfd, NOP, p);
10545           p += 4;
10546         }
10547
10548       res0 = (htab->glink_pltresolve
10549               + htab->glink->output_section->vma
10550               + htab->glink->output_offset);
10551
10552       if (htab->params->ppc476_workaround)
10553         {
10554           /* Ensure that a call stub at the end of a page doesn't
10555              result in prefetch over the end of the page into the
10556              glink branch table.  */
10557           bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
10558           bfd_vma page_addr;
10559           bfd_vma glink_start = (htab->glink->output_section->vma
10560                                  + htab->glink->output_offset);
10561
10562           for (page_addr = res0 & -pagesize;
10563                page_addr > glink_start;
10564                page_addr -= pagesize)
10565             {
10566               /* We have a plt call stub that may need fixing.  */
10567               bfd_byte *loc;
10568               unsigned int insn;
10569
10570               loc = htab->glink->contents + page_addr - 4 - glink_start;
10571               insn = bfd_get_32 (output_bfd, loc);
10572               if (insn == BCTR)
10573                 {
10574                   /* By alignment, we know that there must be at least
10575                      one other call stub before this one.  */
10576                   insn = bfd_get_32 (output_bfd, loc - 16);
10577                   if (insn == BCTR)
10578                     bfd_put_32 (output_bfd, B | (-16 & 0x3fffffc), loc);
10579                   else
10580                     bfd_put_32 (output_bfd, B | (-20 & 0x3fffffc), loc);
10581                 }
10582             }
10583         }
10584
10585       /* Last comes the PLTresolve stub.  */
10586       if (bfd_link_pic (info))
10587         {
10588           bfd_vma bcl;
10589
10590           for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++)
10591             {
10592               unsigned int insn = pic_plt_resolve[i];
10593
10594               if (htab->params->ppc476_workaround && insn == NOP)
10595                 insn = BA + 0;
10596               bfd_put_32 (output_bfd, insn, p);
10597               p += 4;
10598             }
10599           p -= 4 * ARRAY_SIZE (pic_plt_resolve);
10600
10601           bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4
10602                  + htab->glink->output_section->vma
10603                  + htab->glink->output_offset);
10604
10605           bfd_put_32 (output_bfd,
10606                       ADDIS_11_11 + PPC_HA (bcl - res0), p + 0*4);
10607           bfd_put_32 (output_bfd,
10608                       ADDI_11_11 + PPC_LO (bcl - res0), p + 3*4);
10609           bfd_put_32 (output_bfd,
10610                       ADDIS_12_12 + PPC_HA (got + 4 - bcl), p + 7*4);
10611           if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl))
10612             {
10613               bfd_put_32 (output_bfd,
10614                           LWZ_0_12 + PPC_LO (got + 4 - bcl), p + 8*4);
10615               bfd_put_32 (output_bfd,
10616                           LWZ_12_12 + PPC_LO (got + 8 - bcl), p + 9*4);
10617             }
10618           else
10619             {
10620               bfd_put_32 (output_bfd,
10621                           LWZU_0_12 + PPC_LO (got + 4 - bcl), p + 8*4);
10622               bfd_put_32 (output_bfd,
10623                           LWZ_12_12 + 4, p + 9*4);
10624             }
10625         }
10626       else
10627         {
10628           for (i = 0; i < ARRAY_SIZE (plt_resolve); i++)
10629             {
10630               unsigned int insn = plt_resolve[i];
10631
10632               if (htab->params->ppc476_workaround && insn == NOP)
10633                 insn = BA + 0;
10634               bfd_put_32 (output_bfd, insn, p);
10635               p += 4;
10636             }
10637           p -= 4 * ARRAY_SIZE (plt_resolve);
10638
10639           bfd_put_32 (output_bfd,
10640                       LIS_12 + PPC_HA (got + 4), p + 0*4);
10641           bfd_put_32 (output_bfd,
10642                       ADDIS_11_11 + PPC_HA (-res0), p + 1*4);
10643           bfd_put_32 (output_bfd,
10644                       ADDI_11_11 + PPC_LO (-res0), p + 3*4);
10645           if (PPC_HA (got + 4) == PPC_HA (got + 8))
10646             {
10647               bfd_put_32 (output_bfd,
10648                           LWZ_0_12 + PPC_LO (got + 4), p + 2*4);
10649               bfd_put_32 (output_bfd,
10650                           LWZ_12_12 + PPC_LO (got + 8), p + 6*4);
10651             }
10652           else
10653             {
10654               bfd_put_32 (output_bfd,
10655                           LWZU_0_12 + PPC_LO (got + 4), p + 2*4);
10656               bfd_put_32 (output_bfd,
10657                           LWZ_12_12 + 4, p + 6*4);
10658             }
10659         }
10660     }
10661
10662   if (htab->glink_eh_frame != NULL
10663       && htab->glink_eh_frame->contents != NULL)
10664     {
10665       unsigned char *p = htab->glink_eh_frame->contents;
10666       bfd_vma val;
10667
10668       p += sizeof (glink_eh_frame_cie);
10669       /* FDE length.  */
10670       p += 4;
10671       /* CIE pointer.  */
10672       p += 4;
10673       /* Offset to .glink.  */
10674       val = (htab->glink->output_section->vma
10675              + htab->glink->output_offset);
10676       val -= (htab->glink_eh_frame->output_section->vma
10677               + htab->glink_eh_frame->output_offset);
10678       val -= p - htab->glink_eh_frame->contents;
10679       bfd_put_32 (htab->elf.dynobj, val, p);
10680
10681       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
10682           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
10683                                                htab->glink_eh_frame,
10684                                                htab->glink_eh_frame->contents))
10685         return FALSE;
10686     }
10687
10688   return ret;
10689 }
10690 \f
10691 #define TARGET_LITTLE_SYM       powerpc_elf32_le_vec
10692 #define TARGET_LITTLE_NAME      "elf32-powerpcle"
10693 #define TARGET_BIG_SYM          powerpc_elf32_vec
10694 #define TARGET_BIG_NAME         "elf32-powerpc"
10695 #define ELF_ARCH                bfd_arch_powerpc
10696 #define ELF_TARGET_ID           PPC32_ELF_DATA
10697 #define ELF_MACHINE_CODE        EM_PPC
10698 #ifdef __QNXTARGET__
10699 #define ELF_MAXPAGESIZE         0x1000
10700 #define ELF_COMMONPAGESIZE      0x1000
10701 #else
10702 #define ELF_MAXPAGESIZE         0x10000
10703 #define ELF_COMMONPAGESIZE      0x10000
10704 #endif
10705 #define ELF_MINPAGESIZE         0x1000
10706 #define elf_info_to_howto       ppc_elf_info_to_howto
10707
10708 #ifdef  EM_CYGNUS_POWERPC
10709 #define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
10710 #endif
10711
10712 #ifdef EM_PPC_OLD
10713 #define ELF_MACHINE_ALT2        EM_PPC_OLD
10714 #endif
10715
10716 #define elf_backend_plt_not_loaded      1
10717 #define elf_backend_can_gc_sections     1
10718 #define elf_backend_can_refcount        1
10719 #define elf_backend_rela_normal         1
10720 #define elf_backend_caches_rawsize      1
10721
10722 #define bfd_elf32_mkobject                      ppc_elf_mkobject
10723 #define bfd_elf32_bfd_merge_private_bfd_data    ppc_elf_merge_private_bfd_data
10724 #define bfd_elf32_bfd_relax_section             ppc_elf_relax_section
10725 #define bfd_elf32_bfd_reloc_type_lookup         ppc_elf_reloc_type_lookup
10726 #define bfd_elf32_bfd_reloc_name_lookup         ppc_elf_reloc_name_lookup
10727 #define bfd_elf32_bfd_set_private_flags         ppc_elf_set_private_flags
10728 #define bfd_elf32_bfd_link_hash_table_create    ppc_elf_link_hash_table_create
10729 #define bfd_elf32_get_synthetic_symtab          ppc_elf_get_synthetic_symtab
10730
10731 #define elf_backend_object_p                    ppc_elf_object_p
10732 #define elf_backend_gc_mark_hook                ppc_elf_gc_mark_hook
10733 #define elf_backend_gc_sweep_hook               ppc_elf_gc_sweep_hook
10734 #define elf_backend_section_from_shdr           ppc_elf_section_from_shdr
10735 #define elf_backend_relocate_section            ppc_elf_relocate_section
10736 #define elf_backend_create_dynamic_sections     ppc_elf_create_dynamic_sections
10737 #define elf_backend_check_relocs                ppc_elf_check_relocs
10738 #define elf_backend_copy_indirect_symbol        ppc_elf_copy_indirect_symbol
10739 #define elf_backend_adjust_dynamic_symbol       ppc_elf_adjust_dynamic_symbol
10740 #define elf_backend_add_symbol_hook             ppc_elf_add_symbol_hook
10741 #define elf_backend_size_dynamic_sections       ppc_elf_size_dynamic_sections
10742 #define elf_backend_hash_symbol                 ppc_elf_hash_symbol
10743 #define elf_backend_finish_dynamic_symbol       ppc_elf_finish_dynamic_symbol
10744 #define elf_backend_finish_dynamic_sections     ppc_elf_finish_dynamic_sections
10745 #define elf_backend_fake_sections               ppc_elf_fake_sections
10746 #define elf_backend_additional_program_headers  ppc_elf_additional_program_headers
10747 #define elf_backend_modify_segment_map          ppc_elf_modify_segment_map
10748 #define elf_backend_grok_prstatus               ppc_elf_grok_prstatus
10749 #define elf_backend_grok_psinfo                 ppc_elf_grok_psinfo
10750 #define elf_backend_write_core_note             ppc_elf_write_core_note
10751 #define elf_backend_reloc_type_class            ppc_elf_reloc_type_class
10752 #define elf_backend_begin_write_processing      ppc_elf_begin_write_processing
10753 #define elf_backend_final_write_processing      ppc_elf_final_write_processing
10754 #define elf_backend_write_section               ppc_elf_write_section
10755 #define elf_backend_get_sec_type_attr           ppc_elf_get_sec_type_attr
10756 #define elf_backend_plt_sym_val                 ppc_elf_plt_sym_val
10757 #define elf_backend_action_discarded            ppc_elf_action_discarded
10758 #define elf_backend_init_index_section          _bfd_elf_init_1_index_section
10759 #define elf_backend_lookup_section_flags_hook   ppc_elf_lookup_section_flags
10760 #define elf_backend_section_processing          ppc_elf_section_processing
10761
10762 #include "elf32-target.h"
10763
10764 /* FreeBSD Target */
10765
10766 #undef  TARGET_LITTLE_SYM
10767 #undef  TARGET_LITTLE_NAME
10768
10769 #undef  TARGET_BIG_SYM
10770 #define TARGET_BIG_SYM  powerpc_elf32_fbsd_vec
10771 #undef  TARGET_BIG_NAME
10772 #define TARGET_BIG_NAME "elf32-powerpc-freebsd"
10773
10774 #undef  ELF_OSABI
10775 #define ELF_OSABI       ELFOSABI_FREEBSD
10776
10777 #undef  elf32_bed
10778 #define elf32_bed       elf32_powerpc_fbsd_bed
10779
10780 #include "elf32-target.h"
10781
10782 /* VxWorks Target */
10783
10784 #undef TARGET_LITTLE_SYM
10785 #undef TARGET_LITTLE_NAME
10786
10787 #undef TARGET_BIG_SYM
10788 #define TARGET_BIG_SYM          powerpc_elf32_vxworks_vec
10789 #undef TARGET_BIG_NAME
10790 #define TARGET_BIG_NAME         "elf32-powerpc-vxworks"
10791
10792 #undef  ELF_OSABI
10793
10794 /* VxWorks uses the elf default section flags for .plt.  */
10795 static const struct bfd_elf_special_section *
10796 ppc_elf_vxworks_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
10797 {
10798   if (sec->name == NULL)
10799     return NULL;
10800
10801   if (strcmp (sec->name, ".plt") == 0)
10802     return _bfd_elf_get_sec_type_attr (abfd, sec);
10803
10804   return ppc_elf_get_sec_type_attr (abfd, sec);
10805 }
10806
10807 /* Like ppc_elf_link_hash_table_create, but overrides
10808    appropriately for VxWorks.  */
10809 static struct bfd_link_hash_table *
10810 ppc_elf_vxworks_link_hash_table_create (bfd *abfd)
10811 {
10812   struct bfd_link_hash_table *ret;
10813
10814   ret = ppc_elf_link_hash_table_create (abfd);
10815   if (ret)
10816     {
10817       struct ppc_elf_link_hash_table *htab
10818         = (struct ppc_elf_link_hash_table *)ret;
10819       htab->is_vxworks = 1;
10820       htab->plt_type = PLT_VXWORKS;
10821       htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE;
10822       htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE;
10823       htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE;
10824     }
10825   return ret;
10826 }
10827
10828 /* Tweak magic VxWorks symbols as they are loaded.  */
10829 static bfd_boolean
10830 ppc_elf_vxworks_add_symbol_hook (bfd *abfd,
10831                                  struct bfd_link_info *info,
10832                                  Elf_Internal_Sym *sym,
10833                                  const char **namep ATTRIBUTE_UNUSED,
10834                                  flagword *flagsp ATTRIBUTE_UNUSED,
10835                                  asection **secp,
10836                                  bfd_vma *valp)
10837 {
10838   if (!elf_vxworks_add_symbol_hook(abfd, info, sym,namep, flagsp, secp,
10839                                    valp))
10840     return FALSE;
10841
10842   return ppc_elf_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, valp);
10843 }
10844
10845 static void
10846 ppc_elf_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
10847 {
10848   ppc_elf_final_write_processing(abfd, linker);
10849   elf_vxworks_final_write_processing(abfd, linker);
10850 }
10851
10852 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
10853    define it.  */
10854 #undef elf_backend_want_plt_sym
10855 #define elf_backend_want_plt_sym                1
10856 #undef elf_backend_want_got_plt
10857 #define elf_backend_want_got_plt                1
10858 #undef elf_backend_got_symbol_offset
10859 #define elf_backend_got_symbol_offset           0
10860 #undef elf_backend_plt_not_loaded
10861 #define elf_backend_plt_not_loaded              0
10862 #undef elf_backend_plt_readonly
10863 #define elf_backend_plt_readonly                1
10864 #undef elf_backend_got_header_size
10865 #define elf_backend_got_header_size             12
10866
10867 #undef bfd_elf32_get_synthetic_symtab
10868
10869 #undef bfd_elf32_bfd_link_hash_table_create
10870 #define bfd_elf32_bfd_link_hash_table_create \
10871   ppc_elf_vxworks_link_hash_table_create
10872 #undef elf_backend_add_symbol_hook
10873 #define elf_backend_add_symbol_hook \
10874   ppc_elf_vxworks_add_symbol_hook
10875 #undef elf_backend_link_output_symbol_hook
10876 #define elf_backend_link_output_symbol_hook \
10877   elf_vxworks_link_output_symbol_hook
10878 #undef elf_backend_final_write_processing
10879 #define elf_backend_final_write_processing \
10880   ppc_elf_vxworks_final_write_processing
10881 #undef elf_backend_get_sec_type_attr
10882 #define elf_backend_get_sec_type_attr \
10883   ppc_elf_vxworks_get_sec_type_attr
10884 #undef elf_backend_emit_relocs
10885 #define elf_backend_emit_relocs \
10886   elf_vxworks_emit_relocs
10887
10888 #undef elf32_bed
10889 #define elf32_bed                               ppc_elf_vxworks_bed
10890 #undef elf_backend_post_process_headers
10891
10892 #include "elf32-target.h"