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