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