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