bfd/elf32-ppc.c

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