bfd/elf32-ppc.c

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