bfd/elf32-ppc.c

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