bfd/elf32-ppc.c

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