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