bfd/elf32-ppc.c

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