bfd/elf32-ppc.c

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