bfd/elf32-ppc.c

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