bfd/elf32-ppc.c

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