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