bfd/elf32-ppc.c

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