bfd/elf32-ppc.c

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