bfd/elf32-ppc.c

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