bfd/elf32-ppc.c

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