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