bfd/elf32-ppc.c

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