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