bfd/elf32-ppc.c

   1 /* PowerPC-specific support for 32-bit ELF
   2    Copyright 1994, 1995 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 "libelf.h"
  31 #include "elf/ppc.h"
  32
  33 static bfd_reloc_status_type ppc_elf_unsupported_reloc
  34   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  35 static bfd_reloc_status_type ppc_elf_std_reloc
  36   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  37
  38 static bfd_vma ppc_elf_addr16_ha_inner PARAMS ((bfd_vma));
  39 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
  40   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  41 static bfd_vma ppc_elf_got16_inner PARAMS ((asection *sec));
  42 static bfd_reloc_status_type ppc_elf_got16_reloc
  43   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  44 static reloc_howto_type *ppc_elf_reloc_type_lookup
  45   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  46 static void ppc_elf_info_to_howto
  47   PARAMS ((bfd *abfd, arelent *cache_ptr, Elf32_Internal_Rela *dst));
  48 static void ppc_elf_howto_init PARAMS ((void));
  49 static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword));
  50 static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
  51 static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
  52
  53 static boolean ppc_elf_relocate_section PARAMS ((bfd *,
  54                                                  struct bfd_link_info *info,
  55                                                  bfd *,
  56                                                  asection *,
  57                                                  bfd_byte *,
  58                                                  Elf_Internal_Rela *relocs,
  59                                                  Elf_Internal_Sym *local_syms,
  60                                                  asection **));
  61
  62 #define USE_RELA
  63
  64 enum reloc_type
  65 {
  66   R_PPC_NONE = 0,                       /*   0 */
  67   R_PPC_ADDR32,                         /*   1 */
  68   R_PPC_ADDR24,                         /*   2 */
  69   R_PPC_ADDR16,                         /*   3 */
  70   R_PPC_ADDR16_LO,                      /*   4 */
  71   R_PPC_ADDR16_HI,                      /*   5 */
  72   R_PPC_ADDR16_HA,                      /*   6 */
  73   R_PPC_ADDR14,                         /*   7 */
  74   R_PPC_ADDR14_BRTAKEN,                 /*   8 */
  75   R_PPC_ADDR14_BRNTAKEN,                /*   9 */
  76   R_PPC_REL24,                          /*  10 */
  77   R_PPC_REL14,                          /*  11 */
  78   R_PPC_REL14_BRTAKEN,                  /*  12 */
  79   R_PPC_REL14_BRNTAKEN,                 /*  13 */
  80   R_PPC_GOT16,                          /*  14 */
  81   R_PPC_GOT16_LO,                       /*  15 */
  82   R_PPC_GOT16_HI,                       /*  16 */
  83   R_PPC_GOT16_HA,                       /*  17 */
  84   R_PPC_PLT24,                          /*  18 */
  85   R_PPC_COPY,                           /*  19 */
  86   R_PPC_GLOB_DAT,                       /*  20 -- not in final System V spec */
  87   R_PPC_JMP_SLOT,                       /*  21 */
  88   R_PPC_RELATIVE,                       /*  22 */
  89   R_PPC_LOCAL24PC,                      /*  23 */
  90   R_PPC_UADDR32,                        /*  24 */
  91   R_PPC_UADDR16,                        /*  25 */
  92   R_PPC_REL32,                          /*  26 */
  93   R_PPC_PLT32,                          /*  27 */
  94   R_PPC_PLTREL32,                       /*  28 */
  95   R_PPC_PLT16_LO,                       /*  29 */
  96   R_PPC_PLT16_HI,                       /*  30 */
  97   R_PPC_PLT16_HA,                       /*  31 */
  98   R_PPC_SDAREL,                         /*  32 */
  99
 100   /* Relocations added by Sun. */
 101   R_PPC_SECTOFF,                        /*  33 */
 102   R_PPC_SECTOFF_LO,                     /*  34 */
 103   R_PPC_SECTOFF_HI,                     /*  35 */
 104   R_PPC_SECTOFF_HA,                     /*  36 */
 105
 106   /* The remaining relocs are from the Embedded ELF ABI, and are not
 107      in the SVR4 ELF ABI.  */
 108   R_PPC_EMB_NADDR32 = 101,              /* 101 */
 109   R_PPC_EMB_NADDR16,                    /* 102 */
 110   R_PPC_EMB_NADDR16_LO,                 /* 103 */
 111   R_PPC_EMB_NADDR16_HI,                 /* 104 */
 112   R_PPC_EMB_NADDR16_HA,                 /* 105 */
 113   R_PPC_EMB_SDAI16,                     /* 106 */
 114   R_PPC_EMB_SDA2I16,                    /* 107 */
 115   R_PPC_EMB_SDA2REL,                    /* 108 */
 116   R_PPC_EMB_SDA21,                      /* 109 */
 117   R_PPC_EMB_MRKREF,                     /* 110 */
 118   R_PPC_EMB_RELSEC16,                   /* 111 */
 119   R_PPC_EMB_RELST_LO,                   /* 112 */
 120   R_PPC_EMB_RELST_HI,                   /* 113 */
 121   R_PPC_EMB_RELST_HA,                   /* 114 */
 122   R_PPC_EMB_BIT_FLD,                    /* 115 */
 123   R_PPC_EMB_RELSDA,                     /* 116 */
 124   R_PPC_max
 125 };
 126
 127 \f
 128 static reloc_howto_type *ppc_elf_howto_table[ (int)R_PPC_max ];
 129
 130 static reloc_howto_type ppc_elf_howto_raw[] =
 131 {
 132   /* This reloc does nothing.  */
 133   HOWTO (R_PPC_NONE,            /* type */
 134          0,                     /* rightshift */
 135          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 136          32,                    /* bitsize */
 137          false,                 /* pc_relative */
 138          0,                     /* bitpos */
 139          complain_overflow_bitfield, /* complain_on_overflow */
 140          ppc_elf_std_reloc,     /* special_function */
 141          "R_PPC_NONE",          /* name */
 142          false,                 /* partial_inplace */
 143          0,                     /* src_mask */
 144          0,                     /* dst_mask */
 145          false),                /* pcrel_offset */
 146
 147   /* A standard 32 bit relocation.  */
 148   HOWTO (R_PPC_ADDR32,          /* type */
 149          0,                     /* rightshift */
 150          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 151          32,                    /* bitsize */
 152          false,                 /* pc_relative */
 153          0,                     /* bitpos */
 154          complain_overflow_bitfield, /* complain_on_overflow */
 155          ppc_elf_std_reloc,     /* special_function */
 156          "R_PPC_ADDR32",        /* name */
 157          false,                 /* partial_inplace */
 158          0,                     /* src_mask */
 159          0xffffffff,            /* dst_mask */
 160          false),                /* pcrel_offset */
 161
 162   /* An absolute 26 bit branch; the lower two bits must be zero.
 163      FIXME: we don't check that, we just clear them.  */
 164   HOWTO (R_PPC_ADDR24,          /* type */
 165          0,                     /* rightshift */
 166          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 167          26,                    /* bitsize */
 168          false,                 /* pc_relative */
 169          0,                     /* bitpos */
 170          complain_overflow_bitfield, /* complain_on_overflow */
 171          ppc_elf_std_reloc,     /* special_function */
 172          "R_PPC_ADDR24",        /* name */
 173          false,                 /* partial_inplace */
 174          0,                     /* src_mask */
 175          0x3fffffc,             /* dst_mask */
 176          false),                /* pcrel_offset */
 177
 178   /* A standard 16 bit relocation.  */
 179   HOWTO (R_PPC_ADDR16,          /* type */
 180          0,                     /* rightshift */
 181          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 182          16,                    /* bitsize */
 183          false,                 /* pc_relative */
 184          0,                     /* bitpos */
 185          complain_overflow_bitfield, /* complain_on_overflow */
 186          ppc_elf_std_reloc,     /* special_function */
 187          "R_PPC_ADDR16",        /* name */
 188          false,                 /* partial_inplace */
 189          0,                     /* src_mask */
 190          0xffff,                /* dst_mask */
 191          false),                /* pcrel_offset */
 192
 193   /* A 16 bit relocation without overflow.  */
 194   HOWTO (R_PPC_ADDR16_LO,       /* type */
 195          0,                     /* rightshift */
 196          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 197          16,                    /* bitsize */
 198          false,                 /* pc_relative */
 199          0,                     /* bitpos */
 200          complain_overflow_dont,/* complain_on_overflow */
 201          ppc_elf_std_reloc,     /* special_function */
 202          "R_PPC_ADDR16_LO",     /* name */
 203          false,                 /* partial_inplace */
 204          0,                     /* src_mask */
 205          0xffff,                /* dst_mask */
 206          false),                /* pcrel_offset */
 207
 208   /* The high order 16 bits of an address.  */
 209   HOWTO (R_PPC_ADDR16_HI,       /* type */
 210          16,                    /* rightshift */
 211          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 212          16,                    /* bitsize */
 213          false,                 /* pc_relative */
 214          0,                     /* bitpos */
 215          complain_overflow_dont, /* complain_on_overflow */
 216          ppc_elf_std_reloc,     /* special_function */
 217          "R_PPC_ADDR16_HI",     /* name */
 218          false,                 /* partial_inplace */
 219          0,                     /* src_mask */
 220          0xffff,                /* dst_mask */
 221          false),                /* pcrel_offset */
 222
 223   /* The high order 16 bits of an address, plus 1 if the contents of
 224      the low 16 bits, treated as a signed number, is negative.  */
 225   HOWTO (R_PPC_ADDR16_HA,       /* type */
 226          16,                    /* rightshift */
 227          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 228          16,                    /* bitsize */
 229          false,                 /* pc_relative */
 230          0,                     /* bitpos */
 231          complain_overflow_dont, /* complain_on_overflow */
 232          ppc_elf_addr16_ha_reloc, /* special_function */
 233          "R_PPC_ADDR16_HA",     /* name */
 234          false,                 /* partial_inplace */
 235          0,                     /* src_mask */
 236          0xffff,                /* dst_mask */
 237          false),                /* pcrel_offset */
 238
 239   /* An absolute 16 bit branch; the lower two bits must be zero.
 240      FIXME: we don't check that, we just clear them.  */
 241   HOWTO (R_PPC_ADDR14,          /* type */
 242          0,                     /* rightshift */
 243          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 244          16,                    /* bitsize */
 245          false,                 /* pc_relative */
 246          0,                     /* bitpos */
 247          complain_overflow_bitfield, /* complain_on_overflow */
 248          ppc_elf_std_reloc,     /* special_function */
 249          "R_PPC_ADDR14",        /* name */
 250          false,                 /* partial_inplace */
 251          0,                     /* src_mask */
 252          0xfffc,                /* dst_mask */
 253          false),                /* pcrel_offset */
 254
 255   /* An absolute 16 bit branch, for which bit 10 should be set to
 256      indicate that the branch is expected to be taken.  The lower two
 257      bits must be zero.  */
 258   HOWTO (R_PPC_ADDR14_BRTAKEN,  /* type */
 259          0,                     /* rightshift */
 260          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 261          16,                    /* bitsize */
 262          false,                 /* pc_relative */
 263          0,                     /* bitpos */
 264          complain_overflow_bitfield, /* complain_on_overflow */
 265          ppc_elf_unsupported_reloc, /* special_function */
 266          "R_PPC_ADDR14_BRTAKEN",/* name */
 267          false,                 /* partial_inplace */
 268          0,                     /* src_mask */
 269          0xfffc,                /* dst_mask */
 270          false),                /* pcrel_offset */
 271
 272   /* An absolute 16 bit branch, for which bit 10 should be set to
 273      indicate that the branch is not expected to be taken.  The lower
 274      two bits must be zero.  */
 275   HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
 276          0,                     /* rightshift */
 277          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 278          16,                    /* bitsize */
 279          false,                 /* pc_relative */
 280          0,                     /* bitpos */
 281          complain_overflow_bitfield, /* complain_on_overflow */
 282          ppc_elf_unsupported_reloc, /* special_function */
 283          "R_PPC_ADDR14_BRNTAKEN",/* name */
 284          false,                 /* partial_inplace */
 285          0,                     /* src_mask */
 286          0xfffc,                /* dst_mask */
 287          false),                /* pcrel_offset */
 288
 289   /* A relative 26 bit branch; the lower two bits must be zero.  */
 290   HOWTO (R_PPC_REL24,           /* type */
 291          0,                     /* rightshift */
 292          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 293          26,                    /* bitsize */
 294          true,                  /* pc_relative */
 295          0,                     /* bitpos */
 296          complain_overflow_signed, /* complain_on_overflow */
 297          ppc_elf_std_reloc,     /* special_function */
 298          "R_PPC_REL24",         /* name */
 299          false,                 /* partial_inplace */
 300          0,                     /* src_mask */
 301          0x3fffffc,             /* dst_mask */
 302          true),                 /* pcrel_offset */
 303
 304   /* A relative 16 bit branch; the lower two bits must be zero.  */
 305   HOWTO (R_PPC_REL14,           /* type */
 306          0,                     /* rightshift */
 307          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          16,                    /* bitsize */
 309          true,                  /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_signed, /* complain_on_overflow */
 312          ppc_elf_std_reloc,     /* special_function */
 313          "R_PPC_REL14",         /* name */
 314          false,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0xfffc,                /* dst_mask */
 317          true),                 /* pcrel_offset */
 318
 319   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 320      the branch is expected to be taken.  The lower two bits must be
 321      zero.  */
 322   HOWTO (R_PPC_REL14_BRTAKEN,   /* type */
 323          0,                     /* rightshift */
 324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          16,                    /* bitsize */
 326          false,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_signed, /* complain_on_overflow */
 329          ppc_elf_unsupported_reloc, /* special_function */
 330          "R_PPC_REL14_BRTAKEN", /* name */
 331          false,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xfffc,                /* dst_mask */
 334          true),                 /* pcrel_offset */
 335
 336   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 337      the branch is not expected to be taken.  The lower two bits must
 338      be zero.  */
 339   HOWTO (R_PPC_REL14_BRNTAKEN,  /* type */
 340          0,                     /* rightshift */
 341          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          false,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_signed, /* complain_on_overflow */
 346          ppc_elf_unsupported_reloc, /* special_function */
 347          "R_PPC_REL14_BRNTAKEN",/* name */
 348          false,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xfffc,                /* dst_mask */
 351          true),                 /* pcrel_offset */
 352
 353   /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
 354      symbol.  */
 355   HOWTO (R_PPC_GOT16,           /* type */
 356          0,                     /* rightshift */
 357          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 358          16,                    /* bitsize */
 359          false,                 /* pc_relative */
 360          0,                     /* bitpos */
 361          complain_overflow_signed, /* complain_on_overflow */
 362          ppc_elf_got16_reloc,   /* special_function */
 363          "R_PPC_GOT16",         /* name */
 364          false,                 /* partial_inplace */
 365          0,                     /* src_mask */
 366          0xffff,                /* dst_mask */
 367          false),                /* pcrel_offset */
 368
 369   /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
 370      the symbol.  */
 371   HOWTO (R_PPC_GOT16_LO,        /* type */
 372          0,                     /* rightshift */
 373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 374          16,                    /* bitsize */
 375          false,                 /* pc_relative */
 376          0,                     /* bitpos */
 377          complain_overflow_bitfield, /* complain_on_overflow */
 378          ppc_elf_got16_reloc,   /* special_function */
 379          "R_PPC_GOT16_LO",      /* name */
 380          false,                 /* partial_inplace */
 381          0,                     /* src_mask */
 382          0xffff,                /* dst_mask */
 383          false),                /* pcrel_offset */
 384
 385   /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
 386      the symbol.  */
 387   HOWTO (R_PPC_GOT16_HI,        /* type */
 388          16,                    /* rightshift */
 389          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 390          16,                    /* bitsize */
 391          false,                 /* pc_relative */
 392          0,                     /* bitpos */
 393          complain_overflow_bitfield, /* complain_on_overflow */
 394          ppc_elf_got16_reloc,   /* special_function */
 395          "R_PPC_GOT16_HI",      /* name */
 396          false,                 /* partial_inplace */
 397          0,                     /* src_mask */
 398          0xffff,                /* dst_mask */
 399          false),                 /* pcrel_offset */
 400
 401   /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
 402      the symbol.  FIXME: Not supported.  */
 403   HOWTO (R_PPC_GOT16_HA,        /* type */
 404          0,                     /* rightshift */
 405          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          16,                    /* bitsize */
 407          false,                 /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_bitfield, /* complain_on_overflow */
 410          ppc_elf_unsupported_reloc, /* special_function */
 411          "R_PPC_GOT16_HA",      /* name */
 412          false,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0xffff,                /* dst_mask */
 415          false),                /* pcrel_offset */
 416
 417   /* Like R_PPC_REL24, but referring to the procedure linkage table
 418      entry for the symbol.  FIXME: Not supported.  */
 419   HOWTO (R_PPC_PLT24,           /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          26,                    /* bitsize */
 423          true,                  /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_signed, /* complain_on_overflow */
 426          ppc_elf_std_reloc,     /* special_function */
 427          "R_PPC_PLT24",         /* name */
 428          false,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x3fffffc,             /* dst_mask */
 431          true),                 /* pcrel_offset */
 432
 433   /* This is used only by the dynamic linker.  The symbol should exist
 434      both in the object being run and in some shared library.  The
 435      dynamic linker copies the data addressed by the symbol from the
 436      shared library into the object.  I have no idea what the purpose
 437      of this is.  */
 438   HOWTO (R_PPC_COPY,            /* type */
 439          0,                     /* rightshift */
 440          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 441          32,                    /* bitsize */
 442          false,                 /* pc_relative */
 443          0,                     /* bitpos */
 444          complain_overflow_bitfield, /* complain_on_overflow */
 445          ppc_elf_std_reloc,     /* special_function */
 446          "R_PPC_COPY",          /* name */
 447          false,                 /* partial_inplace */
 448          0,                     /* src_mask */
 449          0,                     /* dst_mask */
 450          false),                /* pcrel_offset */
 451
 452   /* Like R_PPC_ADDR32, but used when setting global offset table
 453      entries.  */
 454   HOWTO (R_PPC_GLOB_DAT,        /* type */
 455          0,                     /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          32,                    /* bitsize */
 458          false,                 /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_bitfield, /* complain_on_overflow */
 461          ppc_elf_std_reloc,     /* special_function */
 462          "R_PPC_GLOB_DAT",      /* name */
 463          false,                 /* partial_inplace */
 464          0,                     /* src_mask */
 465          0xffffffff,            /* dst_mask */
 466          false),                /* pcrel_offset */
 467
 468   /* Marks a procedure linkage table entry for a symbol.  */
 469   HOWTO (R_PPC_JMP_SLOT,        /* type */
 470          0,                     /* rightshift */
 471          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          32,                    /* bitsize */
 473          false,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_bitfield, /* complain_on_overflow */
 476          ppc_elf_std_reloc,     /* special_function */
 477          "R_PPC_JMP_SLOT",      /* name */
 478          false,                 /* partial_inplace */
 479          0,                     /* src_mask */
 480          0,                     /* dst_mask */
 481          false),                /* pcrel_offset */
 482
 483   /* Used only by the dynamic linker.  When the object is run, this
 484      longword is set to the load address of the object, plus the
 485      addend.  */
 486   HOWTO (R_PPC_RELATIVE,        /* type */
 487          0,                     /* rightshift */
 488          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 489          32,                    /* bitsize */
 490          false,                 /* pc_relative */
 491          0,                     /* bitpos */
 492          complain_overflow_bitfield, /* complain_on_overflow */
 493          ppc_elf_std_reloc,     /* special_function */
 494          "R_PPC_RELATIVE",      /* name */
 495          false,                 /* partial_inplace */
 496          0,                     /* src_mask */
 497          0xffffffff,            /* dst_mask */
 498          false),                /* pcrel_offset */
 499
 500   /* Like R_PPC_REL24, but uses the value of the symbol within the
 501      object rather than the final value.  Normally used for
 502      _GLOBAL_OFFSET_TABLE_.  FIXME: Not supported.  */
 503   HOWTO (R_PPC_LOCAL24PC,       /* type */
 504          0,                     /* rightshift */
 505          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 506          26,                    /* bitsize */
 507          true,                  /* pc_relative */
 508          0,                     /* bitpos */
 509          complain_overflow_signed, /* complain_on_overflow */
 510          ppc_elf_unsupported_reloc, /* special_function */
 511          "R_PPC_LOCAL24PC",     /* name */
 512          false,                 /* partial_inplace */
 513          0,                     /* src_mask */
 514          0x3fffffc,             /* dst_mask */
 515          true),                 /* pcrel_offset */
 516
 517   /* Like R_PPC_ADDR32, but may be unaligned.  */
 518   HOWTO (R_PPC_UADDR32,         /* type */
 519          0,                     /* rightshift */
 520          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 521          32,                    /* bitsize */
 522          false,                 /* pc_relative */
 523          0,                     /* bitpos */
 524          complain_overflow_bitfield, /* complain_on_overflow */
 525          ppc_elf_std_reloc,     /* special_function */
 526          "R_PPC_UADDR32",       /* name */
 527          false,                 /* partial_inplace */
 528          0,                     /* src_mask */
 529          0xffffffff,            /* dst_mask */
 530          false),                /* pcrel_offset */
 531
 532   /* Like R_PPC_ADDR16, but may be unaligned.  */
 533   HOWTO (R_PPC_UADDR16,         /* type */
 534          0,                     /* rightshift */
 535          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 536          16,                    /* bitsize */
 537          false,                 /* pc_relative */
 538          0,                     /* bitpos */
 539          complain_overflow_bitfield, /* complain_on_overflow */
 540          ppc_elf_std_reloc,     /* special_function */
 541          "R_PPC_UADDR16",       /* name */
 542          false,                 /* partial_inplace */
 543          0,                     /* src_mask */
 544          0xffff,                /* dst_mask */
 545          false),                /* pcrel_offset */
 546
 547   /* 32-bit PC relative */
 548   HOWTO (R_PPC_REL32,           /* type */
 549          0,                     /* rightshift */
 550          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 551          32,                    /* bitsize */
 552          true,                  /* pc_relative */
 553          0,                     /* bitpos */
 554          complain_overflow_bitfield, /* complain_on_overflow */
 555          ppc_elf_std_reloc,     /* special_function */
 556          "R_PPC_REL32",         /* name */
 557          false,                 /* partial_inplace */
 558          0,                     /* src_mask */
 559          0xffffffff,            /* dst_mask */
 560          true),                 /* pcrel_offset */
 561
 562   /* 32-bit relocation to the symbol's procedure linkage table.
 563      FIXEME: not supported. */
 564   HOWTO (R_PPC_PLT32,           /* type */
 565          0,                     /* rightshift */
 566          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 567          32,                    /* bitsize */
 568          false,                 /* pc_relative */
 569          0,                     /* bitpos */
 570          complain_overflow_bitfield, /* complain_on_overflow */
 571          ppc_elf_unsupported_reloc, /* special_function */
 572          "R_PPC_PLT32",         /* name */
 573          false,                 /* partial_inplace */
 574          0,                     /* src_mask */
 575          0,                     /* dst_mask */
 576          false),                /* pcrel_offset */
 577
 578   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 579      FIXEME: not supported. */
 580   HOWTO (R_PPC_PLTREL32,        /* type */
 581          0,                     /* rightshift */
 582          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 583          32,                    /* bitsize */
 584          true,                  /* pc_relative */
 585          0,                     /* bitpos */
 586          complain_overflow_bitfield, /* complain_on_overflow */
 587          ppc_elf_unsupported_reloc, /* special_function */
 588          "R_PPC_PLTREL32",      /* name */
 589          false,                 /* partial_inplace */
 590          0,                     /* src_mask */
 591          0,                     /* dst_mask */
 592          true),                 /* pcrel_offset */
 593
 594   /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
 595      the symbol.  */
 596   HOWTO (R_PPC_PLT16_LO,        /* type */
 597          0,                     /* rightshift */
 598          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 599          16,                    /* bitsize */
 600          false,                 /* pc_relative */
 601          0,                     /* bitpos */
 602          complain_overflow_bitfield, /* complain_on_overflow */
 603          ppc_elf_unsupported_reloc, /* special_function */
 604          "R_PPC_PLT16_LO",      /* name */
 605          false,                 /* partial_inplace */
 606          0,                     /* src_mask */
 607          0xffff,                /* dst_mask */
 608          false),                /* pcrel_offset */
 609
 610   /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
 611      the symbol.  */
 612   HOWTO (R_PPC_PLT16_HI,        /* type */
 613          16,                    /* rightshift */
 614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 615          16,                    /* bitsize */
 616          false,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_bitfield, /* complain_on_overflow */
 619          ppc_elf_unsupported_reloc, /* special_function */
 620          "R_PPC_PLT16_HI",      /* name */
 621          false,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          0xffff,                /* dst_mask */
 624          false),                 /* pcrel_offset */
 625
 626   /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
 627      the symbol.  FIXME: Not supported.  */
 628   HOWTO (R_PPC_PLT16_HA,        /* type */
 629          0,                     /* rightshift */
 630          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 631          16,                    /* bitsize */
 632          false,                 /* pc_relative */
 633          0,                     /* bitpos */
 634          complain_overflow_bitfield, /* complain_on_overflow */
 635          ppc_elf_unsupported_reloc, /* special_function */
 636          "R_PPC_PLT16_HA",      /* name */
 637          false,                 /* partial_inplace */
 638          0,                     /* src_mask */
 639          0xffff,                /* dst_mask */
 640          false),                /* pcrel_offset */
 641
 642   /* A sign-extended 16 bit value relative to _SDA_BASE, for use with
 643      small data items.  */
 644   HOWTO (R_PPC_SDAREL,          /* type */
 645          0,                     /* rightshift */
 646          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 647          16,                    /* bitsize */
 648          false,                 /* pc_relative */
 649          0,                     /* bitpos */
 650          complain_overflow_signed, /* complain_on_overflow */
 651          ppc_elf_got16_reloc,   /* special_function */
 652          "R_PPC_SDAREL",        /* name */
 653          false,                 /* partial_inplace */
 654          0,                     /* src_mask */
 655          0xffff,                /* dst_mask */
 656          false),                /* pcrel_offset */
 657
 658   /* These next 4 relocations were added by Sun. */
 659   /* 32-bit section relative relocation. FIXME: not supported. */
 660   HOWTO (R_PPC_SECTOFF,         /* type */
 661          0,                     /* rightshift */
 662          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 663          32,                    /* bitsize */
 664          true,                  /* pc_relative */
 665          0,                     /* bitpos */
 666          complain_overflow_bitfield, /* complain_on_overflow */
 667          ppc_elf_unsupported_reloc, /* special_function */
 668          "R_PPC_SECTOFF",       /* name */
 669          false,                 /* partial_inplace */
 670          0,                     /* src_mask */
 671          0,                     /* dst_mask */
 672          true),                 /* pcrel_offset */
 673
 674   /* 16-bit lower half section relative relocation. FIXME: not supported. */
 675   HOWTO (R_PPC_SECTOFF_LO,        /* type */
 676          0,                     /* rightshift */
 677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 678          16,                    /* bitsize */
 679          false,                 /* pc_relative */
 680          0,                     /* bitpos */
 681          complain_overflow_bitfield, /* complain_on_overflow */
 682          ppc_elf_unsupported_reloc, /* special_function */
 683          "R_PPC_SECTOFF_LO",    /* name */
 684          false,                 /* partial_inplace */
 685          0,                     /* src_mask */
 686          0xffff,                /* dst_mask */
 687          false),                /* pcrel_offset */
 688
 689   /* 16-bit upper half section relative relocation. FIXME: not supported. */
 690   HOWTO (R_PPC_SECTOFF_HI,      /* type */
 691          16,                    /* rightshift */
 692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 693          16,                    /* bitsize */
 694          false,                 /* pc_relative */
 695          0,                     /* bitpos */
 696          complain_overflow_bitfield, /* complain_on_overflow */
 697          ppc_elf_unsupported_reloc, /* special_function */
 698          "R_PPC_SECTOFF_HI",    /* name */
 699          false,                 /* partial_inplace */
 700          0,                     /* src_mask */
 701          0xffff,                /* dst_mask */
 702          false),                 /* pcrel_offset */
 703
 704   /* 16-bit upper half adjusted section relative relocation. FIXME: not supported. */
 705   HOWTO (R_PPC_SECTOFF_HA,      /* type */
 706          0,                     /* rightshift */
 707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 708          16,                    /* bitsize */
 709          false,                 /* pc_relative */
 710          0,                     /* bitpos */
 711          complain_overflow_bitfield, /* complain_on_overflow */
 712          ppc_elf_unsupported_reloc, /* special_function */
 713          "R_PPC_SECTOFF_HA",    /* name */
 714          false,                 /* partial_inplace */
 715          0,                     /* src_mask */
 716          0xffff,                /* dst_mask */
 717          false),                /* pcrel_offset */
 718
 719   /* The remaining relocs are from the Embedded ELF ABI, and are not
 720      in the SVR4 ELF ABI.  */
 721
 722   /* 32 bit value resulting from the addend minus the symbol */
 723   HOWTO (R_PPC_EMB_NADDR32,     /* type */
 724          0,                     /* rightshift */
 725          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          32,                    /* bitsize */
 727          false,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_bitfield, /* complain_on_overflow */
 730          ppc_elf_unsupported_reloc, /* special_function */
 731          "R_PPC_EMB_NADDR32",   /* name */
 732          false,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffffffff,            /* dst_mask */
 735          false),                /* pcrel_offset */
 736
 737   /* 16 bit value resulting from the addend minus the symbol */
 738   HOWTO (R_PPC_EMB_NADDR16,     /* type */
 739          0,                     /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          false,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_bitfield, /* complain_on_overflow */
 745          ppc_elf_unsupported_reloc, /* special_function */
 746          "R_PPC_EMB_NADDR16",   /* name */
 747          false,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          false),                /* pcrel_offset */
 751
 752   /* 16 bit value resulting from the addend minus the symbol */
 753   HOWTO (R_PPC_EMB_NADDR16_LO,  /* type */
 754          0,                     /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          false,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_dont,/* complain_on_overflow */
 760          ppc_elf_unsupported_reloc, /* special_function */
 761          "R_PPC_EMB_ADDR16_LO", /* name */
 762          false,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          false),                /* pcrel_offset */
 766
 767   /* The high order 16 bits of the addend minus the symbol */
 768   HOWTO (R_PPC_EMB_NADDR16_HI,  /* type */
 769          16,                    /* rightshift */
 770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          16,                    /* bitsize */
 772          false,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_dont, /* complain_on_overflow */
 775          ppc_elf_unsupported_reloc, /* special_function */
 776          "R_PPC_EMB_NADDR16_HI", /* name */
 777          false,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xffff,                /* dst_mask */
 780          false),                /* pcrel_offset */
 781
 782   /* The high order 16 bits of the result of the addend minus the address,
 783      plus 1 if the contents of the low 16 bits, treated as a signed number,
 784      is negative.  */
 785   HOWTO (R_PPC_EMB_NADDR16_HA,  /* type */
 786          16,                    /* rightshift */
 787          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          16,                    /* bitsize */
 789          false,                 /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_dont, /* complain_on_overflow */
 792          ppc_elf_unsupported_reloc, /* special_function */
 793          "R_PPC_EMB_NADDR16_HA", /* name */
 794          false,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          0xffff,                /* dst_mask */
 797          false),                /* pcrel_offset */
 798 };
 799
 800 \f
 801 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done.  */
 802
 803 static void
 804 ppc_elf_howto_init ()
 805 {
 806   unsigned int i, type;
 807
 808   for (i = 0; i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); i++)
 809     {
 810       type = ppc_elf_howto_raw[i].type;
 811       BFD_ASSERT (type < sizeof(ppc_elf_howto_table) / sizeof(ppc_elf_howto_table[0]));
 812       ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
 813     }
 814 }
 815
 816 \f
 817 static reloc_howto_type *
 818 ppc_elf_reloc_type_lookup (abfd, code)
 819      bfd *abfd;
 820      bfd_reloc_code_real_type code;
 821 {
 822   if (!ppc_elf_howto_table[ R_PPC_ADDR32 ])     /* Initialize howto table if needed */
 823     ppc_elf_howto_init ();
 824
 825   switch ((int)code)
 826     {
 827     case BFD_RELOC_NONE:        return ppc_elf_howto_table[ (int) R_PPC_NONE ];
 828     case BFD_RELOC_32:          return ppc_elf_howto_table[ (int) R_PPC_ADDR32 ];
 829     case BFD_RELOC_32_PCREL:    return ppc_elf_howto_table[ (int) R_PPC_REL32 ];
 830     case BFD_RELOC_CTOR:        return ppc_elf_howto_table[ (int) R_PPC_ADDR32 ];
 831     case BFD_RELOC_PPC_B26:     return ppc_elf_howto_table[ (int) R_PPC_REL24 ];
 832     case BFD_RELOC_PPC_BA26:    return ppc_elf_howto_table[ (int) R_PPC_ADDR24 ];
 833     case BFD_RELOC_PPC_TOC16:   return ppc_elf_howto_table[ (int) R_PPC_GOT16 ];
 834     case BFD_RELOC_LO16:        return ppc_elf_howto_table[ (int) R_PPC_ADDR16_LO ];
 835     case BFD_RELOC_HI16:        return ppc_elf_howto_table[ (int) R_PPC_ADDR16_HI ];
 836     case BFD_RELOC_HI16_S:      return ppc_elf_howto_table[ (int) R_PPC_ADDR16_HA ];
 837     case BFD_RELOC_GPREL16:     return ppc_elf_howto_table[ (int) R_PPC_SDAREL ];
 838     }
 839
 840   return (reloc_howto_type *)NULL;
 841 };
 842
 843 /* Set the howto pointer for a PowerPC ELF reloc.  */
 844
 845 static void
 846 ppc_elf_info_to_howto (abfd, cache_ptr, dst)
 847      bfd *abfd;
 848      arelent *cache_ptr;
 849      Elf32_Internal_Rela *dst;
 850 {
 851   if (!ppc_elf_howto_table[ R_PPC_ADDR32 ])     /* Initialize howto table if needed */
 852     ppc_elf_howto_init ();
 853
 854   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
 855   cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
 856 }
 857
 858 /* Function to set whether a module needs the -mrelocatable bit set. */
 859
 860 static boolean
 861 ppc_elf_set_private_flags (abfd, flags)
 862      bfd *abfd;
 863      flagword flags;
 864 {
 865   BFD_ASSERT (!elf_ppc_flags_init (abfd)
 866               || elf_elfheader (abfd)->e_flags == flags);
 867
 868   elf_elfheader (abfd)->e_flags = flags;
 869   elf_ppc_flags_init (abfd) = true;
 870   return true;
 871 }
 872
 873 /* Copy backend specific data from one object module to another */
 874 static boolean
 875 ppc_elf_copy_private_bfd_data (ibfd, obfd)
 876      bfd *ibfd;
 877      bfd *obfd;
 878 {
 879   /* This function is selected based on the input vector.  We only
 880      want to copy information over if the output BFD also uses Elf
 881      format.  */
 882   if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 883     return true;
 884
 885   BFD_ASSERT (!elf_ppc_flags_init (obfd)
 886               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 887
 888   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 889   elf_ppc_flags_init (obfd) = true;
 890   return true;
 891 }
 892
 893 /* Merge backend specific data from an object file to the output
 894    object file when linking */
 895 static boolean
 896 ppc_elf_merge_private_bfd_data (ibfd, obfd)
 897      bfd *ibfd;
 898      bfd *obfd;
 899 {
 900   flagword old_flags;
 901   flagword new_flags;
 902
 903   /* Check if we have the same endianess */
 904   if (ibfd->xvec->byteorder_big_p != obfd->xvec->byteorder_big_p)
 905     {
 906       fprintf (stderr,
 907                "%s: compiled for a %s endian system and target is %s endian.\n",
 908                bfd_get_filename (ibfd),
 909                (ibfd->xvec->byteorder_big_p) ? "big" : "little",
 910                (obfd->xvec->byteorder_big_p) ? "big" : "little");
 911
 912       bfd_set_error (bfd_error_wrong_format);
 913       return false;
 914     }
 915
 916   /* This function is selected based on the input vector.  We only
 917      want to copy information over if the output BFD also uses Elf
 918      format.  */
 919   if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 920     return true;
 921
 922   new_flags = elf_elfheader (ibfd)->e_flags;
 923   old_flags = elf_elfheader (obfd)->e_flags;
 924   if (!elf_ppc_flags_init (obfd))       /* First call, no flags set */
 925     {
 926       elf_ppc_flags_init (obfd) = true;
 927       elf_elfheader (obfd)->e_flags = new_flags;
 928     }
 929
 930   else if (new_flags == old_flags)      /* Compatible flags are ok */
 931     ;
 932
 933   else                                  /* Incompatible flags */
 934     {
 935       /* Warn about -mrelocatable mismatch.  Allow -mrelocatable-lib to be linked
 936          with either.  */
 937       if ((new_flags & EF_PPC_RELOCATABLE) != 0
 938           && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
 939         {
 940           fprintf (stderr,
 941                    "%s: compiled with -mrelocatable and linked with modules compiled normally\n",
 942                    bfd_get_filename (ibfd));
 943         }
 944       else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
 945                && (old_flags & EF_PPC_RELOCATABLE) != 0)
 946         {
 947           fprintf (stderr,
 948                    "%s: compiled normally and linked with modules compiled with -mrelocatable\n",
 949                    bfd_get_filename (ibfd));
 950         }
 951       else if ((new_flags & EF_PPC_RELOCATABLE_LIB) != 0)
 952         elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE_LIB;
 953
 954       new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB);
 955       old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB);
 956
 957       /* Warn about eabi vs. V.4 mismatch */
 958       if ((new_flags & EF_PPC_EMB) != 0 && (old_flags & EF_PPC_EMB) == 0)
 959         {
 960           new_flags &= ~EF_PPC_EMB;
 961           fprintf (stderr,
 962                    "%s: compiled for the eabi and linked with modules compiled for System V\n",
 963                    bfd_get_filename (ibfd));
 964         }
 965       else if ((new_flags & EF_PPC_EMB) == 0 && (old_flags & EF_PPC_EMB) != 0)
 966         {
 967           old_flags &= ~EF_PPC_EMB;
 968           fprintf (stderr,
 969                    "%s: compiled for System V and linked with modules compiled for eabi\n",
 970                    bfd_get_filename (ibfd));
 971         }
 972
 973       /* Warn about any other mismatches */
 974       if (new_flags != old_flags)
 975         fprintf (stderr,
 976                  "%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)\n",
 977                  bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
 978
 979       bfd_set_error (bfd_error_bad_value);
 980       return false;
 981     }
 982
 983   return true;
 984 }
 985
 986 \f
 987 /* ELF relocs are against symbols.  If we are producing relocateable
 988    output, and the reloc is against an external symbol, and nothing
 989    has given us any additional addend, the resulting reloc will also
 990    be against the same symbol.  In such a case, we don't want to
 991    change anything about the way the reloc is handled, since it will
 992    all be done at final link time.  Rather than put special case code
 993    into bfd_perform_relocation, all the reloc types use this howto
 994    function.  It just short circuits the reloc if producing
 995    relocateable output against an external symbol.  */
 996
 997 /*ARGSUSED*/
 998 static bfd_reloc_status_type
 999 ppc_elf_std_reloc (abfd,
1000                    reloc_entry,
1001                    symbol,
1002                    data,
1003                    input_section,
1004                    output_bfd,
1005                    error_message)
1006      bfd *abfd;
1007      arelent *reloc_entry;
1008      asymbol *symbol;
1009      PTR data;
1010      asection *input_section;
1011      bfd *output_bfd;
1012      char **error_message;
1013 {
1014   if (output_bfd != (bfd *) NULL
1015       && (symbol->flags & BSF_SECTION_SYM) == 0
1016       && (! reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1017     {
1018       reloc_entry->address += input_section->output_offset;
1019       return bfd_reloc_ok;
1020     }
1021
1022   return bfd_reloc_continue;
1023 }
1024
1025 /* Don't pretend we can deal with unsupported relocs.  */
1026
1027 /*ARGSUSED*/
1028 static bfd_reloc_status_type
1029 ppc_elf_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
1030                            output_bfd, error_message)
1031      bfd *abfd;
1032      arelent *reloc_entry;
1033      asymbol *symbol;
1034      PTR data;
1035      asection *input_section;
1036      bfd *output_bfd;
1037      char **error_message;
1038 {
1039   BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
1040   fprintf (stderr,
1041            "%s: Relocation %s (%d) is not currently supported.\n",
1042            bfd_get_filename (abfd),
1043            reloc_entry->howto->name,
1044            reloc_entry->howto->type);
1045
1046   return bfd_reloc_notsupported;
1047 }
1048
1049 /* Internal function to return the adjustment to the addend for relocations
1050    that return the upper 16 bits after sign extending the lower 16 bits, ie
1051    for use with a ADDIS instruction followed by a memory reference using the
1052    bottom 16 bits.  */
1053
1054 INLINE
1055 static bfd_vma
1056 ppc_elf_addr16_ha_inner (relocation)
1057      bfd_vma relocation;
1058 {
1059   return (relocation & 0x8000) << 1;
1060 }
1061
1062 /* Handle the ADDR16_HA reloc by adjusting the reloc addend.  */
1063
1064 /*ARGSUSED*/
1065 static bfd_reloc_status_type
1066 ppc_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
1067                          output_bfd, error_message)
1068      bfd *abfd;
1069      arelent *reloc_entry;
1070      asymbol *symbol;
1071      PTR data;
1072      asection *input_section;
1073      bfd *output_bfd;
1074      char **error_message;
1075 {
1076   bfd_vma relocation;
1077   asection *sec;
1078
1079   if (output_bfd != (bfd *) NULL)
1080     return ppc_elf_std_reloc (abfd, reloc_entry, symbol, data,
1081                               input_section, output_bfd, error_message);
1082
1083   sec = symbol->section;
1084   relocation = (((bfd_is_com_section (sec)) ? 0 : symbol->value)
1085                 + sec->output_section->vma
1086                 + sec->output_offset
1087                 + reloc_entry->addend);
1088
1089   reloc_entry->addend += ppc_elf_addr16_ha_inner (relocation);
1090   return bfd_reloc_continue;
1091 }
1092
1093 /* Internal function to return the addjustment to the addend for GOT16
1094    entries */
1095
1096 INLINE
1097 static bfd_vma
1098 ppc_elf_got16_inner (sec)
1099      asection *sec;
1100 {
1101   BFD_ASSERT (bfd_is_und_section (sec)
1102               || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
1103               || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0
1104               || strcmp (bfd_get_section_name (abfd, sec), ".sdata") == 0
1105               || strcmp (bfd_get_section_name (abfd, sec), ".sbss") == 0)
1106
1107   return -(sec->output_section->vma + 0x8000);
1108 }
1109
1110 /* Handle the GOT16 reloc.  We want to use the offset within the .got
1111    section, not the actual VMA.  This is appropriate when generating
1112    an embedded ELF object, for which the .got section acts like the
1113    AIX .toc section.  When and if we support PIC code, we will have to
1114    change this, perhaps by switching off on the e_type field.  */
1115
1116 /*ARGSUSED*/
1117 static bfd_reloc_status_type
1118 ppc_elf_got16_reloc (abfd, reloc_entry, symbol, data, input_section,
1119                      output_bfd, error_message)
1120      bfd *abfd;
1121      arelent *reloc_entry;
1122      asymbol *symbol;
1123      PTR data;
1124      asection *input_section;
1125      bfd *output_bfd;
1126      char **error_message;
1127 {
1128   if (output_bfd != (bfd *) NULL)
1129     return ppc_elf_std_reloc (abfd, reloc_entry, symbol, data,
1130                               input_section, output_bfd, error_message);
1131
1132   reloc_entry->addend += ppc_elf_got16_inner (bfd_get_section (*reloc_entry->sym_ptr_ptr));
1133   return bfd_reloc_continue;
1134 }
1135
1136 \f
1137 /* The RELOCATE_SECTION function is called by the ELF backend linker
1138    to handle the relocations for a section.
1139
1140    The relocs are always passed as Rela structures; if the section
1141    actually uses Rel structures, the r_addend field will always be
1142    zero.
1143
1144    This function is responsible for adjust the section contents as
1145    necessary, and (if using Rela relocs and generating a
1146    relocateable output file) adjusting the reloc addend as
1147    necessary.
1148
1149    This function does not have to worry about setting the reloc
1150    address or the reloc symbol index.
1151
1152    LOCAL_SYMS is a pointer to the swapped in local symbols.
1153
1154    LOCAL_SECTIONS is an array giving the section in the input file
1155    corresponding to the st_shndx field of each local symbol.
1156
1157    The global hash table entry for the global symbols can be found
1158    via elf_sym_hashes (input_bfd).
1159
1160    When generating relocateable output, this function must handle
1161    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1162    going to be the section symbol corresponding to the output
1163    section, which means that the addend must be adjusted
1164    accordingly.  */
1165
1166 static boolean
1167 ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1168                           contents, relocs, local_syms, local_sections)
1169      bfd *output_bfd;
1170      struct bfd_link_info *info;
1171      bfd *input_bfd;
1172      asection *input_section;
1173      bfd_byte *contents;
1174      Elf_Internal_Rela *relocs;
1175      Elf_Internal_Sym *local_syms;
1176      asection **local_sections;
1177 {
1178   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1179   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1180   Elf_Internal_Rela *rel = relocs;
1181   Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1182   boolean ret = true;
1183
1184 #ifdef DEBUG
1185   fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, %ld relocations%s\n",
1186            bfd_get_filename (input_bfd),
1187            bfd_section_name(input_bfd, input_section),
1188            (long)input_section->reloc_count,
1189            (info->relocateable) ? " (relocatable)" : "");
1190 #endif
1191
1192   if (!ppc_elf_howto_table[ R_PPC_ADDR32 ])     /* Initialize howto table if needed */
1193     ppc_elf_howto_init ();
1194
1195   for (; rel < relend; rel++)
1196     {
1197       enum reloc_type r_type = (enum reloc_type)ELF32_R_TYPE (rel->r_info);
1198       bfd_vma offset = rel->r_offset;
1199       bfd_vma addend = rel->r_addend;
1200       bfd_reloc_status_type r = bfd_reloc_other;
1201       Elf_Internal_Sym *sym = (Elf_Internal_Sym *)0;
1202       asection *sec = (asection *)0;
1203       struct elf_link_hash_entry *h = (struct elf_link_hash_entry *)0;
1204       reloc_howto_type *howto;
1205       unsigned long r_symndx;
1206       bfd_vma relocation;
1207
1208       /* Unknown relocation handling */
1209       if ((unsigned)r_type >= (unsigned)R_PPC_max || !ppc_elf_howto_table[(int)r_type])
1210         {
1211           fprintf (stderr,
1212                    "%s: Unknown relocation type %d\n",
1213                    bfd_get_filename (input_bfd),
1214                    (int)r_type);
1215
1216           bfd_set_error (bfd_error_bad_value);
1217           ret = false;
1218           continue;
1219         }
1220
1221       howto = ppc_elf_howto_table[(int)r_type];
1222       r_symndx = ELF32_R_SYM (rel->r_info);
1223
1224       if (info->relocateable)
1225         {
1226           /* This is a relocateable link.  We don't have to change
1227              anything, unless the reloc is against a section symbol,
1228              in which case we have to adjust according to where the
1229              section symbol winds up in the output section.  */
1230           if (r_symndx < symtab_hdr->sh_info)
1231             {
1232               sym = local_syms + r_symndx;
1233               if ((unsigned)ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1234                 {
1235                   sec = local_sections[r_symndx];
1236                   addend = rel->r_addend += sec->output_offset + sym->st_value;
1237                 }
1238             }
1239
1240 #ifdef DEBUG
1241           fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1242                    howto->name,
1243                    (int)r_type,
1244                    r_symndx,
1245                    (long)offset,
1246                    (long)addend);
1247 #endif
1248           continue;
1249         }
1250
1251       /* This is a final link.  */
1252
1253       /* Complain about known relocation that are not yet supported */
1254       if (howto->special_function == ppc_elf_unsupported_reloc)
1255         {
1256           fprintf (stderr,
1257                    "%s: Relocation %s (%d) is not currently supported.\n",
1258                    bfd_get_filename (input_bfd),
1259                    howto->name,
1260                    (int)r_type);
1261
1262           bfd_set_error (bfd_error_bad_value);
1263           ret = false;
1264           continue;
1265         }
1266
1267       if (r_symndx < symtab_hdr->sh_info)
1268         {
1269           sym = local_syms + r_symndx;
1270           sec = local_sections[r_symndx];
1271           relocation = (sec->output_section->vma
1272                         + sec->output_offset
1273                         + sym->st_value);
1274         }
1275       else
1276         {
1277           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1278           if (h->root.type == bfd_link_hash_defined
1279               || h->root.type == bfd_link_hash_defweak)
1280             {
1281               sec = h->root.u.def.section;
1282               relocation = (h->root.u.def.value
1283                             + sec->output_section->vma
1284                             + sec->output_offset);
1285             }
1286           else if (h->root.type == bfd_link_hash_undefweak)
1287             relocation = 0;
1288           else if (info->shared)
1289             relocation = 0;
1290           else
1291             {
1292               (*info->callbacks->undefined_symbol)(info,
1293                                                    h->root.root.string,
1294                                                    input_bfd,
1295                                                    input_section,
1296                                                    rel->r_offset);
1297               ret = false;
1298               continue;
1299             }
1300         }
1301
1302       switch ((int)r_type)
1303         {
1304         default:
1305           break;
1306
1307         case (int)R_PPC_GOT16:          /* GOT16 relocations */
1308         case (int)R_PPC_GOT16_LO:
1309         case (int)R_PPC_GOT16_HI:
1310         case (int)R_PPC_SDAREL:
1311           BFD_ASSERT (sec != (asection *)0);
1312           addend += ppc_elf_got16_inner (sec);
1313           break;
1314
1315         case (int)R_PPC_ADDR16_HA:      /* arithmetic adjust relocations */
1316           BFD_ASSERT (sec != (asection *)0);
1317           addend += ppc_elf_addr16_ha_inner (relocation + addend);
1318           break;
1319         }
1320
1321
1322 #ifdef DEBUG
1323       fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1324                howto->name,
1325                (int)r_type,
1326                r_symndx,
1327                (long)offset,
1328                (long)addend);
1329 #endif
1330
1331       r = _bfd_final_link_relocate (howto,
1332                                     input_bfd,
1333                                     input_section,
1334                                     contents,
1335                                     offset,
1336                                     relocation,
1337                                     addend);
1338
1339       if (r != bfd_reloc_ok)
1340         {
1341           ret = false;
1342           switch (r)
1343             {
1344             default:
1345               break;
1346
1347             case bfd_reloc_overflow:
1348               {
1349                 const char *name;
1350
1351                 if (h != NULL)
1352                   name = h->root.root.string;
1353                 else
1354                   {
1355                     name = bfd_elf_string_from_elf_section (input_bfd,
1356                                                             symtab_hdr->sh_link,
1357                                                             sym->st_name);
1358                     if (name == NULL)
1359                       break;
1360
1361                     if (*name == '\0')
1362                       name = bfd_section_name (input_bfd, sec);
1363                   }
1364
1365                 (*info->callbacks->reloc_overflow)(info,
1366                                                    name,
1367                                                    howto->name,
1368                                                    (bfd_vma) 0,
1369                                                    input_bfd,
1370                                                    input_section,
1371                                                    offset);
1372               }
1373               break;
1374
1375             }
1376         }
1377     }
1378
1379
1380 #ifdef DEBUG
1381   fprintf (stderr, "\n");
1382 #endif
1383
1384   return ret;
1385 }
1386
1387 #define TARGET_LITTLE_SYM       bfd_elf32_powerpcle_vec
1388 #define TARGET_LITTLE_NAME      "elf32-powerpcle"
1389 #define TARGET_BIG_SYM          bfd_elf32_powerpc_vec
1390 #define TARGET_BIG_NAME         "elf32-powerpc"
1391 #define ELF_ARCH                bfd_arch_powerpc
1392 #define ELF_MACHINE_CODE        EM_PPC
1393 #define ELF_MAXPAGESIZE         0x10000
1394 #define elf_info_to_howto       ppc_elf_info_to_howto
1395
1396 #ifdef  EM_CYGNUS_POWERPC
1397 #define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
1398 #endif
1399
1400 #ifdef EM_PPC_OLD
1401 #define ELF_MACHINE_ALT2        EM_PPC_OLD
1402 #endif
1403
1404 #define bfd_elf32_bfd_copy_private_bfd_data     ppc_elf_copy_private_bfd_data
1405 #define bfd_elf32_bfd_merge_private_bfd_data    ppc_elf_merge_private_bfd_data
1406 #define bfd_elf32_bfd_set_private_flags         ppc_elf_set_private_flags
1407 #define bfd_elf32_bfd_reloc_type_lookup         ppc_elf_reloc_type_lookup
1408 #define elf_backend_relocate_section            ppc_elf_relocate_section
1409
1410 #include "elf32-target.h"