bfd/elf32-ppc.c

   1 /* PowerPC-specific support for 32-bit ELF
   2    Copyright 1994, 1995, 1996 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 2 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 Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* This file is based on a preliminary PowerPC ELF ABI.  The
  22    information may not match the final PowerPC ELF ABI.  It includes
  23    suggestions from the in-progress Embedded PowerPC ABI, and that
  24    information may also not match.  */
  25
  26 #include "bfd.h"
  27 #include "sysdep.h"
  28 #include "bfdlink.h"
  29 #include "libbfd.h"
  30 #include "elf-bfd.h"
  31 #include "elf/ppc.h"
  32
  33 #define USE_RELA                /* we want RELA relocations, not REL */
  34
  35 /* PowerPC relocations defined by the ABIs */
  36 enum ppc_reloc_type
  37 {
  38   R_PPC_NONE                    =   0,
  39   R_PPC_ADDR32                  =   1,
  40   R_PPC_ADDR24                  =   2,
  41   R_PPC_ADDR16                  =   3,
  42   R_PPC_ADDR16_LO               =   4,
  43   R_PPC_ADDR16_HI               =   5,
  44   R_PPC_ADDR16_HA               =   6,
  45   R_PPC_ADDR14                  =   7,
  46   R_PPC_ADDR14_BRTAKEN          =   8,
  47   R_PPC_ADDR14_BRNTAKEN         =   9,
  48   R_PPC_REL24                   =  10,
  49   R_PPC_REL14                   =  11,
  50   R_PPC_REL14_BRTAKEN           =  12,
  51   R_PPC_REL14_BRNTAKEN          =  13,
  52   R_PPC_GOT16                   =  14,
  53   R_PPC_GOT16_LO                =  15,
  54   R_PPC_GOT16_HI                =  16,
  55   R_PPC_GOT16_HA                =  17,
  56   R_PPC_PLTREL24                =  18,
  57   R_PPC_COPY                    =  19,
  58   R_PPC_GLOB_DAT                =  20,
  59   R_PPC_JMP_SLOT                =  21,
  60   R_PPC_RELATIVE                =  22,
  61   R_PPC_LOCAL24PC               =  23,
  62   R_PPC_UADDR32                 =  24,
  63   R_PPC_UADDR16                 =  25,
  64   R_PPC_REL32                   =  26,
  65   R_PPC_PLT32                   =  27,
  66   R_PPC_PLTREL32                =  28,
  67   R_PPC_PLT16_LO                =  29,
  68   R_PPC_PLT16_HI                =  30,
  69   R_PPC_PLT16_HA                =  31,
  70   R_PPC_SDAREL16                =  32,
  71   R_PPC_SECTOFF                 =  33,
  72   R_PPC_SECTOFF_LO              =  34,
  73   R_PPC_SECTOFF_HI              =  35,
  74   R_PPC_SECTOFF_HA              =  36,
  75
  76   /* The remaining relocs are from the Embedded ELF ABI, and are not
  77      in the SVR4 ELF ABI.  */
  78   R_PPC_EMB_NADDR32             = 101,
  79   R_PPC_EMB_NADDR16             = 102,
  80   R_PPC_EMB_NADDR16_LO          = 103,
  81   R_PPC_EMB_NADDR16_HI          = 104,
  82   R_PPC_EMB_NADDR16_HA          = 105,
  83   R_PPC_EMB_SDAI16              = 106,
  84   R_PPC_EMB_SDA2I16             = 107,
  85   R_PPC_EMB_SDA2REL             = 108,
  86   R_PPC_EMB_SDA21               = 109,
  87   R_PPC_EMB_MRKREF              = 110,
  88   R_PPC_EMB_RELSEC16            = 111,
  89   R_PPC_EMB_RELST_LO            = 112,
  90   R_PPC_EMB_RELST_HI            = 113,
  91   R_PPC_EMB_RELST_HA            = 114,
  92   R_PPC_EMB_BIT_FLD             = 115,
  93   R_PPC_EMB_RELSDA              = 116,
  94
  95   /* This is a phony reloc to handle any old fashioned TOC16 references
  96      that may still be in object files.  */
  97   R_PPC_TOC16                   = 255,
  98
  99   R_PPC_max
 100 };
 101
 102 static reloc_howto_type *ppc_elf_reloc_type_lookup
 103   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
 104 static void ppc_elf_info_to_howto
 105   PARAMS ((bfd *abfd, arelent *cache_ptr, Elf32_Internal_Rela *dst));
 106 static void ppc_elf_howto_init PARAMS ((void));
 107 static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword));
 108 static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
 109 static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
 110
 111 static boolean ppc_elf_section_from_shdr PARAMS ((bfd *,
 112                                                   Elf32_Internal_Shdr *,
 113                                                   char *));
 114
 115 static elf_linker_section_t *ppc_elf_create_linker_section
 116   PARAMS ((bfd *abfd,
 117            struct bfd_link_info *info,
 118            enum elf_linker_section_enum));
 119
 120 static boolean ppc_elf_check_relocs PARAMS ((bfd *,
 121                                              struct bfd_link_info *,
 122                                              asection *,
 123                                              const Elf_Internal_Rela *));
 124
 125 static boolean ppc_elf_adjust_dynamic_symbol PARAMS ((struct bfd_link_info *,
 126                                                       struct elf_link_hash_entry *));
 127
 128 static boolean ppc_elf_adjust_dynindx PARAMS ((struct elf_link_hash_entry *, PTR));
 129
 130 static boolean ppc_elf_size_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
 131
 132 static boolean ppc_elf_relocate_section PARAMS ((bfd *,
 133                                                  struct bfd_link_info *info,
 134                                                  bfd *,
 135                                                  asection *,
 136                                                  bfd_byte *,
 137                                                  Elf_Internal_Rela *relocs,
 138                                                  Elf_Internal_Sym *local_syms,
 139                                                  asection **));
 140
 141 static boolean ppc_elf_finish_dynamic_symbol PARAMS ((bfd *,
 142                                                       struct bfd_link_info *,
 143                                                       struct elf_link_hash_entry *,
 144                                                       Elf_Internal_Sym *));
 145
 146 static boolean ppc_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
 147
 148 #define BRANCH_PREDICT_BIT 0x200000
 149
 150 /* The name of the dynamic interpreter.  This is put in the .interp
 151    section.  */
 152
 153 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 154
 155 \f
 156 static reloc_howto_type *ppc_elf_howto_table[ (int)R_PPC_max ];
 157
 158 static reloc_howto_type ppc_elf_howto_raw[] =
 159 {
 160   /* This reloc does nothing.  */
 161   HOWTO (R_PPC_NONE,            /* type */
 162          0,                     /* rightshift */
 163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 164          32,                    /* bitsize */
 165          false,                 /* pc_relative */
 166          0,                     /* bitpos */
 167          complain_overflow_bitfield, /* complain_on_overflow */
 168          bfd_elf_generic_reloc, /* special_function */
 169          "R_PPC_NONE",          /* name */
 170          false,                 /* partial_inplace */
 171          0,                     /* src_mask */
 172          0,                     /* dst_mask */
 173          false),                /* pcrel_offset */
 174
 175   /* A standard 32 bit relocation.  */
 176   HOWTO (R_PPC_ADDR32,          /* type */
 177          0,                     /* rightshift */
 178          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 179          32,                    /* bitsize */
 180          false,                 /* pc_relative */
 181          0,                     /* bitpos */
 182          complain_overflow_bitfield, /* complain_on_overflow */
 183          bfd_elf_generic_reloc, /* special_function */
 184          "R_PPC_ADDR32",        /* name */
 185          false,                 /* partial_inplace */
 186          0,                     /* src_mask */
 187          0xffffffff,            /* dst_mask */
 188          false),                /* pcrel_offset */
 189
 190   /* An absolute 26 bit branch; the lower two bits must be zero.
 191      FIXME: we don't check that, we just clear them.  */
 192   HOWTO (R_PPC_ADDR24,          /* type */
 193          0,                     /* rightshift */
 194          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 195          26,                    /* bitsize */
 196          false,                 /* pc_relative */
 197          0,                     /* bitpos */
 198          complain_overflow_bitfield, /* complain_on_overflow */
 199          bfd_elf_generic_reloc, /* special_function */
 200          "R_PPC_ADDR24",        /* name */
 201          false,                 /* partial_inplace */
 202          0,                     /* src_mask */
 203          0x3fffffc,             /* dst_mask */
 204          false),                /* pcrel_offset */
 205
 206   /* A standard 16 bit relocation.  */
 207   HOWTO (R_PPC_ADDR16,          /* type */
 208          0,                     /* rightshift */
 209          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 210          16,                    /* bitsize */
 211          false,                 /* pc_relative */
 212          0,                     /* bitpos */
 213          complain_overflow_bitfield, /* complain_on_overflow */
 214          bfd_elf_generic_reloc, /* special_function */
 215          "R_PPC_ADDR16",        /* name */
 216          false,                 /* partial_inplace */
 217          0,                     /* src_mask */
 218          0xffff,                /* dst_mask */
 219          false),                /* pcrel_offset */
 220
 221   /* A 16 bit relocation without overflow.  */
 222   HOWTO (R_PPC_ADDR16_LO,       /* type */
 223          0,                     /* rightshift */
 224          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 225          16,                    /* bitsize */
 226          false,                 /* pc_relative */
 227          0,                     /* bitpos */
 228          complain_overflow_dont,/* complain_on_overflow */
 229          bfd_elf_generic_reloc, /* special_function */
 230          "R_PPC_ADDR16_LO",     /* name */
 231          false,                 /* partial_inplace */
 232          0,                     /* src_mask */
 233          0xffff,                /* dst_mask */
 234          false),                /* pcrel_offset */
 235
 236   /* The high order 16 bits of an address.  */
 237   HOWTO (R_PPC_ADDR16_HI,       /* type */
 238          16,                    /* rightshift */
 239          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 240          16,                    /* bitsize */
 241          false,                 /* pc_relative */
 242          0,                     /* bitpos */
 243          complain_overflow_dont, /* complain_on_overflow */
 244          bfd_elf_generic_reloc, /* special_function */
 245          "R_PPC_ADDR16_HI",     /* name */
 246          false,                 /* partial_inplace */
 247          0,                     /* src_mask */
 248          0xffff,                /* dst_mask */
 249          false),                /* pcrel_offset */
 250
 251   /* The high order 16 bits of an address, plus 1 if the contents of
 252      the low 16 bits, treated as a signed number, is negative.  */
 253   HOWTO (R_PPC_ADDR16_HA,       /* type */
 254          16,                    /* rightshift */
 255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 256          16,                    /* bitsize */
 257          false,                 /* pc_relative */
 258          0,                     /* bitpos */
 259          complain_overflow_dont, /* complain_on_overflow */
 260          bfd_elf_generic_reloc, /* special_function */
 261          "R_PPC_ADDR16_HA",     /* name */
 262          false,                 /* partial_inplace */
 263          0,                     /* src_mask */
 264          0xffff,                /* dst_mask */
 265          false),                /* pcrel_offset */
 266
 267   /* An absolute 16 bit branch; the lower two bits must be zero.
 268      FIXME: we don't check that, we just clear them.  */
 269   HOWTO (R_PPC_ADDR14,          /* type */
 270          0,                     /* rightshift */
 271          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          16,                    /* bitsize */
 273          false,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_bitfield, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC_ADDR14",        /* name */
 278          false,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0xfffc,                /* dst_mask */
 281          false),                /* pcrel_offset */
 282
 283   /* An absolute 16 bit branch, for which bit 10 should be set to
 284      indicate that the branch is expected to be taken.  The lower two
 285      bits must be zero.  */
 286   HOWTO (R_PPC_ADDR14_BRTAKEN,  /* type */
 287          0,                     /* rightshift */
 288          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 289          16,                    /* bitsize */
 290          false,                 /* pc_relative */
 291          0,                     /* bitpos */
 292          complain_overflow_bitfield, /* complain_on_overflow */
 293          bfd_elf_generic_reloc, /* special_function */
 294          "R_PPC_ADDR14_BRTAKEN",/* name */
 295          false,                 /* partial_inplace */
 296          0,                     /* src_mask */
 297          0xfffc,                /* dst_mask */
 298          false),                /* pcrel_offset */
 299
 300   /* An absolute 16 bit branch, for which bit 10 should be set to
 301      indicate that the branch is not expected to be taken.  The lower
 302      two bits must be zero.  */
 303   HOWTO (R_PPC_ADDR14_BRNTAKEN, /* 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_bitfield, /* complain_on_overflow */
 310          bfd_elf_generic_reloc, /* special_function */
 311          "R_PPC_ADDR14_BRNTAKEN",/* name */
 312          false,                 /* partial_inplace */
 313          0,                     /* src_mask */
 314          0xfffc,                /* dst_mask */
 315          false),                /* pcrel_offset */
 316
 317   /* A relative 26 bit branch; the lower two bits must be zero.  */
 318   HOWTO (R_PPC_REL24,           /* type */
 319          0,                     /* rightshift */
 320          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 321          26,                    /* bitsize */
 322          true,                  /* pc_relative */
 323          0,                     /* bitpos */
 324          complain_overflow_signed, /* complain_on_overflow */
 325          bfd_elf_generic_reloc, /* special_function */
 326          "R_PPC_REL24",         /* name */
 327          false,                 /* partial_inplace */
 328          0,                     /* src_mask */
 329          0x3fffffc,             /* dst_mask */
 330          true),                 /* pcrel_offset */
 331
 332   /* A relative 16 bit branch; the lower two bits must be zero.  */
 333   HOWTO (R_PPC_REL14,           /* type */
 334          0,                     /* rightshift */
 335          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 336          16,                    /* bitsize */
 337          true,                  /* pc_relative */
 338          0,                     /* bitpos */
 339          complain_overflow_signed, /* complain_on_overflow */
 340          bfd_elf_generic_reloc, /* special_function */
 341          "R_PPC_REL14",         /* name */
 342          false,                 /* partial_inplace */
 343          0,                     /* src_mask */
 344          0xfffc,                /* dst_mask */
 345          true),                 /* pcrel_offset */
 346
 347   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 348      the branch is expected to be taken.  The lower two bits must be
 349      zero.  */
 350   HOWTO (R_PPC_REL14_BRTAKEN,   /* type */
 351          0,                     /* rightshift */
 352          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 353          16,                    /* bitsize */
 354          true,                  /* pc_relative */
 355          0,                     /* bitpos */
 356          complain_overflow_signed, /* complain_on_overflow */
 357          bfd_elf_generic_reloc, /* special_function */
 358          "R_PPC_REL14_BRTAKEN", /* name */
 359          false,                 /* partial_inplace */
 360          0,                     /* src_mask */
 361          0xfffc,                /* dst_mask */
 362          true),                 /* pcrel_offset */
 363
 364   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 365      the branch is not expected to be taken.  The lower two bits must
 366      be zero.  */
 367   HOWTO (R_PPC_REL14_BRNTAKEN,  /* 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_BRNTAKEN",/* name */
 376          false,                 /* partial_inplace */
 377          0,                     /* src_mask */
 378          0xfffc,                /* dst_mask */
 379          true),                 /* pcrel_offset */
 380
 381   /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
 382      symbol.  */
 383   HOWTO (R_PPC_GOT16,           /* type */
 384          0,                     /* rightshift */
 385          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 386          16,                    /* bitsize */
 387          false,                 /* pc_relative */
 388          0,                     /* bitpos */
 389          complain_overflow_signed, /* complain_on_overflow */
 390          bfd_elf_generic_reloc, /* special_function */
 391          "R_PPC_GOT16",         /* name */
 392          false,                 /* partial_inplace */
 393          0,                     /* src_mask */
 394          0xffff,                /* dst_mask */
 395          false),                /* pcrel_offset */
 396
 397   /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
 398      the symbol.  */
 399   HOWTO (R_PPC_GOT16_LO,        /* type */
 400          0,                     /* rightshift */
 401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 402          16,                    /* bitsize */
 403          false,                 /* pc_relative */
 404          0,                     /* bitpos */
 405          complain_overflow_bitfield, /* complain_on_overflow */
 406          bfd_elf_generic_reloc, /* special_function */
 407          "R_PPC_GOT16_LO",      /* name */
 408          false,                 /* partial_inplace */
 409          0,                     /* src_mask */
 410          0xffff,                /* dst_mask */
 411          false),                /* pcrel_offset */
 412
 413   /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
 414      the symbol.  */
 415   HOWTO (R_PPC_GOT16_HI,        /* type */
 416          16,                    /* rightshift */
 417          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 418          16,                    /* bitsize */
 419          false,                 /* pc_relative */
 420          0,                     /* bitpos */
 421          complain_overflow_bitfield, /* complain_on_overflow */
 422          bfd_elf_generic_reloc, /* special_function */
 423          "R_PPC_GOT16_HI",      /* name */
 424          false,                 /* partial_inplace */
 425          0,                     /* src_mask */
 426          0xffff,                /* dst_mask */
 427          false),                 /* pcrel_offset */
 428
 429   /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
 430      the symbol.  FIXME: Not supported.  */
 431   HOWTO (R_PPC_GOT16_HA,        /* type */
 432          0,                     /* rightshift */
 433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          16,                    /* bitsize */
 435          false,                 /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_bitfield, /* complain_on_overflow */
 438          bfd_elf_generic_reloc, /* special_function */
 439          "R_PPC_GOT16_HA",      /* name */
 440          false,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0xffff,                /* dst_mask */
 443          false),                /* pcrel_offset */
 444
 445   /* Like R_PPC_REL24, but referring to the procedure linkage table
 446      entry for the symbol.  FIXME: Not supported.  */
 447   HOWTO (R_PPC_PLTREL24,        /* type */
 448          0,                     /* rightshift */
 449          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 450          26,                    /* bitsize */
 451          true,                  /* pc_relative */
 452          0,                     /* bitpos */
 453          complain_overflow_signed,  /* complain_on_overflow */
 454          bfd_elf_generic_reloc, /* special_function */
 455          "R_PPC_PLTREL24",      /* name */
 456          false,                 /* partial_inplace */
 457          0,                     /* src_mask */
 458          0x3fffffc,             /* dst_mask */
 459          true),                 /* pcrel_offset */
 460
 461   /* This is used only by the dynamic linker.  The symbol should exist
 462      both in the object being run and in some shared library.  The
 463      dynamic linker copies the data addressed by the symbol from the
 464      shared library into the object.  I have no idea what the purpose
 465      of this is.  */
 466   HOWTO (R_PPC_COPY,            /* type */
 467          0,                     /* rightshift */
 468          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 469          32,                    /* bitsize */
 470          false,                 /* pc_relative */
 471          0,                     /* bitpos */
 472          complain_overflow_bitfield, /* complain_on_overflow */
 473          bfd_elf_generic_reloc,  /* special_function */
 474          "R_PPC_COPY",          /* name */
 475          false,                 /* partial_inplace */
 476          0,                     /* src_mask */
 477          0,                     /* dst_mask */
 478          false),                /* pcrel_offset */
 479
 480   /* Like R_PPC_ADDR32, but used when setting global offset table
 481      entries.  */
 482   HOWTO (R_PPC_GLOB_DAT,        /* type */
 483          0,                     /* rightshift */
 484          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 485          32,                    /* bitsize */
 486          false,                 /* pc_relative */
 487          0,                     /* bitpos */
 488          complain_overflow_bitfield, /* complain_on_overflow */
 489          bfd_elf_generic_reloc,  /* special_function */
 490          "R_PPC_GLOB_DAT",      /* name */
 491          false,                 /* partial_inplace */
 492          0,                     /* src_mask */
 493          0xffffffff,            /* dst_mask */
 494          false),                /* pcrel_offset */
 495
 496   /* Marks a procedure linkage table entry for a symbol.  */
 497   HOWTO (R_PPC_JMP_SLOT,        /* type */
 498          0,                     /* rightshift */
 499          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 500          32,                    /* bitsize */
 501          false,                 /* pc_relative */
 502          0,                     /* bitpos */
 503          complain_overflow_bitfield, /* complain_on_overflow */
 504          bfd_elf_generic_reloc,  /* special_function */
 505          "R_PPC_JMP_SLOT",      /* name */
 506          false,                 /* partial_inplace */
 507          0,                     /* src_mask */
 508          0,                     /* dst_mask */
 509          false),                /* pcrel_offset */
 510
 511   /* Used only by the dynamic linker.  When the object is run, this
 512      longword is set to the load address of the object, plus the
 513      addend.  */
 514   HOWTO (R_PPC_RELATIVE,        /* type */
 515          0,                     /* rightshift */
 516          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 517          32,                    /* bitsize */
 518          false,                 /* pc_relative */
 519          0,                     /* bitpos */
 520          complain_overflow_bitfield, /* complain_on_overflow */
 521          bfd_elf_generic_reloc,  /* special_function */
 522          "R_PPC_RELATIVE",      /* name */
 523          false,                 /* partial_inplace */
 524          0,                     /* src_mask */
 525          0xffffffff,            /* dst_mask */
 526          false),                /* pcrel_offset */
 527
 528   /* Like R_PPC_REL24, but uses the value of the symbol within the
 529      object rather than the final value.  Normally used for
 530      _GLOBAL_OFFSET_TABLE_.  FIXME: Not supported.  */
 531   HOWTO (R_PPC_LOCAL24PC,       /* type */
 532          0,                     /* rightshift */
 533          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 534          26,                    /* bitsize */
 535          true,                  /* pc_relative */
 536          0,                     /* bitpos */
 537          complain_overflow_signed, /* complain_on_overflow */
 538          bfd_elf_generic_reloc, /* special_function */
 539          "R_PPC_LOCAL24PC",     /* name */
 540          false,                 /* partial_inplace */
 541          0,                     /* src_mask */
 542          0x3fffffc,             /* dst_mask */
 543          true),                 /* pcrel_offset */
 544
 545   /* Like R_PPC_ADDR32, but may be unaligned.  */
 546   HOWTO (R_PPC_UADDR32,         /* type */
 547          0,                     /* rightshift */
 548          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 549          32,                    /* bitsize */
 550          false,                 /* pc_relative */
 551          0,                     /* bitpos */
 552          complain_overflow_bitfield, /* complain_on_overflow */
 553          bfd_elf_generic_reloc, /* special_function */
 554          "R_PPC_UADDR32",       /* name */
 555          false,                 /* partial_inplace */
 556          0,                     /* src_mask */
 557          0xffffffff,            /* dst_mask */
 558          false),                /* pcrel_offset */
 559
 560   /* Like R_PPC_ADDR16, but may be unaligned.  */
 561   HOWTO (R_PPC_UADDR16,         /* type */
 562          0,                     /* rightshift */
 563          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 564          16,                    /* bitsize */
 565          false,                 /* pc_relative */
 566          0,                     /* bitpos */
 567          complain_overflow_bitfield, /* complain_on_overflow */
 568          bfd_elf_generic_reloc, /* special_function */
 569          "R_PPC_UADDR16",       /* name */
 570          false,                 /* partial_inplace */
 571          0,                     /* src_mask */
 572          0xffff,                /* dst_mask */
 573          false),                /* pcrel_offset */
 574
 575   /* 32-bit PC relative */
 576   HOWTO (R_PPC_REL32,           /* type */
 577          0,                     /* rightshift */
 578          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 579          32,                    /* bitsize */
 580          true,                  /* pc_relative */
 581          0,                     /* bitpos */
 582          complain_overflow_bitfield, /* complain_on_overflow */
 583          bfd_elf_generic_reloc, /* special_function */
 584          "R_PPC_REL32",         /* name */
 585          false,                 /* partial_inplace */
 586          0,                     /* src_mask */
 587          0xffffffff,            /* dst_mask */
 588          true),                 /* pcrel_offset */
 589
 590   /* 32-bit relocation to the symbol's procedure linkage table.
 591      FIXEME: not supported. */
 592   HOWTO (R_PPC_PLT32,           /* type */
 593          0,                     /* rightshift */
 594          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 595          32,                    /* bitsize */
 596          false,                 /* pc_relative */
 597          0,                     /* bitpos */
 598          complain_overflow_bitfield, /* complain_on_overflow */
 599          bfd_elf_generic_reloc, /* special_function */
 600          "R_PPC_PLT32",         /* name */
 601          false,                 /* partial_inplace */
 602          0,                     /* src_mask */
 603          0,                     /* dst_mask */
 604          false),                /* pcrel_offset */
 605
 606   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 607      FIXEME: not supported. */
 608   HOWTO (R_PPC_PLTREL32,        /* type */
 609          0,                     /* rightshift */
 610          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 611          32,                    /* bitsize */
 612          true,                  /* pc_relative */
 613          0,                     /* bitpos */
 614          complain_overflow_bitfield, /* complain_on_overflow */
 615          bfd_elf_generic_reloc, /* special_function */
 616          "R_PPC_PLTREL32",      /* name */
 617          false,                 /* partial_inplace */
 618          0,                     /* src_mask */
 619          0,                     /* dst_mask */
 620          true),                 /* pcrel_offset */
 621
 622   /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
 623      the symbol.  */
 624   HOWTO (R_PPC_PLT16_LO,        /* type */
 625          0,                     /* rightshift */
 626          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 627          16,                    /* bitsize */
 628          false,                 /* pc_relative */
 629          0,                     /* bitpos */
 630          complain_overflow_bitfield, /* complain_on_overflow */
 631          bfd_elf_generic_reloc, /* special_function */
 632          "R_PPC_PLT16_LO",      /* name */
 633          false,                 /* partial_inplace */
 634          0,                     /* src_mask */
 635          0xffff,                /* dst_mask */
 636          false),                /* pcrel_offset */
 637
 638   /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
 639      the symbol.  */
 640   HOWTO (R_PPC_PLT16_HI,        /* type */
 641          16,                    /* rightshift */
 642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 643          16,                    /* bitsize */
 644          false,                 /* pc_relative */
 645          0,                     /* bitpos */
 646          complain_overflow_bitfield, /* complain_on_overflow */
 647          bfd_elf_generic_reloc, /* special_function */
 648          "R_PPC_PLT16_HI",      /* name */
 649          false,                 /* partial_inplace */
 650          0,                     /* src_mask */
 651          0xffff,                /* dst_mask */
 652          false),                 /* pcrel_offset */
 653
 654   /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
 655      the symbol.  FIXME: Not supported.  */
 656   HOWTO (R_PPC_PLT16_HA,        /* type */
 657          0,                     /* rightshift */
 658          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 659          16,                    /* bitsize */
 660          false,                 /* pc_relative */
 661          0,                     /* bitpos */
 662          complain_overflow_bitfield, /* complain_on_overflow */
 663          bfd_elf_generic_reloc, /* special_function */
 664          "R_PPC_PLT16_HA",      /* name */
 665          false,                 /* partial_inplace */
 666          0,                     /* src_mask */
 667          0xffff,                /* dst_mask */
 668          false),                /* pcrel_offset */
 669
 670   /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
 671      small data items.  FIXME: Not supported.    */
 672   HOWTO (R_PPC_SDAREL16,        /* type */
 673          0,                     /* rightshift */
 674          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          16,                    /* bitsize */
 676          false,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_signed, /* complain_on_overflow */
 679          bfd_elf_generic_reloc, /* special_function */
 680          "R_PPC_SDAREL16",      /* name */
 681          false,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffff,                /* dst_mask */
 684          false),                /* pcrel_offset */
 685
 686   /* 32-bit section relative relocation. FIXME: not supported. */
 687   HOWTO (R_PPC_SECTOFF,         /* type */
 688          0,                     /* rightshift */
 689          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 690          32,                    /* bitsize */
 691          true,                  /* pc_relative */
 692          0,                     /* bitpos */
 693          complain_overflow_bitfield, /* complain_on_overflow */
 694          bfd_elf_generic_reloc, /* special_function */
 695          "R_PPC_SECTOFF",       /* name */
 696          false,                 /* partial_inplace */
 697          0,                     /* src_mask */
 698          0,                     /* dst_mask */
 699          true),                 /* pcrel_offset */
 700
 701   /* 16-bit lower half section relative relocation. FIXME: not supported. */
 702   HOWTO (R_PPC_SECTOFF_LO,        /* type */
 703          0,                     /* rightshift */
 704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 705          16,                    /* bitsize */
 706          false,                 /* pc_relative */
 707          0,                     /* bitpos */
 708          complain_overflow_bitfield, /* complain_on_overflow */
 709          bfd_elf_generic_reloc, /* special_function */
 710          "R_PPC_SECTOFF_LO",    /* name */
 711          false,                 /* partial_inplace */
 712          0,                     /* src_mask */
 713          0xffff,                /* dst_mask */
 714          false),                /* pcrel_offset */
 715
 716   /* 16-bit upper half section relative relocation. FIXME: not supported. */
 717   HOWTO (R_PPC_SECTOFF_HI,      /* type */
 718          16,                    /* rightshift */
 719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 720          16,                    /* bitsize */
 721          false,                 /* pc_relative */
 722          0,                     /* bitpos */
 723          complain_overflow_bitfield, /* complain_on_overflow */
 724          bfd_elf_generic_reloc, /* special_function */
 725          "R_PPC_SECTOFF_HI",    /* name */
 726          false,                 /* partial_inplace */
 727          0,                     /* src_mask */
 728          0xffff,                /* dst_mask */
 729          false),                 /* pcrel_offset */
 730
 731   /* 16-bit upper half adjusted section relative relocation. FIXME: not supported. */
 732   HOWTO (R_PPC_SECTOFF_HA,      /* type */
 733          0,                     /* rightshift */
 734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 735          16,                    /* bitsize */
 736          false,                 /* pc_relative */
 737          0,                     /* bitpos */
 738          complain_overflow_bitfield, /* complain_on_overflow */
 739          bfd_elf_generic_reloc, /* special_function */
 740          "R_PPC_SECTOFF_HA",    /* name */
 741          false,                 /* partial_inplace */
 742          0,                     /* src_mask */
 743          0xffff,                /* dst_mask */
 744          false),                /* pcrel_offset */
 745
 746   /* The remaining relocs are from the Embedded ELF ABI, and are not
 747      in the SVR4 ELF ABI.  */
 748
 749   /* 32 bit value resulting from the addend minus the symbol */
 750   HOWTO (R_PPC_EMB_NADDR32,     /* type */
 751          0,                     /* rightshift */
 752          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 753          32,                    /* bitsize */
 754          false,                 /* pc_relative */
 755          0,                     /* bitpos */
 756          complain_overflow_bitfield, /* complain_on_overflow */
 757          bfd_elf_generic_reloc, /* special_function */
 758          "R_PPC_EMB_NADDR32",   /* name */
 759          false,                 /* partial_inplace */
 760          0,                     /* src_mask */
 761          0xffffffff,            /* dst_mask */
 762          false),                /* pcrel_offset */
 763
 764   /* 16 bit value resulting from the addend minus the symbol */
 765   HOWTO (R_PPC_EMB_NADDR16,     /* type */
 766          0,                     /* rightshift */
 767          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 768          16,                    /* bitsize */
 769          false,                 /* pc_relative */
 770          0,                     /* bitpos */
 771          complain_overflow_bitfield, /* complain_on_overflow */
 772          bfd_elf_generic_reloc, /* special_function */
 773          "R_PPC_EMB_NADDR16",   /* name */
 774          false,                 /* partial_inplace */
 775          0,                     /* src_mask */
 776          0xffff,                /* dst_mask */
 777          false),                /* pcrel_offset */
 778
 779   /* 16 bit value resulting from the addend minus the symbol */
 780   HOWTO (R_PPC_EMB_NADDR16_LO,  /* type */
 781          0,                     /* rightshift */
 782          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 783          16,                    /* bitsize */
 784          false,                 /* pc_relative */
 785          0,                     /* bitpos */
 786          complain_overflow_dont,/* complain_on_overflow */
 787          bfd_elf_generic_reloc, /* special_function */
 788          "R_PPC_EMB_ADDR16_LO", /* name */
 789          false,                 /* partial_inplace */
 790          0,                     /* src_mask */
 791          0xffff,                /* dst_mask */
 792          false),                /* pcrel_offset */
 793
 794   /* The high order 16 bits of the addend minus the symbol */
 795   HOWTO (R_PPC_EMB_NADDR16_HI,  /* type */
 796          16,                    /* rightshift */
 797          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 798          16,                    /* 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_EMB_NADDR16_HI", /* name */
 804          false,                 /* partial_inplace */
 805          0,                     /* src_mask */
 806          0xffff,                /* dst_mask */
 807          false),                /* pcrel_offset */
 808
 809   /* The high order 16 bits of the result of the addend minus the address,
 810      plus 1 if the contents of the low 16 bits, treated as a signed number,
 811      is negative.  */
 812   HOWTO (R_PPC_EMB_NADDR16_HA,  /* type */
 813          16,                    /* rightshift */
 814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 815          16,                    /* bitsize */
 816          false,                 /* pc_relative */
 817          0,                     /* bitpos */
 818          complain_overflow_dont, /* complain_on_overflow */
 819          bfd_elf_generic_reloc, /* special_function */
 820          "R_PPC_EMB_NADDR16_HA", /* name */
 821          false,                 /* partial_inplace */
 822          0,                     /* src_mask */
 823          0xffff,                /* dst_mask */
 824          false),                /* pcrel_offset */
 825
 826   /* 16 bit value resulting from allocating a 4 byte word to hold an
 827      address in the .sdata section, and returning the offset from
 828      _SDA_BASE_ for that relocation */
 829   HOWTO (R_PPC_EMB_SDAI16,      /* type */
 830          0,                     /* rightshift */
 831          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 832          16,                    /* bitsize */
 833          false,                 /* pc_relative */
 834          0,                     /* bitpos */
 835          complain_overflow_bitfield, /* complain_on_overflow */
 836          bfd_elf_generic_reloc, /* special_function */
 837          "R_PPC_EMB_SDAI16",    /* name */
 838          false,                 /* partial_inplace */
 839          0,                     /* src_mask */
 840          0xffff,                /* dst_mask */
 841          false),                /* pcrel_offset */
 842
 843   /* 16 bit value resulting from allocating a 4 byte word to hold an
 844      address in the .sdata2 section, and returning the offset from
 845      _SDA2_BASE_ for that relocation */
 846   HOWTO (R_PPC_EMB_SDA2I16,     /* type */
 847          0,                     /* rightshift */
 848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          16,                    /* bitsize */
 850          false,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_bitfield, /* complain_on_overflow */
 853          bfd_elf_generic_reloc, /* special_function */
 854          "R_PPC_EMB_SDA2I16",   /* name */
 855          false,                 /* partial_inplace */
 856          0,                     /* src_mask */
 857          0xffff,                /* dst_mask */
 858          false),                /* pcrel_offset */
 859
 860   /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
 861      small data items.  FIXME: Not supported.    */
 862   HOWTO (R_PPC_EMB_SDA2REL,     /* type */
 863          0,                     /* rightshift */
 864          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 865          16,                    /* bitsize */
 866          false,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_signed, /* complain_on_overflow */
 869          bfd_elf_generic_reloc, /* special_function */
 870          "R_PPC_EMB_SDA2REL",   /* name */
 871          false,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          0xffff,                /* dst_mask */
 874          false),                /* pcrel_offset */
 875
 876   /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
 877      signed offset from the appropriate base, and filling in the register
 878      field with the appropriate register (0, 2, or 13).  */
 879   HOWTO (R_PPC_EMB_SDA21,       /* type */
 880          0,                     /* rightshift */
 881          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 882          16,                    /* bitsize */
 883          false,                 /* pc_relative */
 884          0,                     /* bitpos */
 885          complain_overflow_signed, /* complain_on_overflow */
 886          bfd_elf_generic_reloc, /* special_function */
 887          "R_PPC_EMB_SDA21",     /* name */
 888          false,                 /* partial_inplace */
 889          0,                     /* src_mask */
 890          0xffff,                /* dst_mask */
 891          false),                /* pcrel_offset */
 892
 893   /* Relocation not handled: R_PPC_EMB_MRKREF */
 894   /* Relocation not handled: R_PPC_EMB_RELSEC16 */
 895   /* Relocation not handled: R_PPC_EMB_RELST_LO */
 896   /* Relocation not handled: R_PPC_EMB_RELST_HI */
 897   /* Relocation not handled: R_PPC_EMB_RELST_HA */
 898   /* Relocation not handled: R_PPC_EMB_BIT_FLD */
 899
 900   /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
 901      in the 16 bit signed offset from the appropriate base, and filling in the
 902      register field with the appropriate register (0, 2, or 13).  */
 903   HOWTO (R_PPC_EMB_RELSDA,      /* type */
 904          0,                     /* rightshift */
 905          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 906          16,                    /* bitsize */
 907          true,                  /* pc_relative */
 908          0,                     /* bitpos */
 909          complain_overflow_signed, /* complain_on_overflow */
 910          bfd_elf_generic_reloc, /* special_function */
 911          "R_PPC_EMB_RELSDA",    /* name */
 912          false,                 /* partial_inplace */
 913          0,                     /* src_mask */
 914          0xffff,                /* dst_mask */
 915          false),                /* pcrel_offset */
 916
 917   /* Phony reloc to handle AIX style TOC entries */
 918   HOWTO (R_PPC_TOC16,           /* type */
 919          0,                     /* rightshift */
 920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 921          16,                    /* bitsize */
 922          false,                 /* pc_relative */
 923          0,                     /* bitpos */
 924          complain_overflow_signed, /* complain_on_overflow */
 925          bfd_elf_generic_reloc, /* special_function */
 926          "R_PPC_TOC16",         /* name */
 927          false,                 /* partial_inplace */
 928          0,                     /* src_mask */
 929          0xffff,                /* dst_mask */
 930          false),                /* pcrel_offset */
 931 };
 932
 933 \f
 934 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done.  */
 935
 936 static void
 937 ppc_elf_howto_init ()
 938 {
 939   unsigned int i, type;
 940
 941   for (i = 0; i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); i++)
 942     {
 943       type = ppc_elf_howto_raw[i].type;
 944       BFD_ASSERT (type < sizeof(ppc_elf_howto_table) / sizeof(ppc_elf_howto_table[0]));
 945       ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
 946     }
 947 }
 948
 949 \f
 950 static reloc_howto_type *
 951 ppc_elf_reloc_type_lookup (abfd, code)
 952      bfd *abfd;
 953      bfd_reloc_code_real_type code;
 954 {
 955   enum ppc_reloc_type ppc_reloc = R_PPC_NONE;
 956
 957   if (!ppc_elf_howto_table[ R_PPC_ADDR32 ])     /* Initialize howto table if needed */
 958     ppc_elf_howto_init ();
 959
 960   switch ((int)code)
 961     {
 962     default:
 963       return (reloc_howto_type *)NULL;
 964
 965     case BFD_RELOC_NONE:                ppc_reloc = R_PPC_NONE;                 break;
 966     case BFD_RELOC_32:                  ppc_reloc = R_PPC_ADDR32;               break;
 967     case BFD_RELOC_PPC_BA26:            ppc_reloc = R_PPC_ADDR24;               break;
 968     case BFD_RELOC_16:                  ppc_reloc = R_PPC_ADDR16;               break;
 969     case BFD_RELOC_LO16:                ppc_reloc = R_PPC_ADDR16_LO;            break;
 970     case BFD_RELOC_HI16:                ppc_reloc = R_PPC_ADDR16_HI;            break;
 971     case BFD_RELOC_HI16_S:              ppc_reloc = R_PPC_ADDR16_HA;            break;
 972     case BFD_RELOC_PPC_BA16:            ppc_reloc = R_PPC_ADDR14;               break;
 973     case BFD_RELOC_PPC_BA16_BRTAKEN:    ppc_reloc = R_PPC_ADDR14_BRTAKEN;       break;
 974     case BFD_RELOC_PPC_BA16_BRNTAKEN:   ppc_reloc = R_PPC_ADDR14_BRNTAKEN;      break;
 975     case BFD_RELOC_PPC_B26:             ppc_reloc = R_PPC_REL24;                break;
 976     case BFD_RELOC_PPC_B16:             ppc_reloc = R_PPC_REL14;                break;
 977     case BFD_RELOC_PPC_B16_BRTAKEN:     ppc_reloc = R_PPC_REL14_BRTAKEN;        break;
 978     case BFD_RELOC_PPC_B16_BRNTAKEN:    ppc_reloc = R_PPC_REL14_BRNTAKEN;       break;
 979     case BFD_RELOC_16_GOTOFF:           ppc_reloc = R_PPC_GOT16;                break;
 980     case BFD_RELOC_LO16_GOTOFF:         ppc_reloc = R_PPC_GOT16_LO;             break;
 981     case BFD_RELOC_HI16_GOTOFF:         ppc_reloc = R_PPC_GOT16_HI;             break;
 982     case BFD_RELOC_HI16_S_GOTOFF:       ppc_reloc = R_PPC_GOT16_HA;             break;
 983     case BFD_RELOC_24_PLT_PCREL:        ppc_reloc = R_PPC_PLTREL24;             break;
 984     case BFD_RELOC_PPC_COPY:            ppc_reloc = R_PPC_COPY;                 break;
 985     case BFD_RELOC_PPC_GLOB_DAT:        ppc_reloc = R_PPC_GLOB_DAT;             break;
 986     case BFD_RELOC_PPC_LOCAL24PC:       ppc_reloc = R_PPC_LOCAL24PC;            break;
 987     case BFD_RELOC_32_PCREL:            ppc_reloc = R_PPC_REL32;                break;
 988     case BFD_RELOC_32_PLTOFF:           ppc_reloc = R_PPC_PLT32;                break;
 989     case BFD_RELOC_32_PLT_PCREL:        ppc_reloc = R_PPC_PLTREL32;             break;
 990     case BFD_RELOC_LO16_PLTOFF:         ppc_reloc = R_PPC_PLT16_LO;             break;
 991     case BFD_RELOC_HI16_PLTOFF:         ppc_reloc = R_PPC_PLT16_HI;             break;
 992     case BFD_RELOC_HI16_S_PLTOFF:       ppc_reloc = R_PPC_PLT16_HA;             break;
 993     case BFD_RELOC_GPREL16:             ppc_reloc = R_PPC_SDAREL16;             break;
 994     case BFD_RELOC_32_BASEREL:          ppc_reloc = R_PPC_SECTOFF;              break;
 995     case BFD_RELOC_LO16_BASEREL:        ppc_reloc = R_PPC_SECTOFF_LO;           break;
 996     case BFD_RELOC_HI16_BASEREL:        ppc_reloc = R_PPC_SECTOFF_HI;           break;
 997     case BFD_RELOC_HI16_S_BASEREL:      ppc_reloc = R_PPC_SECTOFF_HA;           break;
 998     case BFD_RELOC_CTOR:                ppc_reloc = R_PPC_ADDR32;               break;
 999     case BFD_RELOC_PPC_TOC16:           ppc_reloc = R_PPC_TOC16;                break;
1000     case BFD_RELOC_PPC_EMB_NADDR32:     ppc_reloc = R_PPC_EMB_NADDR32;          break;
1001     case BFD_RELOC_PPC_EMB_NADDR16:     ppc_reloc = R_PPC_EMB_NADDR16;          break;
1002     case BFD_RELOC_PPC_EMB_NADDR16_LO:  ppc_reloc = R_PPC_EMB_NADDR16_LO;       break;
1003     case BFD_RELOC_PPC_EMB_NADDR16_HI:  ppc_reloc = R_PPC_EMB_NADDR16_HI;       break;
1004     case BFD_RELOC_PPC_EMB_NADDR16_HA:  ppc_reloc = R_PPC_EMB_NADDR16_HA;       break;
1005     case BFD_RELOC_PPC_EMB_SDAI16:      ppc_reloc = R_PPC_EMB_SDAI16;           break;
1006     case BFD_RELOC_PPC_EMB_SDA2I16:     ppc_reloc = R_PPC_EMB_SDA2I16;          break;
1007     case BFD_RELOC_PPC_EMB_SDA2REL:     ppc_reloc = R_PPC_EMB_SDA2REL;          break;
1008     case BFD_RELOC_PPC_EMB_SDA21:       ppc_reloc = R_PPC_EMB_SDA21;            break;
1009     case BFD_RELOC_PPC_EMB_MRKREF:      ppc_reloc = R_PPC_EMB_MRKREF;           break;
1010     case BFD_RELOC_PPC_EMB_RELSEC16:    ppc_reloc = R_PPC_EMB_RELSEC16;         break;
1011     case BFD_RELOC_PPC_EMB_RELST_LO:    ppc_reloc = R_PPC_EMB_RELST_LO;         break;
1012     case BFD_RELOC_PPC_EMB_RELST_HI:    ppc_reloc = R_PPC_EMB_RELST_HI;         break;
1013     case BFD_RELOC_PPC_EMB_RELST_HA:    ppc_reloc = R_PPC_EMB_RELST_HA;         break;
1014     case BFD_RELOC_PPC_EMB_BIT_FLD:     ppc_reloc = R_PPC_EMB_BIT_FLD;          break;
1015     case BFD_RELOC_PPC_EMB_RELSDA:      ppc_reloc = R_PPC_EMB_RELSDA;           break;
1016     }
1017
1018   return ppc_elf_howto_table[ (int)ppc_reloc ];
1019 };
1020
1021 /* Set the howto pointer for a PowerPC ELF reloc.  */
1022
1023 static void
1024 ppc_elf_info_to_howto (abfd, cache_ptr, dst)
1025      bfd *abfd;
1026      arelent *cache_ptr;
1027      Elf32_Internal_Rela *dst;
1028 {
1029   if (!ppc_elf_howto_table[ R_PPC_ADDR32 ])     /* Initialize howto table if needed */
1030     ppc_elf_howto_init ();
1031
1032   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
1033   cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
1034 }
1035
1036 /* Function to set whether a module needs the -mrelocatable bit set. */
1037
1038 static boolean
1039 ppc_elf_set_private_flags (abfd, flags)
1040      bfd *abfd;
1041      flagword flags;
1042 {
1043   BFD_ASSERT (!elf_flags_init (abfd)
1044               || elf_elfheader (abfd)->e_flags == flags);
1045
1046   elf_elfheader (abfd)->e_flags = flags;
1047   elf_flags_init (abfd) = true;
1048   return true;
1049 }
1050
1051 /* Copy backend specific data from one object module to another */
1052 static boolean
1053 ppc_elf_copy_private_bfd_data (ibfd, obfd)
1054      bfd *ibfd;
1055      bfd *obfd;
1056 {
1057   /* This function is selected based on the input vector.  We only
1058      want to copy information over if the output BFD also uses Elf
1059      format.  */
1060   if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1061     return true;
1062
1063   BFD_ASSERT (!elf_flags_init (obfd)
1064               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
1065
1066   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1067   elf_flags_init (obfd) = true;
1068   return true;
1069 }
1070
1071 /* Merge backend specific data from an object file to the output
1072    object file when linking */
1073 static boolean
1074 ppc_elf_merge_private_bfd_data (ibfd, obfd)
1075      bfd *ibfd;
1076      bfd *obfd;
1077 {
1078   flagword old_flags;
1079   flagword new_flags;
1080   boolean error;
1081
1082   /* Check if we have the same endianess */
1083   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1084       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1085     {
1086       (*_bfd_error_handler)
1087         ("%s: compiled for a %s endian system and target is %s endian",
1088          bfd_get_filename (ibfd),
1089          bfd_big_endian (ibfd) ? "big" : "little",
1090          bfd_big_endian (obfd) ? "big" : "little");
1091
1092       bfd_set_error (bfd_error_wrong_format);
1093       return false;
1094     }
1095
1096   /* This function is selected based on the input vector.  We only
1097      want to copy information over if the output BFD also uses Elf
1098      format.  */
1099   if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1100     return true;
1101
1102   new_flags = elf_elfheader (ibfd)->e_flags;
1103   old_flags = elf_elfheader (obfd)->e_flags;
1104   if (!elf_flags_init (obfd))   /* First call, no flags set */
1105     {
1106       elf_flags_init (obfd) = true;
1107       elf_elfheader (obfd)->e_flags = new_flags;
1108     }
1109
1110   else if (new_flags == old_flags)      /* Compatible flags are ok */
1111     ;
1112
1113   else                                  /* Incompatible flags */
1114     {
1115       /* Warn about -mrelocatable mismatch.  Allow -mrelocatable-lib to be linked
1116          with either.  */
1117       error = false;
1118       if ((new_flags & EF_PPC_RELOCATABLE) != 0
1119           && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
1120         {
1121           error = true;
1122           (*_bfd_error_handler)
1123             ("%s: compiled with -mrelocatable and linked with modules compiled normally",
1124              bfd_get_filename (ibfd));
1125         }
1126       else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
1127                && (old_flags & EF_PPC_RELOCATABLE) != 0)
1128         {
1129           error = true;
1130           (*_bfd_error_handler)
1131             ("%s: compiled normally and linked with modules compiled with -mrelocatable",
1132              bfd_get_filename (ibfd));
1133         }
1134       else if ((new_flags & EF_PPC_RELOCATABLE_LIB) != 0)
1135         elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE_LIB;
1136
1137
1138       /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if any module uses it */
1139       elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
1140
1141       new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1142       old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1143
1144       /* Warn about any other mismatches */
1145       if (new_flags != old_flags)
1146         {
1147           error = true;
1148           (*_bfd_error_handler)
1149             ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
1150              bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
1151         }
1152
1153       if (error)
1154         {
1155           bfd_set_error (bfd_error_bad_value);
1156           return false;
1157         }
1158     }
1159
1160   return true;
1161 }
1162
1163 \f
1164 /* Handle a PowerPC specific section when reading an object file.  This
1165    is called when elfcode.h finds a section with an unknown type.  */
1166
1167 static boolean
1168 ppc_elf_section_from_shdr (abfd, hdr, name)
1169      bfd *abfd;
1170      Elf32_Internal_Shdr *hdr;
1171      char *name;
1172 {
1173   asection *newsect;
1174   flagword flags;
1175
1176   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1177     return false;
1178
1179   newsect = hdr->bfd_section;
1180   flags = bfd_get_section_flags (abfd, newsect);
1181   if (hdr->sh_flags & SHF_EXCLUDE)
1182     flags |= SEC_EXCLUDE;
1183
1184   if (hdr->sh_type == SHT_ORDERED)
1185     flags |= SEC_SORT_ENTRIES;
1186
1187   bfd_set_section_flags (abfd, newsect, flags);
1188   return true;
1189 }
1190
1191 \f
1192 /* Set up any other section flags and such that may be necessary.  */
1193
1194 boolean
1195 ppc_elf_fake_sections (abfd, shdr, asect)
1196      bfd *abfd;
1197      Elf32_Internal_Shdr *shdr;
1198      asection *asect;
1199 {
1200   if ((asect->flags & SEC_EXCLUDE) != 0)
1201     shdr->sh_flags |= SHF_EXCLUDE;
1202
1203   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
1204     shdr->sh_type = SHT_ORDERED;
1205 }
1206
1207 \f
1208 /* Create a special linker section */
1209 static elf_linker_section_t *
1210 ppc_elf_create_linker_section (abfd, info, which)
1211      bfd *abfd;
1212      struct bfd_link_info *info;
1213      enum elf_linker_section_enum which;
1214 {
1215   bfd *dynobj = elf_hash_table (info)->dynobj;
1216   elf_linker_section_t *lsect;
1217
1218   /* Record the first bfd section that needs the special section */
1219   if (!dynobj)
1220     dynobj = elf_hash_table (info)->dynobj = abfd;
1221
1222   /* If this is the first time, create the section */
1223   lsect = elf_linker_section (dynobj, which);
1224   if (!lsect)
1225     {
1226       elf_linker_section_t defaults;
1227       static elf_linker_section_t zero_section;
1228
1229       defaults = zero_section;
1230       defaults.which = which;
1231       defaults.hole_written_p = false;
1232       defaults.alignment = 2;
1233       defaults.flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1234
1235       switch (which)
1236         {
1237         default:
1238           (*_bfd_error_handler) ("%s: Unknown special linker type %d",
1239                                  bfd_get_filename (abfd),
1240                                  (int)which);
1241
1242           bfd_set_error (bfd_error_bad_value);
1243           return (elf_linker_section_t *)0;
1244
1245         case LINKER_SECTION_GOT:        /* .got section */
1246           defaults.name            = ".got";
1247           defaults.rel_name        = ".rela.got";
1248           defaults.sym_name        = "_GLOBAL_OFFSET_TABLE_";
1249           defaults.max_hole_offset = 32764;
1250           defaults.hole_size       = 16;
1251           defaults.sym_offset      = 4;
1252           break;
1253
1254         case LINKER_SECTION_SDATA:      /* .sdata/.sbss section */
1255           defaults.name           = ".sdata";
1256           defaults.rel_name       = ".rela.sdata";
1257           defaults.bss_name       = ".sbss";
1258           defaults.sym_name       = "_SDA_BASE_";
1259           defaults.sym_offset     = 32768;
1260           break;
1261
1262         case LINKER_SECTION_SDATA2:     /* .sdata2/.sbss2 section */
1263           defaults.name           = ".sdata2";
1264           defaults.rel_name       = ".rela.sdata2";
1265           defaults.bss_name       = ".sbss2";
1266           defaults.sym_name       = "_SDA2_BASE_";
1267           defaults.sym_offset     = 32768;
1268           break;
1269         }
1270
1271       lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults);
1272     }
1273
1274   return lsect;
1275 }
1276
1277 \f
1278 /* Adjust a symbol defined by a dynamic object and referenced by a
1279    regular object.  The current definition is in some section of the
1280    dynamic object, but we're not including those sections.  We have to
1281    change the definition to something the rest of the link can
1282    understand.  */
1283
1284 static boolean
1285 ppc_elf_adjust_dynamic_symbol (info, h)
1286      struct bfd_link_info *info;
1287      struct elf_link_hash_entry *h;
1288 {
1289 #ifdef DEBUG
1290   fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called\n");
1291 #endif
1292   return true;
1293 }
1294
1295 \f
1296 /* Increment the index of a dynamic symbol by a given amount.  Called
1297    via elf_link_hash_traverse.  */
1298
1299 static boolean
1300 ppc_elf_adjust_dynindx (h, cparg)
1301      struct elf_link_hash_entry *h;
1302      PTR cparg;
1303 {
1304   int *cp = (int *) cparg;
1305
1306 #ifdef DEBUG
1307   fprintf (stderr, "ppc_elf_adjust_dynindx called, h->dynindx = %d, *cp = %d\n", h->dynindx, *cp);
1308 #endif
1309
1310   if (h->dynindx != -1)
1311     h->dynindx += *cp;
1312
1313   return true;
1314 }
1315
1316 \f
1317 /* Set the sizes of the dynamic sections.  */
1318
1319 static boolean
1320 ppc_elf_size_dynamic_sections (output_bfd, info)
1321      bfd *output_bfd;
1322      struct bfd_link_info *info;
1323 {
1324   bfd *dynobj;
1325   asection *s;
1326   boolean reltext;
1327   boolean relplt;
1328
1329 #ifdef DEBUG
1330   fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
1331 #endif
1332
1333   dynobj = elf_hash_table (info)->dynobj;
1334   BFD_ASSERT (dynobj != NULL);
1335
1336   if (elf_hash_table (info)->dynamic_sections_created)
1337     {
1338       /* Set the contents of the .interp section to the interpreter.  */
1339       if (! info->shared)
1340         {
1341           s = bfd_get_section_by_name (dynobj, ".interp");
1342           BFD_ASSERT (s != NULL);
1343           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1344           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1345         }
1346
1347       /* Make space for the trailing nop in .plt.  */
1348       s = bfd_get_section_by_name (dynobj, ".plt");
1349       BFD_ASSERT (s != NULL);
1350       if (s->_raw_size > 0)
1351         s->_raw_size += 4;
1352     }
1353   else
1354     {
1355       /* We may have created entries in the .rela.got, .rela.sdata, and
1356          .rela.sdata2 section2.  However, if we are not creating the
1357          dynamic sections, we will not actually use these entries.  Reset
1358          the size of .rela.got, et al, which will cause it to get
1359          stripped from the output file below.  */
1360       static char *rela_sections[] = { ".rela.got", ".rela.sdata", ".rela.sdata", (char *)0 };
1361       char **p;
1362
1363       for (p = rela_sections; *p != (char *)0; p++)
1364         {
1365           s = bfd_get_section_by_name (dynobj, *p);
1366           if (s != NULL)
1367             s->_raw_size = 0;
1368         }
1369     }
1370
1371   /* The check_relocs and adjust_dynamic_symbol entry points have
1372      determined the sizes of the various dynamic sections.  Allocate
1373      memory for them.  */
1374   reltext = false;
1375   relplt = false;
1376   for (s = dynobj->sections; s != NULL; s = s->next)
1377     {
1378       const char *name;
1379       boolean strip;
1380
1381       if ((s->flags & SEC_IN_MEMORY) == 0)
1382         continue;
1383
1384       /* It's OK to base decisions on the section name, because none
1385          of the dynobj section names depend upon the input files.  */
1386       name = bfd_get_section_name (dynobj, s);
1387
1388       strip = false;
1389
1390 #if 0
1391       if (strncmp (name, ".rela", 5) == 0)
1392         {
1393           if (s->_raw_size == 0)
1394             {
1395               /* If we don't need this section, strip it from the
1396                  output file.  This is to handle .rela.bss and
1397                  .rel.plt.  We must create it in
1398                  create_dynamic_sections, because it must be created
1399                  before the linker maps input sections to output
1400                  sections.  The linker does that before
1401                  adjust_dynamic_symbol is called, and it is that
1402                  function which decides whether anything needs to go
1403                  into these sections.  */
1404               strip = true;
1405             }
1406           else
1407             {
1408               asection *target;
1409
1410               /* If this relocation section applies to a read only
1411                  section, then we probably need a DT_TEXTREL entry.  */
1412               target = bfd_get_section_by_name (output_bfd, name + 5);
1413               if (target != NULL
1414                   && (target->flags & SEC_READONLY) != 0)
1415                 reltext = true;
1416
1417               if (strcmp (name, ".rela.plt") == 0)
1418                 relplt = true;
1419
1420               /* We use the reloc_count field as a counter if we need
1421                  to copy relocs into the output file.  */
1422               s->reloc_count = 0;
1423             }
1424         }
1425       else
1426 #endif
1427         if (strcmp (name, ".plt") != 0
1428             && strcmp (name, ".got") != 0
1429             && strcmp (name, ".sdata") != 0
1430             && strcmp (name, ".sdata2") != 0)
1431         {
1432           /* It's not one of our sections, so don't allocate space.  */
1433           continue;
1434         }
1435
1436       if (strip)
1437         {
1438           asection **spp;
1439
1440           for (spp = &s->output_section->owner->sections;
1441                *spp != s->output_section;
1442                spp = &(*spp)->next)
1443             ;
1444           *spp = s->output_section->next;
1445           --s->output_section->owner->section_count;
1446
1447           continue;
1448         }
1449
1450       /* Allocate memory for the section contents.  */
1451       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1452       if (s->contents == NULL && s->_raw_size != 0)
1453         return false;
1454     }
1455
1456   if (elf_hash_table (info)->dynamic_sections_created)
1457     {
1458       /* Add some entries to the .dynamic section.  We fill in the
1459          values later, in ppc_elf_finish_dynamic_sections, but we
1460          must add the entries now so that we get the correct size for
1461          the .dynamic section.  The DT_DEBUG entry is filled in by the
1462          dynamic linker and used by the debugger.  */
1463       if (! info->shared)
1464         {
1465           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1466             return false;
1467         }
1468
1469       if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
1470         return false;
1471
1472       if (relplt)
1473         {
1474           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1475               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1476               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1477             return false;
1478         }
1479
1480       if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
1481           || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
1482           || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
1483                                             sizeof (Elf32_External_Rela)))
1484         return false;
1485
1486       if (reltext)
1487         {
1488           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1489             return false;
1490         }
1491     }
1492
1493   /* If we are generating a shared library, we generate a section
1494      symbol for each output section.  These are local symbols, which
1495      means that they must come first in the dynamic symbol table.
1496      That means we must increment the dynamic symbol index of every
1497      other dynamic symbol.  */
1498   if (info->shared)
1499     {
1500       int c, i;
1501
1502       c = bfd_count_sections (output_bfd);
1503       elf_link_hash_traverse (elf_hash_table (info),
1504                               ppc_elf_adjust_dynindx,
1505                               (PTR) &c);
1506       elf_hash_table (info)->dynsymcount += c;
1507
1508       for (i = 1, s = output_bfd->sections; s != NULL; s = s->next, i++)
1509         {
1510           elf_section_data (s)->dynindx = i;
1511           /* These symbols will have no names, so we don't need to
1512              fiddle with dynstr_index.  */
1513         }
1514     }
1515
1516   return true;
1517 }
1518
1519 \f
1520 /* Look through the relocs for a section during the first phase, and
1521    allocate space in the global offset table or procedure linkage
1522    table.  */
1523
1524 static boolean
1525 ppc_elf_check_relocs (abfd, info, sec, relocs)
1526      bfd *abfd;
1527      struct bfd_link_info *info;
1528      asection *sec;
1529      const Elf_Internal_Rela *relocs;
1530 {
1531   bfd *dynobj;
1532   Elf_Internal_Shdr *symtab_hdr;
1533   struct elf_link_hash_entry **sym_hashes;
1534   const Elf_Internal_Rela *rel;
1535   const Elf_Internal_Rela *rel_end;
1536   elf_linker_section_t *got;
1537   elf_linker_section_t *sdata;
1538   elf_linker_section_t *sdata2;
1539   asection *sreloc;
1540
1541   if (info->relocateable)
1542     return true;
1543
1544 #ifdef DEBUG
1545   fprintf (stderr, "ppc_elf_check_relocs called for section %s\n",
1546            bfd_get_section_name (abfd, sec));
1547 #endif
1548
1549   /* Create the linker generated sections all the time so that the special
1550      symbols are created.  */
1551   if ((got = elf_linker_section (abfd, LINKER_SECTION_GOT)) == NULL)
1552     {
1553       got = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_GOT);
1554       if (!got)
1555         return false;
1556     }
1557
1558   if ((sdata = elf_linker_section (abfd, LINKER_SECTION_SDATA)) == NULL)
1559     {
1560       sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
1561       if (!sdata)
1562         return false;
1563     }
1564
1565
1566   if ((sdata2 = elf_linker_section (abfd, LINKER_SECTION_SDATA2)) == NULL)
1567     {
1568       sdata2 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA2);
1569       if (!sdata2)
1570         return false;
1571     }
1572
1573   dynobj = elf_hash_table (info)->dynobj;
1574   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1575   sym_hashes = elf_sym_hashes (abfd);
1576
1577   sreloc = NULL;
1578
1579   rel_end = relocs + sec->reloc_count;
1580   for (rel = relocs; rel < rel_end; rel++)
1581     {
1582       unsigned long r_symndx;
1583       struct elf_link_hash_entry *h;
1584
1585       r_symndx = ELF32_R_SYM (rel->r_info);
1586       if (r_symndx < symtab_hdr->sh_info)
1587         h = NULL;
1588       else
1589         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1590
1591       switch (ELF32_R_TYPE (rel->r_info))
1592         {
1593         default:
1594           break;
1595
1596         /* GOT16 relocations */
1597         case R_PPC_GOT16:
1598         case R_PPC_GOT16_LO:
1599         case R_PPC_GOT16_HI:
1600         case R_PPC_GOT16_HA:
1601           if (got->rel_section == NULL
1602               && (h != NULL || info->shared)
1603               && !_bfd_elf_make_linker_section_rela (dynobj, got, 2))
1604             return false;
1605
1606           if (!bfd_elf32_create_pointer_linker_section (abfd, info, got, h, rel))
1607             return false;
1608
1609           break;
1610
1611         /* Indirect .sdata relocation */
1612         case R_PPC_EMB_SDAI16:
1613           if (got->rel_section == NULL
1614               && (h != NULL || info->shared)
1615               && !_bfd_elf_make_linker_section_rela (dynobj, got, 2))
1616             return false;
1617
1618           BFD_ASSERT (!info->shared);
1619           if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata, h, rel))
1620             return false;
1621
1622           break;
1623
1624         /* Indirect .sdata2 relocation */
1625         case R_PPC_EMB_SDA2I16:
1626           if (got->rel_section == NULL
1627               && (h != NULL || info->shared)
1628               && !_bfd_elf_make_linker_section_rela (dynobj, got, 2))
1629             return false;
1630
1631           BFD_ASSERT (!info->shared);
1632           if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata2, h, rel))
1633             return false;
1634
1635           break;
1636
1637 #if 0
1638         case R_PPC_PLT32:
1639         case R_PPC_PLTREL24:
1640         case R_PPC_PLT16_LO:
1641         case R_PPC_PLT16_HI:
1642         case R_PPC_PLT16_HA:
1643 #ifdef DEBUG
1644           fprintf (stderr, "Reloc requires a PLT entry\n");
1645 #endif
1646           /* This symbol requires a procedure linkage table entry.  We
1647              actually build the entry in adjust_dynamic_symbol,
1648              because this might be a case of linking PIC code without
1649              linking in any dynamic objects, in which case we don't
1650              need to generate a procedure linkage table after all.  */
1651
1652           if (h == NULL)
1653             {
1654               /* It does not make sense to have a procedure linkage
1655                  table entry for a local symbol.  */
1656               bfd_set_error (bfd_error_bad_value);
1657               return false;
1658             }
1659
1660           /* Make sure this symbol is output as a dynamic symbol.  */
1661           if (h->dynindx == -1)
1662             {
1663               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1664                 return false;
1665             }
1666
1667           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1668           break;
1669
1670         case R_SPARC_PC10:
1671         case R_SPARC_PC22:
1672           if (h != NULL
1673               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1674             break;
1675           /* Fall through.  */
1676         case R_SPARC_DISP8:
1677         case R_SPARC_DISP16:
1678         case R_SPARC_DISP32:
1679         case R_SPARC_WDISP30:
1680         case R_SPARC_WDISP22:
1681           if (h == NULL)
1682             break;
1683           /* Fall through.  */
1684         case R_SPARC_8:
1685         case R_SPARC_16:
1686         case R_SPARC_32:
1687         case R_SPARC_HI22:
1688         case R_SPARC_22:
1689         case R_SPARC_13:
1690         case R_SPARC_LO10:
1691         case R_SPARC_UA32:
1692           if (info->shared
1693               && (sec->flags & SEC_ALLOC) != 0)
1694             {
1695               /* When creating a shared object, we must copy these
1696                  relocs into the output file.  We create a reloc
1697                  section in dynobj and make room for the reloc.  */
1698               if (sreloc == NULL)
1699                 {
1700                   const char *name;
1701
1702                   name = (bfd_elf_string_from_elf_section
1703                           (abfd,
1704                            elf_elfheader (abfd)->e_shstrndx,
1705                            elf_section_data (sec)->rel_hdr.sh_name));
1706                   if (name == NULL)
1707                     return false;
1708
1709                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1710                               && strcmp (bfd_get_section_name (abfd, sec),
1711                                          name + 5) == 0);
1712
1713                   sreloc = bfd_get_section_by_name (dynobj, name);
1714                   if (sreloc == NULL)
1715                     {
1716                       sreloc = bfd_make_section (dynobj, name);
1717                       if (sreloc == NULL
1718                           || ! bfd_set_section_flags (dynobj, sreloc,
1719                                                       (SEC_ALLOC
1720                                                        | SEC_LOAD
1721                                                        | SEC_HAS_CONTENTS
1722                                                        | SEC_IN_MEMORY
1723                                                        | SEC_READONLY))
1724                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1725                         return false;
1726                     }
1727                 }
1728
1729               sreloc->_raw_size += sizeof (Elf32_External_Rela);
1730             }
1731
1732           break;
1733 #endif
1734         }
1735     }
1736
1737   return true;
1738 }
1739
1740 \f
1741 /* Finish up dynamic symbol handling.  We set the contents of various
1742    dynamic sections here.  */
1743
1744 static boolean
1745 ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
1746      bfd *output_bfd;
1747      struct bfd_link_info *info;
1748      struct elf_link_hash_entry *h;
1749      Elf_Internal_Sym *sym;
1750 {
1751   bfd *dynobj;
1752
1753 #ifdef DEBUG
1754   fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s\n", h->root.root.string);
1755 #endif
1756
1757   dynobj = elf_hash_table (info)->dynobj;
1758   BFD_ASSERT (dynobj != NULL);
1759
1760   if (h->plt_offset != (bfd_vma) -1)
1761     {
1762       asection *splt;
1763       asection *srela;
1764       Elf_Internal_Rela rela;
1765
1766       /* This symbol has an entry in the procedure linkage table.  Set
1767          it up.  */
1768
1769       BFD_ASSERT (h->dynindx != -1);
1770
1771       splt = bfd_get_section_by_name (dynobj, ".plt");
1772       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1773       BFD_ASSERT (splt != NULL && srela != NULL);
1774
1775       /* Fill in the entry in the procedure linkage table.  */
1776 #if 0
1777       bfd_put_32 (output_bfd,
1778                   PLT_ENTRY_WORD0 + h->plt_offset,
1779                   splt->contents + h->plt_offset);
1780       bfd_put_32 (output_bfd,
1781                   (PLT_ENTRY_WORD1
1782                    + (((- (h->plt_offset + 4)) >> 2) & 0x3fffff)),
1783                   splt->contents + h->plt_offset + 4);
1784       bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
1785                   splt->contents + h->plt_offset + 8);
1786
1787       /* Fill in the entry in the .rela.plt section.  */
1788       rela.r_offset = (splt->output_section->vma
1789                        + splt->output_offset
1790                        + h->plt_offset);
1791       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1792       rela.r_addend = 0;
1793       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1794                                  ((Elf32_External_Rela *) srela->contents
1795                                   + h->plt_offset / PLT_ENTRY_SIZE - 4));
1796 #endif
1797
1798       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1799         {
1800           /* Mark the symbol as undefined, rather than as defined in
1801              the .plt section.  Leave the value alone.  */
1802           sym->st_shndx = SHN_UNDEF;
1803         }
1804     }
1805
1806   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1807     {
1808       asection *s;
1809       Elf_Internal_Rela rela;
1810
1811       /* This symbols needs a copy reloc.  Set it up.  */
1812
1813       BFD_ASSERT (h->dynindx != -1);
1814
1815       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1816                                    ".rela.bss");
1817       BFD_ASSERT (s != NULL);
1818
1819       rela.r_offset = (h->root.u.def.value
1820                        + h->root.u.def.section->output_section->vma
1821                        + h->root.u.def.section->output_offset);
1822       rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
1823       rela.r_addend = 0;
1824       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1825                                  ((Elf32_External_Rela *) s->contents
1826                                   + s->reloc_count));
1827       ++s->reloc_count;
1828     }
1829
1830   /* Mark some specially defined symbols as absolute.  */
1831   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1832       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1833       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1834     sym->st_shndx = SHN_ABS;
1835
1836   return true;
1837 }
1838
1839 \f
1840 /* Finish up the dynamic sections.  */
1841
1842 static boolean
1843 ppc_elf_finish_dynamic_sections (output_bfd, info)
1844      bfd *output_bfd;
1845      struct bfd_link_info *info;
1846 {
1847   asection *sdyn;
1848   bfd *dynobj = elf_hash_table (info)->dynobj;
1849   elf_linker_section_t *got = elf_linker_section (dynobj, LINKER_SECTION_GOT);
1850
1851 #ifdef DEBUG
1852   fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
1853 #endif
1854
1855   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1856
1857   if (elf_hash_table (info)->dynamic_sections_created)
1858     {
1859       asection *splt;
1860       Elf32_External_Dyn *dyncon, *dynconend;
1861
1862       splt = bfd_get_section_by_name (dynobj, ".plt");
1863       BFD_ASSERT (splt != NULL && sdyn != NULL);
1864
1865       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1866       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1867       for (; dyncon < dynconend; dyncon++)
1868         {
1869           Elf_Internal_Dyn dyn;
1870           const char *name;
1871           boolean size;
1872
1873           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1874
1875           switch (dyn.d_tag)
1876             {
1877             case DT_PLTGOT:   name = ".plt"; size = false; break;
1878             case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1879             case DT_JMPREL:   name = ".rela.plt"; size = false; break;
1880             default:      name = NULL; size = false; break;
1881             }
1882
1883           if (name != NULL)
1884             {
1885               asection *s;
1886
1887               s = bfd_get_section_by_name (output_bfd, name);
1888               if (s == NULL)
1889                 dyn.d_un.d_val = 0;
1890               else
1891                 {
1892                   if (! size)
1893                     dyn.d_un.d_ptr = s->vma;
1894                   else
1895                     {
1896                       if (s->_cooked_size != 0)
1897                         dyn.d_un.d_val = s->_cooked_size;
1898                       else
1899                         dyn.d_un.d_val = s->_raw_size;
1900                     }
1901                 }
1902               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1903             }
1904         }
1905     }
1906
1907   /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
1908      easily find the address of the _GLOBAL_OFFSET_TABLE_.  */
1909   if (got)
1910     {
1911       unsigned char *contents = got->section->contents + got->hole_offset;
1912       bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
1913
1914       if (sdyn == NULL)
1915         bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
1916       else
1917         bfd_put_32 (output_bfd,
1918                     sdyn->output_section->vma + sdyn->output_offset,
1919                     contents+4);
1920
1921       elf_section_data (got->section->output_section)->this_hdr.sh_entsize = 4;
1922     }
1923
1924   if (info->shared)
1925     {
1926       asection *sdynsym;
1927       asection *s;
1928       Elf_Internal_Sym sym;
1929
1930       /* Set up the section symbols for the output sections.  */
1931
1932       sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1933       BFD_ASSERT (sdynsym != NULL);
1934
1935       sym.st_size = 0;
1936       sym.st_name = 0;
1937       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1938       sym.st_other = 0;
1939
1940       for (s = output_bfd->sections; s != NULL; s = s->next)
1941         {
1942           int indx;
1943
1944           sym.st_value = s->vma;
1945
1946           indx = elf_section_data (s)->this_idx;
1947           BFD_ASSERT (indx > 0);
1948           sym.st_shndx = indx;
1949
1950           bfd_elf32_swap_symbol_out (output_bfd, &sym,
1951                                      (PTR) (((Elf32_External_Sym *)
1952                                              sdynsym->contents)
1953                                             + elf_section_data (s)->dynindx));
1954         }
1955
1956       /* Set the sh_info field of the output .dynsym section to the
1957          index of the first global symbol.  */
1958       elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1959         bfd_count_sections (output_bfd) + 1;
1960     }
1961
1962   return true;
1963 }
1964
1965 \f
1966 /* The RELOCATE_SECTION function is called by the ELF backend linker
1967    to handle the relocations for a section.
1968
1969    The relocs are always passed as Rela structures; if the section
1970    actually uses Rel structures, the r_addend field will always be
1971    zero.
1972
1973    This function is responsible for adjust the section contents as
1974    necessary, and (if using Rela relocs and generating a
1975    relocateable output file) adjusting the reloc addend as
1976    necessary.
1977
1978    This function does not have to worry about setting the reloc
1979    address or the reloc symbol index.
1980
1981    LOCAL_SYMS is a pointer to the swapped in local symbols.
1982
1983    LOCAL_SECTIONS is an array giving the section in the input file
1984    corresponding to the st_shndx field of each local symbol.
1985
1986    The global hash table entry for the global symbols can be found
1987    via elf_sym_hashes (input_bfd).
1988
1989    When generating relocateable output, this function must handle
1990    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1991    going to be the section symbol corresponding to the output
1992    section, which means that the addend must be adjusted
1993    accordingly.  */
1994
1995 static boolean
1996 ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1997                           contents, relocs, local_syms, local_sections)
1998      bfd *output_bfd;
1999      struct bfd_link_info *info;
2000      bfd *input_bfd;
2001      asection *input_section;
2002      bfd_byte *contents;
2003      Elf_Internal_Rela *relocs;
2004      Elf_Internal_Sym *local_syms;
2005      asection **local_sections;
2006 {
2007   Elf_Internal_Shdr *symtab_hdr           = &elf_tdata (input_bfd)->symtab_hdr;
2008   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2009   bfd *dynobj                             = elf_hash_table (info)->dynobj;
2010   elf_linker_section_t *got               = elf_linker_section (dynobj, LINKER_SECTION_GOT);
2011   elf_linker_section_t *sdata             = elf_linker_section (dynobj, LINKER_SECTION_SDATA);
2012   elf_linker_section_t *sdata2            = elf_linker_section (dynobj, LINKER_SECTION_SDATA2);
2013   Elf_Internal_Rela *rel                  = relocs;
2014   Elf_Internal_Rela *relend               = relocs + input_section->reloc_count;
2015   boolean ret                             = true;
2016   long insn;
2017
2018 #ifdef DEBUG
2019   fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, %ld relocations%s\n",
2020            bfd_get_filename (input_bfd),
2021            bfd_section_name(input_bfd, input_section),
2022            (long)input_section->reloc_count,
2023            (info->relocateable) ? " (relocatable)" : "");
2024 #endif
2025
2026   if (!ppc_elf_howto_table[ R_PPC_ADDR32 ])     /* Initialize howto table if needed */
2027     ppc_elf_howto_init ();
2028
2029   for (; rel < relend; rel++)
2030     {
2031       enum ppc_reloc_type r_type        = (enum ppc_reloc_type)ELF32_R_TYPE (rel->r_info);
2032       bfd_vma offset                    = rel->r_offset;
2033       bfd_vma addend                    = rel->r_addend;
2034       bfd_reloc_status_type r           = bfd_reloc_other;
2035       Elf_Internal_Sym *sym             = (Elf_Internal_Sym *)0;
2036       asection *sec                     = (asection *)0;
2037       struct elf_link_hash_entry *h     = (struct elf_link_hash_entry *)0;
2038       reloc_howto_type *howto;
2039       unsigned long r_symndx;
2040       bfd_vma relocation;
2041
2042       /* Unknown relocation handling */
2043       if ((unsigned)r_type >= (unsigned)R_PPC_max || !ppc_elf_howto_table[(int)r_type])
2044         {
2045           (*_bfd_error_handler) ("%s: unknown relocation type %d",
2046                                  bfd_get_filename (input_bfd),
2047                                  (int)r_type);
2048
2049           bfd_set_error (bfd_error_bad_value);
2050           ret = false;
2051           continue;
2052         }
2053
2054       howto = ppc_elf_howto_table[(int)r_type];
2055       r_symndx = ELF32_R_SYM (rel->r_info);
2056
2057       if (info->relocateable)
2058         {
2059           /* This is a relocateable link.  We don't have to change
2060              anything, unless the reloc is against a section symbol,
2061              in which case we have to adjust according to where the
2062              section symbol winds up in the output section.  */
2063           if (r_symndx < symtab_hdr->sh_info)
2064             {
2065               sym = local_syms + r_symndx;
2066               if ((unsigned)ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2067                 {
2068                   sec = local_sections[r_symndx];
2069                   addend = rel->r_addend += sec->output_offset + sym->st_value;
2070                 }
2071             }
2072
2073 #ifdef DEBUG
2074           fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
2075                    howto->name,
2076                    (int)r_type,
2077                    r_symndx,
2078                    (long)offset,
2079                    (long)addend);
2080 #endif
2081           continue;
2082         }
2083
2084       /* This is a final link.  */
2085       if (r_symndx < symtab_hdr->sh_info)
2086         {
2087           sym = local_syms + r_symndx;
2088           sec = local_sections[r_symndx];
2089           relocation = (sec->output_section->vma
2090                         + sec->output_offset
2091                         + sym->st_value);
2092         }
2093       else
2094         {
2095           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2096           if (h->root.type == bfd_link_hash_defined
2097               || h->root.type == bfd_link_hash_defweak)
2098             {
2099               sec = h->root.u.def.section;
2100               relocation = (h->root.u.def.value
2101                             + sec->output_section->vma
2102                             + sec->output_offset);
2103             }
2104           else if (h->root.type == bfd_link_hash_undefweak)
2105             relocation = 0;
2106           else if (info->shared)
2107             relocation = 0;
2108           else
2109             {
2110               (*info->callbacks->undefined_symbol)(info,
2111                                                    h->root.root.string,
2112                                                    input_bfd,
2113                                                    input_section,
2114                                                    rel->r_offset);
2115               ret = false;
2116               continue;
2117             }
2118         }
2119
2120       switch ((int)r_type)
2121         {
2122         default:
2123           (*_bfd_error_handler) ("%s: unknown relocation type %d",
2124                                  bfd_get_filename (input_bfd),
2125                                  (int)r_type);
2126
2127           bfd_set_error (bfd_error_bad_value);
2128           ret = false;
2129           continue;
2130
2131         /* relocations that need no special processing */
2132         case (int)R_PPC_NONE:
2133         case (int)R_PPC_ADDR32:
2134         case (int)R_PPC_ADDR24:
2135         case (int)R_PPC_ADDR16:
2136         case (int)R_PPC_ADDR16_LO:
2137         case (int)R_PPC_ADDR16_HI:
2138         case (int)R_PPC_ADDR14:
2139         case (int)R_PPC_REL24:
2140         case (int)R_PPC_REL14:
2141         case (int)R_PPC_UADDR32:
2142         case (int)R_PPC_UADDR16:
2143         case (int)R_PPC_REL32:
2144           break;
2145
2146         /* branch taken prediction relocations */
2147         case (int)R_PPC_ADDR14_BRTAKEN:
2148         case (int)R_PPC_REL14_BRTAKEN:
2149           insn = bfd_get_32 (output_bfd, contents + offset);
2150           if ((relocation - offset) & 0x8000)
2151             insn &= ~BRANCH_PREDICT_BIT;
2152           else
2153             insn |= BRANCH_PREDICT_BIT;
2154           bfd_put_32 (output_bfd, insn, contents + offset);
2155           break;
2156
2157         /* branch not taken predicition relocations */
2158         case (int)R_PPC_ADDR14_BRNTAKEN:
2159         case (int)R_PPC_REL14_BRNTAKEN:
2160           insn = bfd_get_32 (output_bfd, contents + offset);
2161           if ((relocation - offset) & 0x8000)
2162             insn |= BRANCH_PREDICT_BIT;
2163           else
2164             insn &= ~BRANCH_PREDICT_BIT;
2165           bfd_put_32 (output_bfd, insn, contents + offset);
2166           break;
2167
2168         /* GOT16 relocations */
2169         case (int)R_PPC_GOT16:
2170         case (int)R_PPC_GOT16_LO:
2171         case (int)R_PPC_GOT16_HI:
2172         case (int)R_PPC_GOT16_HA:
2173           relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info,
2174                                                                 got, h, relocation, rel,
2175                                                                 R_PPC_RELATIVE);
2176           break;
2177
2178         /* Indirect .sdata relocation */
2179         case (int)R_PPC_EMB_SDAI16:
2180           BFD_ASSERT (sdata != NULL);
2181           relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info,
2182                                                                 sdata, h, relocation, rel,
2183                                                                 R_PPC_RELATIVE);
2184           break;
2185
2186         /* Indirect .sdata2 relocation */
2187         case (int)R_PPC_EMB_SDA2I16:
2188           BFD_ASSERT (sdata2 != NULL);
2189           relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info,
2190                                                                 sdata2, h, relocation, rel,
2191                                                                 R_PPC_RELATIVE);
2192           break;
2193
2194         /* Handle the TOC16 reloc.  We want to use the offset within the .got
2195            section, not the actual VMA.  This is appropriate when generating
2196            an embedded ELF object, for which the .got section acts like the
2197            AIX .toc section.  */
2198         case (int)R_PPC_TOC16:                  /* phony GOT16 relocations */
2199           BFD_ASSERT (sec != (asection *)0);
2200           BFD_ASSERT (bfd_is_und_section (sec)
2201                       || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
2202                       || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0)
2203
2204           addend -= sec->output_section->vma + 0x8000;
2205           break;
2206
2207         /* arithmetic adjust relocations */
2208         case (int)R_PPC_ADDR16_HA:
2209           BFD_ASSERT (sec != (asection *)0);
2210           addend += ((relocation + addend) & 0x8000) << 1;
2211           break;
2212
2213         /* relocate against _SDA_BASE_ */
2214         case (int)R_PPC_SDAREL16:
2215           BFD_ASSERT (sec != (asection *)0);
2216           if (strcmp (bfd_get_section_name (abfd, sec), ".sdata") != 0
2217               && strcmp (bfd_get_section_name (abfd, sec), ".sbss") != 0)
2218             {
2219               (*_bfd_error_handler) ("%s: The target of a %s relocation is in the wrong section (%s)",
2220                                      bfd_get_filename (input_bfd),
2221                                      ppc_elf_howto_table[ (int)r_type ]->name,
2222                                      bfd_get_section_name (abfd, sec));
2223
2224               bfd_set_error (bfd_error_bad_value);
2225               ret = false;
2226               continue;
2227             }
2228           addend -= sdata->sym_hash->root.u.def.value;
2229           relocation = sdata->sym_hash->root.u.def.section->output_section->vma - relocation;
2230           break;
2231
2232
2233         /* relocate against _SDA2_BASE_ */
2234         case (int)R_PPC_EMB_SDA2REL:
2235           BFD_ASSERT (sec != (asection *)0);
2236           if (strcmp (bfd_get_section_name (abfd, sec), ".sdata2") != 0
2237               && strcmp (bfd_get_section_name (abfd, sec), ".sbss2") != 0)
2238             {
2239               (*_bfd_error_handler) ("%s: The target of a %s relocation is in the wrong section (%s)",
2240                                      bfd_get_filename (input_bfd),
2241                                      ppc_elf_howto_table[ (int)r_type ]->name,
2242                                      bfd_get_section_name (abfd, sec));
2243
2244               bfd_set_error (bfd_error_bad_value);
2245               ret = false;
2246               continue;
2247             }
2248           addend -= sdata2->sym_hash->root.u.def.value;
2249           relocation = sdata2->sym_hash->root.u.def.section->output_section->vma - relocation;
2250           break;
2251
2252
2253         /* relocate against either _SDA_BASE_, _SDA2_BASE_, or 0 */
2254         case (int)R_PPC_EMB_SDA21:
2255         case (int)R_PPC_EMB_RELSDA:
2256           {
2257             const char *name = bfd_get_section_name (abfd, sec);
2258             int reg;
2259
2260             BFD_ASSERT (sec != (asection *)0);
2261             if (strcmp (name, ".sdata") == 0 || strcmp (name, ".sbss") == 0)
2262               {
2263                 reg = 13;
2264                 addend -= sdata->sym_hash->root.u.def.value;
2265                 relocation = sdata->sym_hash->root.u.def.section->output_section->vma - relocation;
2266               }
2267
2268             else if (strcmp (name, ".sdata2") == 0 || strcmp (name, ".sbss2") == 0)
2269               {
2270                 reg = 2;
2271                 addend -= sdata2->sym_hash->root.u.def.value;
2272                 relocation = sdata2->sym_hash->root.u.def.section->output_section->vma - relocation;
2273               }
2274
2275             else if (strcmp (name, ".PPC.EMB.sdata0") == 0 || strcmp (name, ".PPC.EMB.sbss0") == 0)
2276               {
2277                 reg = 0;
2278               }
2279
2280             else
2281               {
2282                 (*_bfd_error_handler) ("%s: The target of a %s relocation is in the wrong section (%s)",
2283                                        bfd_get_filename (input_bfd),
2284                                        ppc_elf_howto_table[ (int)r_type ]->name,
2285                                        bfd_get_section_name (abfd, sec));
2286
2287                 bfd_set_error (bfd_error_bad_value);
2288                 ret = false;
2289                 continue;
2290               }
2291             goto unsupported;
2292           }
2293
2294         case (int)R_PPC_PLTREL24:
2295         case (int)R_PPC_COPY:
2296         case (int)R_PPC_GLOB_DAT:
2297         case (int)R_PPC_JMP_SLOT:
2298         case (int)R_PPC_RELATIVE:
2299         case (int)R_PPC_LOCAL24PC:
2300         case (int)R_PPC_PLT32:
2301         case (int)R_PPC_PLTREL32:
2302         case (int)R_PPC_PLT16_LO:
2303         case (int)R_PPC_PLT16_HI:
2304         case (int)R_PPC_PLT16_HA:
2305         case (int)R_PPC_SECTOFF:
2306         case (int)R_PPC_SECTOFF_LO:
2307         case (int)R_PPC_SECTOFF_HI:
2308         case (int)R_PPC_SECTOFF_HA:
2309         case (int)R_PPC_EMB_NADDR32:
2310         case (int)R_PPC_EMB_NADDR16:
2311         case (int)R_PPC_EMB_NADDR16_LO:
2312         case (int)R_PPC_EMB_NADDR16_HI:
2313         case (int)R_PPC_EMB_NADDR16_HA:
2314         case (int)R_PPC_EMB_MRKREF:
2315         case (int)R_PPC_EMB_RELSEC16:
2316         case (int)R_PPC_EMB_RELST_LO:
2317         case (int)R_PPC_EMB_RELST_HI:
2318         case (int)R_PPC_EMB_RELST_HA:
2319         case (int)R_PPC_EMB_BIT_FLD:
2320         unsupported:
2321           (*_bfd_error_handler) ("%s: Relocation %s is not yet supported.",
2322                                  bfd_get_filename (input_bfd),
2323                                  ppc_elf_howto_table[ (int)r_type ]->name);
2324
2325           bfd_set_error (bfd_error_invalid_operation);
2326           ret = false;
2327           continue;
2328         }
2329
2330
2331 #ifdef DEBUG
2332       fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
2333                howto->name,
2334                (int)r_type,
2335                r_symndx,
2336                (long)offset,
2337                (long)addend);
2338 #endif
2339
2340       r = _bfd_final_link_relocate (howto,
2341                                     input_bfd,
2342                                     input_section,
2343                                     contents,
2344                                     offset,
2345                                     relocation,
2346                                     addend);
2347
2348       if (r != bfd_reloc_ok)
2349         {
2350           ret = false;
2351           switch (r)
2352             {
2353             default:
2354               break;
2355
2356             case bfd_reloc_overflow:
2357               {
2358                 const char *name;
2359
2360                 if (h != NULL)
2361                   name = h->root.root.string;
2362                 else
2363                   {
2364                     name = bfd_elf_string_from_elf_section (input_bfd,
2365                                                             symtab_hdr->sh_link,
2366                                                             sym->st_name);
2367                     if (name == NULL)
2368                       break;
2369
2370                     if (*name == '\0')
2371                       name = bfd_section_name (input_bfd, sec);
2372                   }
2373
2374                 (*info->callbacks->reloc_overflow)(info,
2375                                                    name,
2376                                                    howto->name,
2377                                                    (bfd_vma) 0,
2378                                                    input_bfd,
2379                                                    input_section,
2380                                                    offset);
2381               }
2382               break;
2383
2384             }
2385         }
2386     }
2387
2388
2389 #ifdef DEBUG
2390   fprintf (stderr, "\n");
2391 #endif
2392
2393   return ret;
2394 }
2395
2396 \f
2397 #define TARGET_LITTLE_SYM       bfd_elf32_powerpcle_vec
2398 #define TARGET_LITTLE_NAME      "elf32-powerpcle"
2399 #define TARGET_BIG_SYM          bfd_elf32_powerpc_vec
2400 #define TARGET_BIG_NAME         "elf32-powerpc"
2401 #define ELF_ARCH                bfd_arch_powerpc
2402 #define ELF_MACHINE_CODE        EM_PPC
2403 #define ELF_MAXPAGESIZE         0x10000
2404 #define elf_info_to_howto       ppc_elf_info_to_howto
2405
2406 #ifdef  EM_CYGNUS_POWERPC
2407 #define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
2408 #endif
2409
2410 #ifdef EM_PPC_OLD
2411 #define ELF_MACHINE_ALT2        EM_PPC_OLD
2412 #endif
2413
2414 #define bfd_elf32_bfd_copy_private_bfd_data     ppc_elf_copy_private_bfd_data
2415 #define bfd_elf32_bfd_merge_private_bfd_data    ppc_elf_merge_private_bfd_data
2416 #define bfd_elf32_bfd_set_private_flags         ppc_elf_set_private_flags
2417 #define bfd_elf32_bfd_reloc_type_lookup         ppc_elf_reloc_type_lookup
2418 #define elf_backend_section_from_shdr           ppc_elf_section_from_shdr
2419 #define elf_backend_relocate_section            ppc_elf_relocate_section
2420 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
2421 #define elf_backend_check_relocs                ppc_elf_check_relocs
2422 #define elf_backend_adjust_dynamic_symbol       ppc_elf_adjust_dynamic_symbol
2423 #define elf_backend_size_dynamic_sections       ppc_elf_size_dynamic_sections
2424 #define elf_backend_finish_dynamic_symbol       ppc_elf_finish_dynamic_symbol
2425 #define elf_backend_finish_dynamic_sections     ppc_elf_finish_dynamic_sections
2426 #define elf_backend_fake_sections               ppc_elf_fake_sections
2427
2428 #include "elf32-target.h"