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