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