bfd/coff-ppc.c

   1 /* BFD back-end for PowerPC Microsoft Portable Executable files.
   2    Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
   3
   4    Original version pieced together by Kim Knuttila (krk@cygnus.com)
   5
   6    There is nothing new under the sun. This file draws a lot on other
   7    coff files, in particular, those for the rs/6000, alpha, mips, and
   8    intel backends, and the PE work for the arm.
   9
  10 This file is part of BFD, the Binary File Descriptor library.
  11
  12 This program is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2 of the License, or
  15 (at your option) any later version.
  16
  17 This program is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with this program; if not, write to the Free Software
  24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  25
  26 /* Current State:
  27    - objdump works
  28    - relocs generated by gas
  29    - ld will link files, but they do not run.
  30    - dlltool will not produce correct output in some .reloc cases, and will
  31      not produce the right glue code for dll function calls.
  32 */
  33
  34
  35 #include "bfd.h"
  36 #include "sysdep.h"
  37 #include "libbfd.h"
  38 #include "obstack.h"
  39
  40 #include "coff/powerpc.h"
  41 #include "coff/internal.h"
  42
  43 #include "coff/pe.h"
  44
  45 #ifdef BADMAG
  46 #undef BADMAG
  47 #endif
  48
  49 #define BADMAG(x) PPCBADMAG(x)
  50
  51 #include "libcoff.h"
  52
  53 /* In order not to add an int to every hash table item for every coff
  54    linker, we define our own hash table, derived from the coff one */
  55
  56 /* PE linker hash table entries. */
  57
  58 struct ppc_coff_link_hash_entry
  59 {
  60   struct coff_link_hash_entry root; /* First entry, as required  */
  61
  62   /* As we wonder around the relocs, we'll keep the assigned toc_offset
  63      here */
  64   bfd_vma toc_offset;               /* Our addition, as required */
  65   int symbol_is_glue;
  66   unsigned long int glue_insn;
  67   char eye_catcher[8];
  68 };
  69
  70 /* Need a 7 char string for an eye catcher */
  71 #define EYE "krkjunk"
  72
  73 #define CHECK_EYE(addr) \
  74  if (strcmp(addr, EYE) != 0) \
  75   { \
  76     fprintf(stderr,\
  77     "File %s, line %d, Hash check failure, bad eye %8s\n", \
  78     __FILE__, __LINE__, addr); \
  79     abort(); \
  80  }
  81
  82 /* PE linker hash table.  */
  83
  84 struct ppc_coff_link_hash_table
  85 {
  86   struct coff_link_hash_table root; /* First entry, as required */
  87 };
  88
  89 static struct bfd_hash_entry *ppc_coff_link_hash_newfunc
  90   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
  91            const char *));
  92
  93 /* Routine to create an entry in the link hash table.  */
  94
  95 static struct bfd_hash_entry *
  96 ppc_coff_link_hash_newfunc (entry, table, string)
  97      struct bfd_hash_entry *entry;
  98      struct bfd_hash_table *table;
  99      const char *string;
 100 {
 101   struct ppc_coff_link_hash_entry *ret =
 102     (struct ppc_coff_link_hash_entry *) entry;
 103
 104   /* Allocate the structure if it has not already been allocated by a
 105      subclass.  */
 106   if (ret == (struct ppc_coff_link_hash_entry *) NULL)
 107     ret = (struct ppc_coff_link_hash_entry *)
 108       bfd_hash_allocate (table,
 109                          sizeof (struct ppc_coff_link_hash_entry));
 110
 111   if (ret == (struct ppc_coff_link_hash_entry *) NULL)
 112     return NULL;
 113
 114   /* Call the allocation method of the superclass.  */
 115   ret = ((struct ppc_coff_link_hash_entry *)
 116          _bfd_coff_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 117                                       table, string));
 118
 119   if (ret)
 120     {
 121       /* Initialize the local fields.  */
 122       ret->toc_offset = 1;
 123       ret->symbol_is_glue = 0;
 124       ret->glue_insn = 0;
 125       strcpy(ret->eye_catcher, EYE);
 126     }
 127
 128   return (struct bfd_hash_entry *) ret;
 129 }
 130
 131 /* Initialize a PE linker hash table.  */
 132
 133 static boolean
 134 ppc_coff_link_hash_table_init (table, abfd, newfunc)
 135      struct ppc_coff_link_hash_table *table;
 136      bfd *abfd;
 137      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 138                                                 struct bfd_hash_table *,
 139                                                 const char *));
 140 {
 141   return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc);
 142 }
 143
 144 /* Create a PE linker hash table.  */
 145
 146 static struct bfd_link_hash_table *
 147 ppc_coff_link_hash_table_create (abfd)
 148      bfd *abfd;
 149 {
 150   struct ppc_coff_link_hash_table *ret;
 151
 152   ret = ((struct ppc_coff_link_hash_table *)
 153          bfd_alloc (abfd, sizeof (struct ppc_coff_link_hash_table)));
 154   if (ret == NULL)
 155     {
 156       bfd_set_error (bfd_error_no_memory);
 157       return NULL;
 158     }
 159   if (! ppc_coff_link_hash_table_init (ret, abfd,
 160                                         ppc_coff_link_hash_newfunc))
 161     {
 162       bfd_release (abfd, ret);
 163       return (struct bfd_link_hash_table *) NULL;
 164     }
 165   return &ret->root.root;
 166 }
 167
 168 /* Now, tailor coffcode.h to use our hash stuff */
 169
 170 #define coff_bfd_link_hash_table_create ppc_coff_link_hash_table_create
 171
 172 \f
 173 /* The nt loader points the toc register to &toc + 32768, in order to */
 174 /* use the complete range of a 16-bit displacement (I guess). We have */
 175 /* to adjust for this when we fix up loads displaced off the toc reg. */
 176 #define TOC_LOAD_ADJUSTMENT (-32768)
 177 #define TOC_SECTION_NAME ".private.toc"
 178
 179 /* The main body of code is in coffcode.h.  */
 180
 181 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
 182
 183 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 184    from smaller values.  Start with zero, widen, *then* decrement.  */
 185 #define MINUS_ONE       (((bfd_vma)0) - 1)
 186
 187 /* these should definitely go in a header file somewhere... */
 188
 189 /* NOP */
 190 #define IMAGE_REL_PPC_ABSOLUTE          0x0000
 191
 192 /* 64-bit address */
 193 #define IMAGE_REL_PPC_ADDR64            0x0001
 194
 195 /* 32-bit address */
 196 #define IMAGE_REL_PPC_ADDR32            0x0002
 197
 198 /* 26-bit address, shifted left 2 (branch absolute) */
 199 #define IMAGE_REL_PPC_ADDR24            0x0003
 200
 201 /* 16-bit address */
 202 #define IMAGE_REL_PPC_ADDR16            0x0004
 203
 204 /* 16-bit address, shifted left 2 (load doubleword) */
 205 #define IMAGE_REL_PPC_ADDR14            0x0005
 206
 207 /* 26-bit PC-relative offset, shifted left 2 (branch relative) */
 208 #define IMAGE_REL_PPC_REL24             0x0006
 209
 210 /* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
 211 #define IMAGE_REL_PPC_REL14             0x0007
 212
 213 /* 16-bit offset from TOC base */
 214 #define IMAGE_REL_PPC_TOCREL16          0x0008
 215
 216 /* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
 217 #define IMAGE_REL_PPC_TOCREL14          0x0009
 218
 219 /* 32-bit addr w/o image base */
 220 #define IMAGE_REL_PPC_ADDR32NB          0x000A
 221
 222 /* va of containing section (as in an image sectionhdr) */
 223 #define IMAGE_REL_PPC_SECREL            0x000B
 224
 225 /* sectionheader number */
 226 #define IMAGE_REL_PPC_SECTION           0x000C
 227
 228 /* substitute TOC restore instruction iff symbol is glue code */
 229 #define IMAGE_REL_PPC_IFGLUE            0x000D
 230
 231 /* symbol is glue code; virtual address is TOC restore instruction */
 232 #define IMAGE_REL_PPC_IMGLUE            0x000E
 233
 234 /* va of containing section (limited to 16 bits) */
 235 #define IMAGE_REL_PPC_SECREL16          0x000F
 236
 237 /* stuff to handle immediate data when the number of bits in the */
 238 /* data is greater than the number of bits in the immediate field */
 239 /* We need to do (usually) 32 bit arithmetic on 16 bit chunks */
 240 #define IMAGE_REL_PPC_REFHI             0x0010
 241 #define IMAGE_REL_PPC_REFLO             0x0011
 242 #define IMAGE_REL_PPC_PAIR              0x0012
 243
 244
 245 /*  Flag bits in IMAGE_RELOCATION.TYPE */
 246
 247 /* subtract reloc value rather than adding it */
 248 #define IMAGE_REL_PPC_NEG               0x0100
 249
 250 /* fix branch prediction bit to predict branch taken */
 251 #define IMAGE_REL_PPC_BRTAKEN           0x0200
 252
 253 /* fix branch prediction bit to predict branch not taken */
 254 #define IMAGE_REL_PPC_BRNTAKEN          0x0400
 255
 256 /* toc slot defined in file (or, data in toc) */
 257 #define IMAGE_REL_PPC_TOCDEFN           0x0800
 258
 259 /* masks to isolate above values in IMAGE_RELOCATION.Type */
 260 #define IMAGE_REL_PPC_TYPEMASK          0x00FF
 261 #define IMAGE_REL_PPC_FLAGMASK          0x0F00
 262
 263 #define EXTRACT_TYPE(x)                 ((x) & IMAGE_REL_PPC_TYPEMASK)
 264 #define EXTRACT_FLAGS(x) ((x) & IMAGE_REL_PPC_FLAGMASK)
 265 #define EXTRACT_JUNK(x)  \
 266            ((x) & ~(IMAGE_REL_PPC_TYPEMASK | IMAGE_REL_PPC_FLAGMASK))
 267
 268 \f
 269 /* static helper functions to make relocation work */
 270 /* (Work In Progress) */
 271
 272 static bfd_reloc_status_type ppc_refhi_reloc PARAMS ((bfd *abfd,
 273                                                       arelent *reloc,
 274                                                       asymbol *symbol,
 275                                                       PTR data,
 276                                                       asection *section,
 277                                                       bfd *output_bfd,
 278                                                       char **error));
 279 static bfd_reloc_status_type ppc_reflo_reloc PARAMS ((bfd *abfd,
 280                                                       arelent *reloc,
 281                                                       asymbol *symbol,
 282                                                       PTR data,
 283                                                       asection *section,
 284                                                       bfd *output_bfd,
 285                                                       char **error));
 286 static bfd_reloc_status_type ppc_pair_reloc PARAMS ((bfd *abfd,
 287                                                      arelent *reloc,
 288                                                      asymbol *symbol,
 289                                                      PTR data,
 290                                                      asection *section,
 291                                                      bfd *output_bfd,
 292                                                      char **error));
 293
 294 \f
 295 static bfd_reloc_status_type ppc_toc16_reloc PARAMS ((bfd *abfd,
 296                                                       arelent *reloc,
 297                                                       asymbol *symbol,
 298                                                       PTR data,
 299                                                       asection *section,
 300                                                       bfd *output_bfd,
 301                                                       char **error));
 302
 303 static bfd_reloc_status_type ppc_addr32nb_reloc PARAMS ((bfd *abfd,
 304                                                          arelent *reloc,
 305                                                          asymbol *symbol,
 306                                                          PTR data,
 307                                                          asection *section,
 308                                                          bfd *output_bfd,
 309                                                          char **error));
 310
 311 static bfd_reloc_status_type ppc_section_reloc PARAMS ((bfd *abfd,
 312                                                         arelent *reloc,
 313                                                         asymbol *symbol,
 314                                                         PTR data,
 315                                                         asection *section,
 316                                                         bfd *output_bfd,
 317                                                         char **error));
 318
 319 static bfd_reloc_status_type ppc_secrel_reloc PARAMS ((bfd *abfd,
 320                                                        arelent *reloc,
 321                                                        asymbol *symbol,
 322                                                        PTR data,
 323                                                        asection *section,
 324                                                        bfd *output_bfd,
 325                                                        char **error));
 326
 327 static bfd_reloc_status_type ppc_imglue_reloc PARAMS ((bfd *abfd,
 328                                                        arelent *reloc,
 329                                                        asymbol *symbol,
 330                                                        PTR data,
 331                                                        asection *section,
 332                                                        bfd *output_bfd,
 333                                                        char **error));
 334
 335
 336
 337 static boolean in_reloc_p PARAMS((bfd *abfd, reloc_howto_type *howto));
 338
 339 \f
 340 /* FIXME: It'll take a while to get through all of these. I only need a few to
 341    get us started, so those I'll make sure work. Those marked FIXME are either
 342    completely unverified or have a specific unknown marked in the comment */
 343
 344 /*---------------------------------------------------------------------------*/
 345 /*                                                                           */
 346 /* Relocation entries for Windows/NT on PowerPC.                             */
 347 /*                                                                           */
 348 /* From the document "" we find the following listed as used relocs:         */
 349 /*                                                                           */
 350 /*   ABSOLUTE       : The noop                                               */
 351 /*   ADDR[64|32|16] : fields that hold addresses in data fields or the       */
 352 /*                    16 bit displacement field on a load/store.             */
 353 /*   ADDR[24|14]    : fields that hold addresses in branch and cond          */
 354 /*                    branches. These represent [26|16] bit addresses.       */
 355 /*                    The low order 2 bits are preserved.                    */
 356 /*   REL[24|14]     : branches relative to the Instruction Address           */
 357 /*                    register. These represent [26|16] bit addresses,       */
 358 /*                    as before. The instruction field will be zero, and     */
 359 /*                    the address of the SYM will be inserted at link time.  */
 360 /*   TOCREL16       : 16 bit displacement field referring to a slot in       */
 361 /*                    toc.                                                   */
 362 /*   TOCREL14       : 16 bit displacement field, similar to REL14 or ADDR14. */
 363 /*   ADDR32NB       : 32 bit address relative to the virtual origin.         */
 364 /*                    (On the alpha, this is always a linker generated thunk)*/
 365 /*                    (i.e. 32bit addr relative to the image base)           */
 366 /*   SECREL         : The value is relative to the start of the section      */
 367 /*                    containing the symbol.                                 */
 368 /*   SECTION        : access to the header containing the item. Supports the */
 369 /*                    codeview debugger.                                     */
 370 /*                                                                           */
 371 /* In particular, note that the document does not indicate that the          */
 372 /* relocations listed in the header file are used.                           */
 373 /*                                                                           */
 374 /*                                                                           */
 375 /*                                                                           */
 376 /*---------------------------------------------------------------------------*/
 377
 378 static reloc_howto_type ppc_coff_howto_table[] =
 379 {
 380   /* IMAGE_REL_PPC_ABSOLUTE 0x0000   NOP */
 381   /* Unused: */
 382   HOWTO (IMAGE_REL_PPC_ABSOLUTE, /* type */
 383          0,                      /* rightshift */
 384          0,                      /* size (0 = byte, 1 = short, 2 = long) */
 385          0,                      /* bitsize */
 386          false,                  /* pc_relative */
 387          0,                      /* bitpos */
 388          complain_overflow_dont, /* dont complain_on_overflow */
 389          0,                      /* special_function */
 390          "ABSOLUTE",             /* name */
 391          false,                  /* partial_inplace */
 392          0x00,                   /* src_mask */
 393          0x00,                   /* dst_mask */
 394          false),                 /* pcrel_offset */
 395
 396   /* IMAGE_REL_PPC_ADDR64 0x0001  64-bit address */
 397   /* Unused: */
 398   HOWTO(IMAGE_REL_PPC_ADDR64,    /* type */
 399         0,                       /* rightshift */
 400         3,                       /* size (0 = byte, 1 = short, 2 = long) */
 401         64,                      /* bitsize */
 402         false,                   /* pc_relative */
 403         0,                       /* bitpos */
 404         complain_overflow_bitfield,      /* complain_on_overflow */
 405         0,                       /* special_function */
 406         "ADDR64",               /* name */
 407         true,                    /* partial_inplace */
 408         MINUS_ONE,               /* src_mask */
 409         MINUS_ONE,               /* dst_mask */
 410         false),                 /* pcrel_offset */
 411
 412   /* IMAGE_REL_PPC_ADDR32 0x0002  32-bit address */
 413   /* Used: */
 414   HOWTO (IMAGE_REL_PPC_ADDR32,  /* type */
 415          0,                     /* rightshift */
 416          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 417          32,                    /* bitsize */
 418          false,                 /* pc_relative */
 419          0,                     /* bitpos */
 420          complain_overflow_bitfield, /* complain_on_overflow */
 421          0,                     /* special_function */
 422          "ADDR32",              /* name */
 423          true,                  /* partial_inplace */
 424          0xffffffff,            /* src_mask */
 425          0xffffffff,            /* dst_mask */
 426          false),                /* pcrel_offset */
 427
 428   /* IMAGE_REL_PPC_ADDR24 0x0003  26-bit address, shifted left 2 (branch absolute) */
 429   /* the LI field is in bit 6 through bit 29 is 24 bits, + 2 for the shift */
 430   /* Of course, That's the IBM approved bit numbering, which is not what */
 431   /* anyone else uses.... The li field is in bit 2 thru 25 */
 432   /* Used: */
 433   HOWTO (IMAGE_REL_PPC_ADDR24,  /* type */
 434          0,                     /* rightshift */
 435          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 436          26,                    /* bitsize */
 437          false,                 /* pc_relative */
 438          0,                     /* bitpos */
 439          complain_overflow_bitfield, /* complain_on_overflow */
 440          0,                     /* special_function */
 441          "ADDR24",              /* name */
 442          true,                  /* partial_inplace */
 443          0x07fffffc,            /* src_mask */
 444          0x07fffffc,            /* dst_mask */
 445          false),                /* pcrel_offset */
 446
 447   /* IMAGE_REL_PPC_ADDR16 0x0004  16-bit address */
 448   /* Used: */
 449   HOWTO (IMAGE_REL_PPC_ADDR16,  /* type */
 450          0,                     /* rightshift */
 451          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 452          16,                    /* bitsize */
 453          false,                 /* pc_relative */
 454          0,                     /* bitpos */
 455          complain_overflow_signed, /* complain_on_overflow */
 456          0,                     /* special_function */
 457          "ADDR16",              /* name */
 458          true,                  /* partial_inplace */
 459          0xffff,                /* src_mask */
 460          0xffff,                /* dst_mask */
 461          false),                /* pcrel_offset */
 462
 463   /* IMAGE_REL_PPC_ADDR14 0x0005 */
 464   /*  16-bit address, shifted left 2 (load doubleword) */
 465   /* FIXME: the mask is likely wrong, and the bit position may be as well */
 466   /* Unused: */
 467   HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
 468          1,                     /* rightshift */
 469          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 470          16,                    /* bitsize */
 471          false,                 /* pc_relative */
 472          0,                     /* bitpos */
 473          complain_overflow_signed, /* complain_on_overflow */
 474          0,                     /* special_function */
 475          "ADDR16",              /* name */
 476          true,                  /* partial_inplace */
 477          0xffff,                /* src_mask */
 478          0xffff,                /* dst_mask */
 479          false),                /* pcrel_offset */
 480
 481   /* IMAGE_REL_PPC_REL24 0x0006 */
 482   /*   26-bit PC-relative offset, shifted left 2 (branch relative) */
 483   /* Used: */
 484   HOWTO (IMAGE_REL_PPC_REL24,   /* type */
 485          0,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          26,                    /* bitsize */
 488          true,                  /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_signed, /* complain_on_overflow */
 491          0,                     /* special_function */
 492          "REL24",               /* name */
 493          true,                  /* partial_inplace */
 494          0x3fffffc,             /* src_mask */
 495          0x3fffffc,             /* dst_mask */
 496          false),                /* pcrel_offset */
 497
 498   /* IMAGE_REL_PPC_REL14 0x0007 */
 499   /*   16-bit PC-relative offset, shifted left 2 (br cond relative) */
 500   /* FIXME: the mask is likely wrong, and the bit position may be as well */
 501   /* FIXME: how does it know how far to shift? */
 502   /* Unused: */
 503   HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
 504          1,                     /* rightshift */
 505          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 506          16,                    /* bitsize */
 507          false,                 /* pc_relative */
 508          0,                     /* bitpos */
 509          complain_overflow_signed, /* complain_on_overflow */
 510          0,                     /* special_function */
 511          "ADDR16",              /* name */
 512          true,                  /* partial_inplace */
 513          0xffff,                /* src_mask */
 514          0xffff,                /* dst_mask */
 515          true),                 /* pcrel_offset */
 516
 517   /* IMAGE_REL_PPC_TOCREL16 0x0008 */
 518   /*   16-bit offset from TOC base */
 519   /* Used: */
 520   HOWTO (IMAGE_REL_PPC_TOCREL16,/* type */
 521          0,                     /* rightshift */
 522          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 523          16,                    /* bitsize */
 524          false,                 /* pc_relative */
 525          0,                     /* bitpos */
 526          complain_overflow_dont, /* complain_on_overflow */
 527          ppc_toc16_reloc,       /* special_function */
 528          "TOCREL16",            /* name */
 529          false,                 /* partial_inplace */
 530          0xffff,                /* src_mask */
 531          0xffff,                /* dst_mask */
 532          false),                /* pcrel_offset */
 533
 534   /* IMAGE_REL_PPC_TOCREL14 0x0009 */
 535   /*   16-bit offset from TOC base, shifted left 2 (load doubleword) */
 536   /* Unused: */
 537   HOWTO (IMAGE_REL_PPC_TOCREL14,/* type */
 538          1,                     /* rightshift */
 539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 540          16,                    /* bitsize */
 541          false,                 /* pc_relative */
 542          0,                     /* bitpos */
 543          complain_overflow_signed, /* complain_on_overflow */
 544          0,                     /* special_function */
 545          "TOCREL14",            /* name */
 546          false,                 /* partial_inplace */
 547          0xffff,                /* src_mask */
 548          0xffff,                /* dst_mask */
 549          false),                /* pcrel_offset */
 550
 551   /* IMAGE_REL_PPC_ADDR32NB 0x000A */
 552   /*   32-bit addr w/ image base */
 553   /* Unused: */
 554   HOWTO (IMAGE_REL_PPC_ADDR32NB,/* type */
 555          0,                     /* rightshift */
 556          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 557          32,                    /* bitsize */
 558          false,                 /* pc_relative */
 559          0,                     /* bitpos */
 560          complain_overflow_signed, /* complain_on_overflow */
 561          0,                     /* special_function */
 562          "ADDR32NB",            /* name */
 563          true,                  /* partial_inplace */
 564          0xffffffff,            /* src_mask */
 565          0xffffffff,            /* dst_mask */
 566          false),                 /* pcrel_offset */
 567
 568   /* IMAGE_REL_PPC_SECREL 0x000B */
 569   /*   va of containing section (as in an image sectionhdr) */
 570   /* Unused: */
 571   HOWTO (IMAGE_REL_PPC_SECREL,/* type */
 572          0,                     /* rightshift */
 573          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 574          32,                    /* bitsize */
 575          false,                 /* pc_relative */
 576          0,                     /* bitpos */
 577          complain_overflow_signed, /* complain_on_overflow */
 578          ppc_secrel_reloc,      /* special_function */
 579          "SECREL",              /* name */
 580          true,                  /* partial_inplace */
 581          0xffffffff,            /* src_mask */
 582          0xffffffff,            /* dst_mask */
 583          true),                 /* pcrel_offset */
 584
 585   /* IMAGE_REL_PPC_SECTION 0x000C */
 586   /*   sectionheader number */
 587   /* Unused: */
 588   HOWTO (IMAGE_REL_PPC_SECTION,/* type */
 589          0,                     /* rightshift */
 590          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 591          32,                    /* bitsize */
 592          false,                 /* pc_relative */
 593          0,                     /* bitpos */
 594          complain_overflow_signed, /* complain_on_overflow */
 595          ppc_section_reloc,     /* special_function */
 596          "SECTION",             /* name */
 597          true,                  /* partial_inplace */
 598          0xffffffff,            /* src_mask */
 599          0xffffffff,            /* dst_mask */
 600          true),                 /* pcrel_offset */
 601
 602   /* IMAGE_REL_PPC_IFGLUE 0x000D */
 603   /*   substitute TOC restore instruction iff symbol is glue code */
 604   /* Used: */
 605   HOWTO (IMAGE_REL_PPC_IFGLUE,/* type */
 606          0,                     /* rightshift */
 607          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 608          32,                    /* bitsize */
 609          false,                 /* pc_relative */
 610          0,                     /* bitpos */
 611          complain_overflow_signed, /* complain_on_overflow */
 612          0,                     /* special_function */
 613          "IFGLUE",              /* name */
 614          true,                  /* partial_inplace */
 615          0xffffffff,            /* src_mask */
 616          0xffffffff,            /* dst_mask */
 617          false),                /* pcrel_offset */
 618
 619   /* IMAGE_REL_PPC_IMGLUE 0x000E */
 620   /*   symbol is glue code; virtual address is TOC restore instruction */
 621   /* Unused: */
 622   HOWTO (IMAGE_REL_PPC_IMGLUE,/* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          false,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_dont, /* complain_on_overflow */
 629          ppc_imglue_reloc,      /* special_function */
 630          "IMGLUE",              /* name */
 631          false,                 /* partial_inplace */
 632          0xffffffff,            /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          false),                 /* pcrel_offset */
 635
 636   /* IMAGE_REL_PPC_SECREL16 0x000F */
 637   /*   va of containing section (limited to 16 bits) */
 638   /* Unused: */
 639   HOWTO (IMAGE_REL_PPC_SECREL16,/* type */
 640          0,                     /* rightshift */
 641          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 642          16,                    /* bitsize */
 643          false,                 /* pc_relative */
 644          0,                     /* bitpos */
 645          complain_overflow_signed, /* complain_on_overflow */
 646          0,                     /* special_function */
 647          "SECREL16",            /* name */
 648          true,                  /* partial_inplace */
 649          0xffff,                /* src_mask */
 650          0xffff,                /* dst_mask */
 651          true),                 /* pcrel_offset */
 652
 653   /* IMAGE_REL_PPC_REFHI             0x0010 */
 654   /* Unused: */
 655   HOWTO (IMAGE_REL_PPC_REFHI,   /* type */
 656          0,                     /* rightshift */
 657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 658          16,                    /* bitsize */
 659          false,                 /* pc_relative */
 660          0,                     /* bitpos */
 661          complain_overflow_signed, /* complain_on_overflow */
 662          ppc_refhi_reloc,       /* special_function */
 663          "REFHI",               /* name */
 664          true,                  /* partial_inplace */
 665          0xffffffff,            /* src_mask */
 666          0xffffffff,            /* dst_mask */
 667          false),                 /* pcrel_offset */
 668
 669   /* IMAGE_REL_PPC_REFLO             0x0011 */
 670   /* Unused: */
 671   HOWTO (IMAGE_REL_PPC_REFLO,   /* type */
 672          0,                     /* rightshift */
 673          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 674          16,                    /* bitsize */
 675          false,                 /* pc_relative */
 676          0,                     /* bitpos */
 677          complain_overflow_signed, /* complain_on_overflow */
 678          ppc_refhi_reloc,       /* special_function */
 679          "REFLO",               /* name */
 680          true,                  /* partial_inplace */
 681          0xffffffff,            /* src_mask */
 682          0xffffffff,            /* dst_mask */
 683          false),                /* pcrel_offset */
 684
 685   /* IMAGE_REL_PPC_PAIR              0x0012 */
 686   /* Unused: */
 687   HOWTO (IMAGE_REL_PPC_PAIR,    /* type */
 688          0,                     /* rightshift */
 689          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 690          16,                    /* bitsize */
 691          false,                 /* pc_relative */
 692          0,                     /* bitpos */
 693          complain_overflow_signed, /* complain_on_overflow */
 694          ppc_pair_reloc,        /* special_function */
 695          "PAIR",                /* name */
 696          true,                  /* partial_inplace */
 697          0xffffffff,            /* src_mask */
 698          0xffffffff,            /* dst_mask */
 699          false)                 /* pcrel_offset */
 700 };
 701
 702
 703 \f
 704
 705 /* Some really cheezy macros that can be turned on to test stderr :-) */
 706
 707 #ifdef DEBUG_RELOC
 708 #define UN_IMPL(x)                                           \
 709 {                                                            \
 710    static int i;                                             \
 711    if (i == 0)                                               \
 712      {                                                       \
 713        i = 1;                                                \
 714        fprintf(stderr,"Unimplemented Relocation -- %s\n",x); \
 715      }                                                       \
 716 }
 717
 718 #define DUMP_RELOC(n,r)                              \
 719 {                                                    \
 720    fprintf(stderr,"%s sym %d, addr %d, addend %d\n", \
 721            n, (*(r->sym_ptr_ptr))->name,             \
 722            r->address, r->addend);                   \
 723 }
 724
 725 /* Given a reloc name, n, and a pointer to an internal_reloc,
 726    dump out interesting information on the contents
 727
 728 #define n_name          _n._n_name
 729 #define n_zeroes        _n._n_n._n_zeroes
 730 #define n_offset        _n._n_n._n_offset
 731
 732 */
 733
 734 #define DUMP_RELOC2(n,r)                     \
 735 {                                            \
 736    fprintf(stderr,"%s sym %d, r_vaddr %d %s\n", \
 737            n, r->r_symndx, r->r_vaddr,\
 738            (((r->r_type) & IMAGE_REL_PPC_TOCDEFN) == 0) \
 739            ?" ":" TOCDEFN"  );      \
 740 }
 741
 742 #else
 743 #define UN_IMPL(x)
 744 #define DUMP_RELOC(n,r)
 745 #define DUMP_RELOC2(n,r)
 746 #endif
 747
 748
 749 \f
 750 /* toc construction and management routines */
 751 extern bfd* bfd_of_toc_owner;
 752 extern long int global_toc_size;
 753
 754 extern long int import_table_size;
 755 extern long int first_thunk_address;
 756 extern long int thunk_size;
 757
 758 enum toc_type
 759 {
 760   default_toc,
 761   toc_32,
 762   toc_64
 763 };
 764
 765 struct list_ele
 766 {
 767   struct list_ele *next;
 768   bfd_vma addr;
 769   int offset;
 770   const char *name;
 771 };
 772
 773 extern struct list_ele *head;
 774 extern struct list_ele *tail;
 775
 776 static void
 777 record_toc(toc_section, our_toc_offset, name)
 778      asection *toc_section;
 779      int our_toc_offset;
 780      const char *name;
 781 {
 782   /* add this entry to our toc addr-offset-name list */
 783   struct list_ele *t;
 784   t = malloc(sizeof(struct list_ele));
 785   t->next = 0;
 786   t->offset = our_toc_offset;
 787   t->name = name;
 788   t->addr = toc_section->output_offset + our_toc_offset;
 789
 790   if (head == 0)
 791     {
 792       head = t;
 793       tail = t;
 794     }
 795   else
 796     {
 797       tail->next = t;
 798       tail = t;
 799     }
 800 }
 801
 802 /* record a toc offset against a symbol */
 803 static int
 804 ppc_record_toc_entry(abfd, info, sec, sym, toc_kind)
 805      bfd *abfd;
 806      struct bfd_link_info *info;
 807      asection *sec;
 808      int sym;
 809      enum toc_type toc_kind;
 810 {
 811   bfd_byte *t;
 812   bfd_byte *old_contents;
 813   asection *s;
 814   int element_size;
 815   int data;
 816   int offset;
 817   struct ppc_coff_link_hash_entry *h;
 818   struct coff_symbol_struct *target;
 819   int ret_val;
 820   const char *name;
 821
 822   int *local_syms;
 823
 824   h = 0;
 825
 826   h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
 827   if (h != 0)
 828     {
 829       CHECK_EYE(h->eye_catcher);
 830     }
 831
 832   if (h == 0)
 833     {
 834       local_syms = obj_coff_local_toc_table(abfd);
 835       if (local_syms == 0)
 836         {
 837           int i;
 838           /* allocate a table */
 839           local_syms =
 840             (int *) bfd_zalloc (abfd,
 841                                 obj_raw_syment_count(abfd) * sizeof(int));
 842           if (local_syms == 0)
 843             {
 844               bfd_set_error (bfd_error_no_memory);
 845               return false;
 846             }
 847           obj_coff_local_toc_table(abfd) = local_syms;
 848           for (i = 0; i < obj_raw_syment_count(abfd); ++i)
 849             local_syms[i] = 1;
 850         }
 851
 852       if (local_syms[sym] == 1)
 853         {
 854           local_syms[sym] = global_toc_size;
 855           ret_val = global_toc_size;
 856           global_toc_size += 4;
 857 #ifdef TOC_DEBUG
 858           fprintf(stderr,
 859                   "Setting toc_offset for local sym %d to %d\n",
 860                   sym, ret_val);
 861 #endif
 862         }
 863       else
 864         {
 865           ret_val = local_syms[sym];
 866 #ifdef TOC_DEBUG
 867           fprintf(stderr,
 868                   "toc_offset already set for local sym %d to %d\n",
 869                   sym, ret_val);
 870 #endif
 871         }
 872     }
 873   else
 874     {
 875       name = h->root.root.root.string;
 876
 877       /* check to see if there's a toc slot allocated. If not, do it
 878          here. It will be used in relocate_section */
 879       if (h->toc_offset == 1)
 880         {
 881           h->toc_offset = global_toc_size;
 882           ret_val = global_toc_size;
 883           global_toc_size += 4;
 884 #ifdef TOC_DEBUG
 885           fprintf(stderr,
 886                   "Setting toc_offset for sym %d (%s) [h=%p] to %d\n",
 887                   sym, name, h, ret_val);
 888 #endif
 889         }
 890       else
 891         {
 892           ret_val = h->toc_offset;
 893 #ifdef TOC_DEBUG
 894           fprintf(stderr,
 895                   "toc_offset already set for sym %d (%s) [h=%p] to %d\n",
 896                   sym, name, h, ret_val);
 897 #endif
 898         }
 899     }
 900
 901   return ret_val;
 902 }
 903 /* FIXME: record a toc offset against a data-in-toc symbol */
 904 /* Now, there is currenly some confusion on what this means. In some
 905    compilers one sees the moral equivalent of:
 906       .tocd
 907       define some data
 908       .text
 909       refer to the data with a [tocv] qualifier
 910    In general, one sees something to indicate that a tocd has been
 911    seen, and that would trigger the allocation of data in toc. The IBM
 912    docs seem to suggest that anything with the TOCDEFN qualifier should
 913    never trigger storage allocation. However, in the kernel32.lib that
 914    we've been using for our test bed, there are a couple of variables
 915    referenced that fail that test.
 916
 917    So it can't work that way.
 918 */
 919 static int
 920 ppc_record_data_in_toc_entry(abfd, info, sec, sym, toc_kind)
 921      bfd *abfd;
 922      struct bfd_link_info *info;
 923      asection *sec;
 924      int sym;
 925      enum toc_type toc_kind;
 926 {
 927   bfd_byte *t;
 928   bfd_byte *old_contents;
 929   asection *s;
 930   int element_size;
 931   int data;
 932   int offset;
 933   struct ppc_coff_link_hash_entry *h = 0;
 934   struct coff_symbol_struct *target;
 935   int ret_val;
 936   const char *name;
 937
 938   int *local_syms;
 939
 940   h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
 941
 942   if (h == 0)
 943     {
 944       local_syms = obj_coff_local_toc_table(abfd);
 945       if (local_syms == 0)
 946         {
 947           int i;
 948           /* allocate a table */
 949           local_syms =
 950             (int *) bfd_zalloc (abfd,
 951                                 obj_raw_syment_count(abfd) * sizeof(int));
 952           if (local_syms == 0)
 953             {
 954               bfd_set_error (bfd_error_no_memory);
 955               return false;
 956             }
 957           obj_coff_local_toc_table(abfd) = local_syms;
 958           for (i = 0; i < obj_raw_syment_count(abfd); ++i)
 959             local_syms[i] = 1;
 960         }
 961
 962       if (local_syms[sym] == 1)
 963         {
 964           local_syms[sym] = global_toc_size;
 965           ret_val = global_toc_size;
 966           global_toc_size += 4;
 967 #ifdef TOC_DEBUG
 968           fprintf(stderr,
 969                   "Setting data_in_toc_offset for local sym %d to %d\n",
 970                   sym, ret_val);
 971 #endif
 972         }
 973       else
 974         {
 975           ret_val = local_syms[sym];
 976 #ifdef TOC_DEBUG
 977           fprintf(stderr,
 978                   "data_in_toc_offset already set for local sym %d to %d\n",
 979                   sym, ret_val);
 980 #endif
 981         }
 982     }
 983   else
 984     {
 985       CHECK_EYE(h->eye_catcher);
 986
 987       name = h->root.root.root.string;
 988
 989       /* check to see if there's a toc slot allocated. If not, do it
 990          here. It will be used in relocate_section */
 991       if (h->toc_offset == 1)
 992         {
 993 #if 0
 994           h->toc_offset = global_toc_size;
 995 #endif
 996           ret_val = global_toc_size;
 997           /* We're allocating a chunk of the toc, as opposed to a slot */
 998           /* FIXME: alignment? */
 999
1000           global_toc_size += 4;
1001 #ifdef TOC_DEBUG
1002           fprintf(stderr,
1003                   "Setting data_in_toc_offset for sym %d (%s) [h=%p] to %d\n",
1004                   sym, name, h, ret_val);
1005 #endif
1006         }
1007       else
1008         {
1009           ret_val = h->toc_offset;
1010 #ifdef TOC_DEBUG
1011           fprintf(stderr,
1012                   "data_in_toc_offset already set for sym %d (%s) [h=%p] to %d\n",
1013                   sym, name, h, ret_val);
1014 #endif
1015         }
1016     }
1017
1018   return ret_val;
1019 }
1020
1021 /* record a toc offset against a symbol */
1022 static void
1023 ppc_mark_symbol_as_glue(abfd, sym, rel)
1024      bfd *abfd;
1025      int sym;
1026      struct internal_reloc *rel;
1027 {
1028   struct ppc_coff_link_hash_entry *h;
1029
1030   h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
1031
1032   CHECK_EYE(h->eye_catcher);
1033
1034   h->symbol_is_glue = 1;
1035   h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
1036
1037   return;
1038 }
1039
1040 \f
1041 /* Provided the symbol, returns the value reffed */
1042 static long get_symbol_value PARAMS ((asymbol *));
1043
1044 static long
1045 get_symbol_value (symbol)
1046      asymbol *symbol;
1047 {
1048   long relocation = 0;
1049
1050   if (bfd_is_com_section (symbol->section))
1051     {
1052       relocation = 0;
1053     }
1054   else
1055     {
1056       relocation = symbol->value +
1057         symbol->section->output_section->vma +
1058           symbol->section->output_offset;
1059     }
1060
1061   return(relocation);
1062 }
1063
1064 /* Return true if this relocation should
1065    appear in the output .reloc section. */
1066
1067 static boolean in_reloc_p(abfd, howto)
1068      bfd * abfd;
1069      reloc_howto_type *howto;
1070 {
1071   return
1072     (! howto->pc_relative)
1073       && (howto->type != IMAGE_REL_PPC_TOCREL16)
1074       && (howto->type != IMAGE_REL_PPC_IMGLUE);
1075 }
1076
1077 /* this function is in charge of performing all the ppc PE relocations */
1078 /* Don't yet know if we want to do this this particular way ... (krk)  */
1079 /* FIXME: (it is not yet enabled) */
1080
1081 static bfd_reloc_status_type
1082 pe_ppc_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
1083               error_message)
1084      bfd *abfd;
1085      arelent *reloc_entry;
1086      asymbol *symbol_in;
1087      PTR data;
1088      asection *input_section;
1089      bfd *output_bfd;
1090      char **error_message;
1091 {
1092   /* the consth relocation comes in two parts, we have to remember
1093      the state between calls, in these variables */
1094   static boolean part1_consth_active = false;
1095   static unsigned long part1_consth_value;
1096
1097   unsigned long insn;
1098   unsigned long sym_value;
1099   unsigned long unsigned_value;
1100   unsigned short r_type;
1101   long signed_value;
1102
1103   unsigned long addr = reloc_entry->address ; /*+ input_section->vma*/
1104   bfd_byte  *hit_data =addr + (bfd_byte *)(data);
1105
1106   fprintf(stderr, "pe_ppc_reloc (%s)\n", TARGET_LITTLE_NAME);
1107
1108   r_type = reloc_entry->howto->type;
1109
1110   if (output_bfd)
1111     {
1112       /* Partial linking - do nothing */
1113       reloc_entry->address += input_section->output_offset;
1114       return bfd_reloc_ok;
1115     }
1116
1117   if (symbol_in != NULL
1118       && bfd_is_und_section (symbol_in->section))
1119     {
1120       /* Keep the state machine happy in case we're called again */
1121       if (r_type == IMAGE_REL_PPC_REFHI)
1122         {
1123           part1_consth_active = true;
1124           part1_consth_value  = 0;
1125         }
1126       return(bfd_reloc_undefined);
1127     }
1128
1129   if ((part1_consth_active) && (r_type != IMAGE_REL_PPC_PAIR))
1130     {
1131       part1_consth_active = false;
1132       *error_message = (char *) "Missing PAIR";
1133       return(bfd_reloc_dangerous);
1134     }
1135
1136
1137   sym_value = get_symbol_value(symbol_in);
1138
1139   return(bfd_reloc_ok);
1140 }
1141
1142 /* The reloc processing routine for the optimized COFF linker.  */
1143
1144 static boolean
1145 coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
1146                            contents, relocs, syms, sections)
1147      bfd *output_bfd;
1148      struct bfd_link_info *info;
1149      bfd *input_bfd;
1150      asection *input_section;
1151      bfd_byte *contents;
1152      struct internal_reloc *relocs;
1153      struct internal_syment *syms;
1154      asection **sections;
1155 {
1156   struct internal_reloc *rel;
1157   struct internal_reloc *relend;
1158   boolean hihalf;
1159   bfd_vma hihalf_val;
1160   asection *toc_section = 0;
1161   bfd_vma relocation;
1162   reloc_howto_type *howto = 0;
1163
1164 #ifdef DEBUG_RELOC
1165   fprintf(stderr,
1166           "pe_ppc_relocate_section (%s) for %s \n",
1167           TARGET_LITTLE_NAME,
1168           input_section->name);
1169
1170 #endif
1171
1172   /* If we are performing a relocateable link, we don't need to do a
1173      thing.  The caller will take care of adjusting the reloc
1174      addresses and symbol indices.  */
1175   if (info->relocateable)
1176     return true;
1177
1178   hihalf = false;
1179   hihalf_val = 0;
1180
1181   rel = relocs;
1182   relend = rel + input_section->reloc_count;
1183   for (; rel < relend; rel++)
1184     {
1185       long symndx;
1186       struct ppc_coff_link_hash_entry *h;
1187       struct internal_syment *sym;
1188       bfd_vma val;
1189
1190       asection *sec;
1191       bfd_reloc_status_type rstat;
1192       bfd_byte *loc;
1193
1194       unsigned short r_type  = EXTRACT_TYPE (rel->r_type);
1195       unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
1196       unsigned short junk    = EXTRACT_JUNK (rel->r_type);
1197
1198 #ifdef DEBUG_RELOC
1199       /* now examine flags */
1200       if (r_flags != 0)
1201         {
1202           fprintf (stderr, "Reloc with flags found!");
1203           if ( r_flags & IMAGE_REL_PPC_NEG )
1204             fprintf (stderr, " NEG");
1205           if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
1206             fprintf (stderr, " BRTAKEN");
1207           if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
1208             fprintf (stderr, " BRNTAKEN");
1209           if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
1210             fprintf (stderr, " TOCDEFN");
1211           fprintf(stderr, "\n");
1212         }
1213 #endif
1214
1215       symndx = rel->r_symndx;
1216       loc = contents + rel->r_vaddr - input_section->vma;
1217
1218       /* FIXME: check bounds on r_type */
1219       howto = ppc_coff_howto_table + r_type;
1220
1221       if (symndx == -1)
1222         {
1223           h = NULL;
1224           sym = NULL;
1225         }
1226       else
1227         {
1228           h = (struct ppc_coff_link_hash_entry *)
1229             (obj_coff_sym_hashes (input_bfd)[symndx]);
1230           if (h != 0)
1231             {
1232               CHECK_EYE(h->eye_catcher);
1233             }
1234
1235           sym = syms + symndx;
1236         }
1237
1238       sec = NULL;
1239       val = 0;
1240
1241       /* FIXME: PAIR unsupported in the following code */
1242       if (h == NULL)
1243         {
1244           if (symndx == -1)
1245             sec = bfd_abs_section_ptr;
1246           else
1247             {
1248               sec = sections[symndx];
1249               val = (sec->output_section->vma
1250                      + sec->output_offset
1251                      + sym->n_value
1252                      - sec->vma);
1253             }
1254         }
1255       else
1256         {
1257           CHECK_EYE(h->eye_catcher);
1258
1259           if (h->root.root.type == bfd_link_hash_defined
1260               || h->root.root.type == bfd_link_hash_defweak)
1261             {
1262               sec = h->root.root.u.def.section;
1263               val = (h->root.root.u.def.value
1264                      + sec->output_section->vma
1265                      + sec->output_offset);
1266             }
1267           else
1268             {
1269               if (! ((*info->callbacks->undefined_symbol)
1270                      (info, h->root.root.root.string, input_bfd, input_section,
1271                       rel->r_vaddr - input_section->vma)))
1272                 return false;
1273             }
1274         }
1275
1276       rstat = bfd_reloc_ok;
1277
1278       /* Each case must do its own relocation, setting rstat appropriately */
1279       switch (r_type)
1280         {
1281         default:
1282           fprintf( stderr,
1283                   "ERROR: during reloc processing -- unsupported reloc %s\n",
1284                   howto->name);
1285           bfd_set_error (bfd_error_bad_value);
1286           abort();
1287           return false;
1288         case IMAGE_REL_PPC_TOCREL16:
1289           {
1290             bfd_vma our_toc_offset;
1291             int fixit;
1292
1293             DUMP_RELOC2(howto->name, rel);
1294
1295             if (toc_section == 0)
1296               {
1297                 toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
1298                                                        TOC_SECTION_NAME);
1299 #ifdef TOC_DEBUG
1300
1301                 fprintf(stderr,
1302                         "BFD of toc owner %p, section addr of %s %p\n",
1303                          bfd_of_toc_owner, TOC_SECTION_NAME, toc_section);
1304 #endif
1305
1306                 if ( toc_section == NULL )
1307                   {
1308                     fprintf(stderr, "No Toc section!\n");
1309                     abort();
1310                   }
1311               }
1312
1313             /*
1314              *  Amazing bit tricks present. As we may have seen earlier, we
1315              *  use the 1 bit to tell us whether or not a toc offset has been
1316              *  allocated. Now that they've all been allocated, we will use
1317              *  the 1 bit to tell us if we've written this particular toc
1318              *  entry out.
1319              */
1320             fixit = false;
1321             if (h == 0)
1322               { /* it is a file local symbol */
1323                 int *local_toc_table;
1324                 const char *name;
1325
1326                 sym = syms + symndx;
1327                 name = sym->_n._n_name;
1328
1329                 local_toc_table = obj_coff_local_toc_table(input_bfd);
1330                 our_toc_offset = local_toc_table[symndx];
1331
1332                 if ((our_toc_offset & 1) != 0)
1333                   {
1334                     /* if it has been written out, it is marked with the
1335                        1 bit. Fix up our offset, but do not write it out
1336                        again.
1337                      */
1338                     our_toc_offset &= ~1;
1339 #ifdef TOC_DEBUG
1340
1341                     fprintf(stderr,
1342                             "Not writing out toc_offset of %d for %s\n", our_toc_offset, name);
1343 #endif
1344                   }
1345                 else
1346                   {
1347                     /* write out the toc entry */
1348                     record_toc(toc_section, our_toc_offset, strdup(name));
1349 #ifdef TOC_DEBUG
1350                     fprintf(stderr,
1351                             "Writing out toc_offset toc_section (%p,%p)+%d val %d for %s\n",
1352                             toc_section,
1353                             toc_section->contents,
1354                             our_toc_offset,
1355                             val,
1356                             name);
1357 #endif
1358
1359                     bfd_put_32(output_bfd,
1360                                val,
1361                                toc_section->contents + our_toc_offset);
1362
1363                     local_toc_table[symndx] |= 1;
1364                     fixit = true;
1365                   }
1366               }
1367             else
1368               {
1369                 const char *name = h->root.root.root.string;
1370                 our_toc_offset = h->toc_offset;
1371
1372                 if ( (r_flags & IMAGE_REL_PPC_TOCDEFN) == IMAGE_REL_PPC_TOCDEFN &&
1373                       our_toc_offset == 1)
1374                   {
1375                     /* This is unbelievable cheese. Some knowledgable asm hacker has decided to
1376                        use r2 as a base for loading a value. He/She does this by setting the
1377                        tocdefn bit, and not supplying a toc definition. The behaviour is then
1378                        to use the value of the symbol as a toc index. Good Grief.
1379                     */
1380                     our_toc_offset = val - (toc_section->output_section->vma + toc_section->output_offset);
1381                   }
1382                 else if ((our_toc_offset & 1) != 0)
1383                   {
1384                     /* if it has been written out, it is marked with the
1385                        1 bit. Fix up our offset, but do not write it out
1386                        again.
1387                      */
1388                     our_toc_offset &= ~1;
1389 #ifdef TOC_DEBUG
1390                     fprintf(stderr,
1391                             "Not writing out toc_offset of %d for %s\n", our_toc_offset, name);
1392 #endif
1393                   }
1394                 else
1395                   {
1396                     record_toc(toc_section, our_toc_offset, strdup(name));
1397
1398 #ifdef TOC_DEBUG
1399                     /* write out the toc entry */
1400                     fprintf(stderr,
1401                             "Writing out toc_offset toc_section (%p,%p)+%d val %d for %s\n",
1402                             toc_section,
1403                             toc_section->contents,
1404                             our_toc_offset,
1405                             val,
1406                             name);
1407 #endif
1408
1409                     /* write out the toc entry */
1410                     bfd_put_32(output_bfd,
1411                                val,
1412                                toc_section->contents + our_toc_offset);
1413
1414                     h->toc_offset |= 1;
1415                     /* The tricky part is that this is the address that */
1416                     /* needs a .reloc entry for it */
1417                     fixit = true;
1418                   }
1419               }
1420
1421             if (fixit && info->base_file)
1422               {
1423                 /* So if this is non pcrelative, and is referenced
1424                    to a section or a common symbol, then it needs a reloc */
1425
1426                 /* relocation to a symbol in a section which
1427                    isn't absolute - we output the address here
1428                    to a file */
1429
1430                 bfd_vma addr =  toc_section->output_section->vma
1431                   + toc_section->output_offset + our_toc_offset;
1432
1433                 fprintf(stderr,
1434                         "  Toc Section reloc candidate\n");
1435
1436                 if (coff_data(output_bfd)->pe)
1437                   addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
1438                 fwrite (&addr, 1,4, (FILE *) info->base_file);
1439               }
1440
1441
1442             /* FIXME: this test is conservative */
1443             if ( (r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN &&
1444                 our_toc_offset > toc_section->_raw_size)
1445               {
1446                 fprintf(stderr,
1447                         "reloc offset is bigger than the toc size!\n");
1448                 abort();
1449               }
1450
1451             /* Now we know the relocation for this toc reference */
1452             relocation =  our_toc_offset + TOC_LOAD_ADJUSTMENT;
1453             rstat = _bfd_relocate_contents (howto,
1454                                             input_bfd,
1455                                             relocation,
1456                                             loc);
1457           }
1458           break;
1459         case IMAGE_REL_PPC_IFGLUE:
1460           {
1461             /* To solve this, we need to know whether or not the symbol */
1462             /* appearing on the call instruction is a glue function or not. */
1463             /* A glue function must announce itself via a IMGLUE reloc, and */
1464             /* the reloc contains the required toc restore instruction */
1465
1466             bfd_vma x;
1467             const char *my_name;
1468             DUMP_RELOC2(howto->name, rel);
1469
1470             if (h != 0)
1471               {
1472                 my_name = h->root.root.root.string;
1473                 if (h->symbol_is_glue == 1)
1474                   {
1475                     x = bfd_get_32(input_bfd, loc);
1476                     bfd_put_32(input_bfd, h->glue_insn, loc);
1477                   }
1478               }
1479           }
1480           break;
1481         case IMAGE_REL_PPC_SECREL:
1482           /* Unimplemented: codeview debugging information */
1483           /* For fast access to the header of the section
1484              containing the item. */
1485           break;
1486         case IMAGE_REL_PPC_SECTION:
1487           /* Unimplemented: codeview debugging information */
1488           /* Is used to indicate that the value should be relative
1489              to the beginning of the section that contains the
1490              symbol */
1491           break;
1492         case IMAGE_REL_PPC_ABSOLUTE:
1493           {
1494             const char *my_name;
1495             if (h == 0)
1496                 my_name = (syms+symndx)->_n._n_name;
1497             else
1498               {
1499                 my_name = h->root.root.root.string;
1500               }
1501
1502             fprintf(stderr,
1503                     "Warning: unsupported reloc %s <file %s, section %s>\n",
1504                     howto->name,
1505                     bfd_get_filename(input_bfd),
1506                     input_section->name);
1507
1508             fprintf(stderr,"sym %d (%s), r_vaddr %d (%x)\n",
1509                     rel->r_symndx, my_name, rel->r_vaddr, rel->r_vaddr);
1510           }
1511           break;
1512         case IMAGE_REL_PPC_IMGLUE:
1513           {
1514             /* There is nothing to do now. This reloc was noted in the first
1515                pass over the relocs, and the glue instruction extracted */
1516             const char *my_name;
1517             if (h->symbol_is_glue == 1)
1518               break;
1519             my_name = h->root.root.root.string;
1520             fprintf(stderr,
1521                     "Warning: previously missed IMGLUE reloc %s <file %s, section %s>\n",
1522                     howto->name,
1523                     bfd_get_filename(input_bfd),
1524                     input_section->name);
1525             break;
1526
1527           }
1528           break;
1529
1530         case IMAGE_REL_PPC_ADDR32NB:
1531           {
1532             struct coff_link_hash_entry *myh = 0;
1533             const char *name = 0;
1534             DUMP_RELOC2(howto->name, rel);
1535             if (h == 0)
1536               { /* it is a file local symbol */
1537                 sym = syms + symndx;
1538                 name = sym->_n._n_name;
1539               }
1540             else
1541               {
1542                 char *target = 0;
1543
1544                 name = h->root.root.root.string;
1545                 if (strcmp(".idata$2", name) == 0)
1546                   target = "__idata2_magic__";
1547                 else if (strcmp(".idata$4", name) == 0)
1548                   target = "__idata4_magic__";
1549                 else if (strcmp(".idata$5", name) == 0)
1550                   target = "__idata5_magic__";
1551                 else
1552                   abort();
1553
1554                 myh = 0;
1555
1556                 myh = coff_link_hash_lookup (coff_hash_table (info),
1557                                              target,
1558                                              false, false, true);
1559                 if (myh == 0)
1560                   {
1561                     fprintf(stderr, "Missing idata magic cookies, this cannot work anyway...\n");
1562                     abort();
1563                   }
1564
1565                 val = myh->root.u.def.value +
1566                   sec->output_section->vma + sec->output_offset;
1567                 if (first_thunk_address == 0)
1568                   {
1569                     int idata5offset;
1570                     myh = coff_link_hash_lookup (coff_hash_table (info),
1571                                                  "__idata5_magic__",
1572                                                  false, false, true);
1573                     first_thunk_address = myh->root.u.def.value +
1574                       sec->output_section->vma +
1575                       sec->output_offset -
1576                         pe_data(output_bfd)->pe_opthdr.ImageBase;
1577
1578                     idata5offset = myh->root.u.def.value;
1579                     myh = coff_link_hash_lookup (coff_hash_table (info),
1580                                                  "__idata6_magic__",
1581                                                  false, false, true);
1582
1583                     thunk_size = myh->root.u.def.value - idata5offset;
1584                     myh = coff_link_hash_lookup (coff_hash_table (info),
1585                                                  "__idata4_magic__",
1586                                                  false, false, true);
1587                     import_table_size = myh->root.u.def.value;
1588                   }
1589               }
1590
1591             rstat = _bfd_relocate_contents (howto,
1592                               input_bfd,
1593                               val -
1594                               pe_data(output_bfd)->pe_opthdr.ImageBase,
1595                               loc);
1596           }
1597           break;
1598
1599         case IMAGE_REL_PPC_REL24:
1600           DUMP_RELOC2(howto->name, rel);
1601           val -= (input_section->output_section->vma
1602                   + input_section->output_offset);
1603
1604           rstat = _bfd_relocate_contents (howto,
1605                                           input_bfd,
1606                                           val,
1607                                           loc);
1608           break;
1609         case IMAGE_REL_PPC_ADDR16:
1610         case IMAGE_REL_PPC_ADDR24:
1611         case IMAGE_REL_PPC_ADDR32:
1612           DUMP_RELOC2(howto->name, rel);
1613           rstat = _bfd_relocate_contents (howto,
1614                                           input_bfd,
1615                                           val,
1616                                           loc);
1617           break;
1618         }
1619
1620       if ( info->base_file )
1621         {
1622           /* So if this is non pcrelative, and is referenced
1623              to a section or a common symbol, then it needs a reloc */
1624           if (sym && pe_data(output_bfd)->in_reloc_p(output_bfd, howto))
1625             {
1626               /* relocation to a symbol in a section which
1627                  isn't absolute - we output the address here
1628                  to a file */
1629               bfd_vma addr = rel->r_vaddr
1630                 - input_section->vma
1631                 + input_section->output_offset
1632                   + input_section->output_section->vma;
1633
1634               if (coff_data(output_bfd)->pe)
1635                 {
1636                   addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
1637                   fprintf(stderr,
1638                           " adjusted down to %d", addr);
1639                 }
1640               fprintf(stderr, "\n");
1641
1642               fwrite (&addr, 1,4, (FILE *) info->base_file);
1643             }
1644         }
1645
1646       switch (rstat)
1647         {
1648         default:
1649           abort ();
1650         case bfd_reloc_ok:
1651           break;
1652         case bfd_reloc_overflow:
1653           {
1654             const char *name;
1655             char buf[SYMNMLEN + 1];
1656
1657             if (symndx == -1)
1658               name = "*ABS*";
1659             else if (h != NULL)
1660               name = h->root.root.root.string;
1661             else if (sym == NULL)
1662               name = "*unknown*";
1663             else if (sym->_n._n_n._n_zeroes == 0
1664                      && sym->_n._n_n._n_offset != 0)
1665               name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1666             else
1667               {
1668                 strncpy (buf, sym->_n._n_name, SYMNMLEN);
1669                 buf[SYMNMLEN] = '\0';
1670                 name = buf;
1671               }
1672 #if 0
1673             else
1674               {
1675                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1676                 if (name == NULL)
1677                   return false;
1678               }
1679 #endif
1680
1681             if (! ((*info->callbacks->reloc_overflow)
1682                    (info, name, howto->name,
1683                     (bfd_vma) 0, input_bfd,
1684                     input_section, rel->r_vaddr - input_section->vma)))
1685               return false;
1686           }
1687         }
1688
1689     }
1690
1691   return true;
1692 }
1693
1694 #ifdef COFF_IMAGE_WITH_PE
1695
1696 long int global_toc_size = 0;
1697
1698 bfd* bfd_of_toc_owner = 0;
1699
1700 long int import_table_size;
1701 long int first_thunk_address;
1702 long int thunk_size;
1703
1704 struct list_ele *head;
1705 struct list_ele *tail;
1706
1707 void
1708 dump_toc(vfile)
1709      void *vfile;
1710 {
1711   FILE *file = vfile;
1712   struct list_ele *t;
1713
1714   fprintf(file,
1715           " Offset Offset   Name if present\n");
1716
1717   for(t = head; t != 0; t=t->next)
1718     {
1719       fprintf(file,
1720               " %2x  %04lx    %s\n",
1721               t->offset - 32768, t->offset, t->name);
1722     }
1723 }
1724
1725 boolean
1726 ppc_allocate_toc_section (info)
1727      struct bfd_link_info *info;
1728 {
1729   asection *s;
1730   bfd_byte *foo;
1731   static char test_char = '1';
1732
1733   if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble? */
1734     return true;
1735
1736   if (bfd_of_toc_owner == 0)
1737     {
1738       fprintf(stderr,
1739               "There is no bfd that owns the toc section!\n");
1740       abort();
1741     }
1742
1743   s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
1744   if (s == NULL)
1745     {
1746       fprintf(stderr, "No Toc section!\n");
1747       abort();
1748     }
1749
1750   foo = bfd_alloc(bfd_of_toc_owner, global_toc_size);
1751   memset(foo, test_char, global_toc_size);
1752
1753   s->_raw_size = s->_cooked_size = global_toc_size;
1754   s->contents = foo;
1755
1756   return true;
1757 }
1758
1759 boolean
1760 ppc_process_before_allocation (abfd, info)
1761      bfd *abfd;
1762      struct bfd_link_info *info;
1763 {
1764   asection *sec;
1765   struct internal_reloc *i, *rel;
1766
1767 #if 0
1768   fprintf(stderr,
1769           "ppc_process_before_allocation: BFD %s\n",
1770           bfd_get_filename(abfd));
1771 #endif
1772
1773   /* here we have a bfd that is to be included on the link. We have a hook
1774      to do reloc rummaging, before section sizes are nailed down. */
1775
1776   _bfd_coff_get_external_symbols(abfd);
1777
1778   /* rummage around all the relocs and map the toc */
1779   sec = abfd->sections;
1780
1781   if (sec == 0)
1782     {
1783       return true;
1784     }
1785
1786   for (; sec != 0; sec = sec->next)
1787   {
1788     int toc_offset;
1789 #ifdef DEBUG_RELOC
1790     fprintf(stderr,
1791             "  section %s reloc count %d\n",
1792             sec->name,
1793             sec->reloc_count);
1794 #endif
1795
1796     if (sec->reloc_count == 0)
1797       continue;
1798
1799     /* load the relocs */
1800     /* FIXME: there may be a storage leak here */
1801     i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
1802
1803     if (i == 0)
1804       abort();
1805
1806     for (rel=i;rel<i+sec->reloc_count;++rel)
1807       {
1808         unsigned short r_type  = EXTRACT_TYPE (rel->r_type);
1809         unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
1810         unsigned short junk    = EXTRACT_JUNK (rel->r_type);
1811
1812 #ifdef DEBUG_RELOC
1813         /* now examine flags */
1814         if (r_flags != 0)
1815           {
1816             fprintf (stderr, "Reloc with flags found!");
1817             if ( r_flags & IMAGE_REL_PPC_NEG )
1818               fprintf (stderr, " NEG");
1819             if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
1820               fprintf (stderr, " BRTAKEN");
1821             if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
1822               fprintf (stderr, " BRNTAKEN");
1823             if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
1824                 fprintf (stderr, " TOCDEFN");
1825             fprintf(stderr, "\n");
1826           }
1827 #endif
1828
1829         DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1830
1831         switch(r_type)
1832           {
1833           case IMAGE_REL_PPC_TOCREL16:
1834             if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
1835               toc_offset = ppc_record_data_in_toc_entry(abfd, info, sec,
1836                                                         rel->r_symndx,
1837                                                         default_toc);
1838             else
1839               toc_offset = ppc_record_toc_entry(abfd, info, sec,
1840                                                 rel->r_symndx, default_toc);
1841             break;
1842           case IMAGE_REL_PPC_IMGLUE:
1843             ppc_mark_symbol_as_glue(abfd, rel->r_symndx, rel);
1844             break;
1845           default:
1846             break;
1847           }
1848       }
1849   }
1850 }
1851
1852 #endif
1853
1854
1855 static bfd_reloc_status_type
1856 ppc_refhi_reloc (abfd,
1857                  reloc_entry,
1858                  symbol,
1859                  data,
1860                  input_section,
1861                  output_bfd,
1862                  error_message)
1863      bfd *abfd;
1864      arelent *reloc_entry;
1865      asymbol *symbol;
1866      PTR data;
1867      asection *input_section;
1868      bfd *output_bfd;
1869      char **error_message;
1870 {
1871   UN_IMPL("REFHI");
1872   DUMP_RELOC("REFHI",reloc_entry);
1873
1874   if (output_bfd == (bfd *) NULL)
1875     return bfd_reloc_continue;
1876
1877   return bfd_reloc_undefined;
1878 }
1879
1880 static bfd_reloc_status_type
1881 ppc_reflo_reloc (abfd,
1882                  reloc_entry,
1883                  symbol,
1884                  data,
1885                  input_section,
1886                  output_bfd,
1887                  error_message)
1888      bfd *abfd;
1889      arelent *reloc_entry;
1890      asymbol *symbol;
1891      PTR data;
1892      asection *input_section;
1893      bfd *output_bfd;
1894      char **error_message;
1895 {
1896   UN_IMPL("REFLO");
1897   DUMP_RELOC("REFLO",reloc_entry);
1898
1899   if (output_bfd == (bfd *) NULL)
1900     return bfd_reloc_continue;
1901
1902   return bfd_reloc_undefined;
1903 }
1904
1905 static bfd_reloc_status_type
1906 ppc_pair_reloc (abfd,
1907                 reloc_entry,
1908                 symbol,
1909                 data,
1910                 input_section,
1911                 output_bfd,
1912                 error_message)
1913      bfd *abfd;
1914      arelent *reloc_entry;
1915      asymbol *symbol;
1916      PTR data;
1917      asection *input_section;
1918      bfd *output_bfd;
1919      char **error_message;
1920 {
1921   UN_IMPL("PAIR");
1922   DUMP_RELOC("PAIR",reloc_entry);
1923
1924   if (output_bfd == (bfd *) NULL)
1925     return bfd_reloc_continue;
1926
1927   return bfd_reloc_undefined;
1928 }
1929
1930 \f
1931 static bfd_reloc_status_type
1932 ppc_toc16_reloc (abfd,
1933                  reloc_entry,
1934                  symbol,
1935                  data,
1936                  input_section,
1937                  output_bfd,
1938                  error_message)
1939      bfd *abfd;
1940      arelent *reloc_entry;
1941      asymbol *symbol;
1942      PTR data;
1943      asection *input_section;
1944      bfd *output_bfd;
1945      char **error_message;
1946 {
1947   UN_IMPL("TOCREL16");
1948   DUMP_RELOC("TOCREL16",reloc_entry);
1949
1950   if (output_bfd == (bfd *) NULL)
1951     {
1952       return bfd_reloc_continue;
1953     }
1954
1955   return bfd_reloc_ok;
1956 }
1957
1958 /* ADDR32NB : 32 bit address relative to the virtual origin.         */
1959 /*            (On the alpha, this is always a linker generated thunk)*/
1960 /*            (i.e. 32bit addr relative to the image base)           */
1961 /*                                                                   */
1962 /*                                                                   */
1963
1964 static bfd_reloc_status_type
1965 ppc_addr32nb_reloc (abfd,
1966                     reloc_entry,
1967                     symbol,
1968                     data,
1969                     input_section,
1970                     output_bfd,
1971                     error_message)
1972      bfd *abfd;
1973      arelent *reloc_entry;
1974      asymbol *symbol;
1975      PTR data;
1976      asection *input_section;
1977      bfd *output_bfd;
1978      char **error_message;
1979 {
1980   UN_IMPL("ADDR32NB");
1981   DUMP_RELOC("ADDR32NB",reloc_entry);
1982
1983   return bfd_reloc_ok;
1984 }
1985
1986 static bfd_reloc_status_type
1987 ppc_secrel_reloc (abfd,
1988                   reloc_entry,
1989                   symbol,
1990                   data,
1991                   input_section,
1992                   output_bfd,
1993                   error_message)
1994      bfd *abfd;
1995      arelent *reloc_entry;
1996      asymbol *symbol;
1997      PTR data;
1998      asection *input_section;
1999      bfd *output_bfd;
2000      char **error_message;
2001 {
2002   UN_IMPL("SECREL");
2003   DUMP_RELOC("SECREL",reloc_entry);
2004
2005   if (output_bfd == (bfd *) NULL)
2006     return bfd_reloc_continue;
2007
2008   return bfd_reloc_ok;
2009 }
2010
2011 static bfd_reloc_status_type
2012 ppc_section_reloc (abfd,
2013                    reloc_entry,
2014                    symbol,
2015                    data,
2016                    input_section,
2017                    output_bfd,
2018                    error_message)
2019      bfd *abfd;
2020      arelent *reloc_entry;
2021      asymbol *symbol;
2022      PTR data;
2023      asection *input_section;
2024      bfd *output_bfd;
2025      char **error_message;
2026 {
2027   UN_IMPL("SECTION");
2028   DUMP_RELOC("SECTION",reloc_entry);
2029
2030   if (output_bfd == (bfd *) NULL)
2031     return bfd_reloc_continue;
2032
2033   return bfd_reloc_ok;
2034 }
2035
2036 static bfd_reloc_status_type
2037 ppc_imglue_reloc (abfd,
2038                   reloc_entry,
2039                   symbol,
2040                   data,
2041                   input_section,
2042                   output_bfd,
2043                   error_message)
2044      bfd *abfd;
2045      arelent *reloc_entry;
2046      asymbol *symbol;
2047      PTR data;
2048      asection *input_section;
2049      bfd *output_bfd;
2050      char **error_message;
2051 {
2052   UN_IMPL("IMGLUE");
2053   DUMP_RELOC("IMGLUE",reloc_entry);
2054
2055   if (output_bfd == (bfd *) NULL)
2056     return bfd_reloc_continue;
2057
2058   return bfd_reloc_ok;
2059 }
2060
2061 \f
2062
2063 #define MAX_RELOC_INDEX  \
2064       (sizeof(ppc_coff_howto_table) / sizeof(ppc_coff_howto_table[0]) - 1)
2065
2066
2067 /* FIXME: There is a possiblity that when we read in a reloc from a file,
2068           that there are some bits encoded in the upper portion of the
2069           type field. Not yet implemented.
2070 */
2071 static void ppc_coff_rtype2howto PARAMS ((arelent *relent,
2072                                           struct internal_reloc *internal));
2073
2074 static void
2075 ppc_coff_rtype2howto (relent, internal)
2076      arelent *relent;
2077      struct internal_reloc *internal;
2078 {
2079
2080   /* We can encode one of three things in the type field, aside from the
2081      type:
2082      1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
2083         value, rather than an addition value
2084      2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
2085         the branch is expected to be taken or not.
2086      3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
2087      For now, we just strip this stuff to find the type, and ignore it other
2088      than that.
2089   */
2090
2091   unsigned short r_type  = EXTRACT_TYPE (internal->r_type);
2092   unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
2093   unsigned short junk    = EXTRACT_JUNK (internal->r_type);
2094
2095   /* the masking process only slices off the bottom byte for r_type. */
2096   if ( r_type > MAX_RELOC_INDEX )
2097     {
2098       fprintf(stderr,
2099               "ppc_coff_rtype2howto: reloc index %d out of range [%d, %d]\n",
2100               internal->r_type, 0, MAX_RELOC_INDEX);
2101       abort();
2102     }
2103
2104   /* check for absolute crap */
2105   if ( junk != 0 )
2106     {
2107       fprintf(stderr,
2108               "ppc_coff_rtype2howto: reloc index %d contains junk %d\n",
2109               internal->r_type, junk);
2110       abort();
2111     }
2112
2113 #ifdef DEBUG_RELOC
2114   /* now examine flags */
2115   if (r_flags != 0)
2116     {
2117       fprintf (stderr, "Reloc with flags found!");
2118       if ( r_flags & IMAGE_REL_PPC_NEG )
2119         fprintf (stderr, " NEG");
2120       if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
2121         fprintf (stderr, " BRTAKEN");
2122       if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
2123         fprintf (stderr, " BRNTAKEN");
2124       if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
2125         fprintf (stderr, " TOCDEFN");
2126       fprintf(stderr, "\n");
2127     }
2128 #endif
2129
2130   switch(r_type)
2131     {
2132     case IMAGE_REL_PPC_ADDR16:
2133     case IMAGE_REL_PPC_REL24:
2134     case IMAGE_REL_PPC_ADDR24:
2135     case IMAGE_REL_PPC_TOCREL16:
2136     case IMAGE_REL_PPC_ADDR32:
2137     case IMAGE_REL_PPC_IFGLUE:
2138     case IMAGE_REL_PPC_ADDR32NB:
2139     case IMAGE_REL_PPC_SECTION:
2140     case IMAGE_REL_PPC_SECREL:
2141       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, internal);
2142       break;
2143     case IMAGE_REL_PPC_IMGLUE:
2144       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, internal);
2145       break;
2146     default:
2147       fprintf(stderr,
2148               "Warning: Unsupported reloc %s [%d] used -- it may not work.\n",
2149               ppc_coff_howto_table[r_type].name,
2150               r_type);
2151       break;
2152     }
2153
2154   relent->howto = ppc_coff_howto_table + r_type;
2155
2156 }
2157
2158 static reloc_howto_type *
2159 coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
2160      bfd *abfd;
2161      asection *sec;
2162      struct internal_reloc *rel;
2163      struct coff_link_hash_entry *h;
2164      struct internal_syment *sym;
2165      bfd_vma *addendp;
2166 {
2167   reloc_howto_type *howto;
2168
2169   /* We can encode one of three things in the type field, aside from the
2170      type:
2171      1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
2172         value, rather than an addition value
2173      2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
2174         the branch is expected to be taken or not.
2175      3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
2176      For now, we just strip this stuff to find the type, and ignore it other
2177      than that.
2178   */
2179
2180   unsigned short r_type  = EXTRACT_TYPE (rel->r_type);
2181   unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
2182   unsigned short junk    = EXTRACT_JUNK (rel->r_type);
2183
2184 fprintf(stderr,
2185         "coff_ppc_rtype_to_howto\n");
2186
2187   /* the masking process only slices off the bottom byte for r_type. */
2188   if ( r_type > MAX_RELOC_INDEX )
2189     {
2190       fprintf(stderr,
2191               "coff_ppc_rtype_to_howto: index %d out of range [%d, %d]\n",
2192               r_type, 0, MAX_RELOC_INDEX);
2193       abort();
2194     }
2195
2196   /* check for absolute crap */
2197   if ( junk != 0 )
2198     {
2199       fprintf(stderr,
2200               "coff_ppc_rtype_to_howto: reloc index %d contains junk %d\n",
2201               rel->r_type, junk);
2202       abort();
2203     }
2204
2205 #ifdef DEBUG_RELOC
2206   /* now examine flags */
2207   if (r_flags != 0)
2208     {
2209       fprintf (stderr, "Reloc with flags found!");
2210       if ( r_flags & IMAGE_REL_PPC_NEG )
2211         fprintf (stderr, " NEG");
2212       if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
2213         fprintf (stderr, " BRTAKEN");
2214       if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
2215         fprintf (stderr, " BRNTAKEN");
2216       if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
2217         fprintf (stderr, " TOCDEFN");
2218       fprintf(stderr, "\n");
2219     }
2220 #endif
2221
2222   switch(r_type)
2223     {
2224     case IMAGE_REL_PPC_ADDR32NB:
2225       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
2226       *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
2227       break;
2228     case IMAGE_REL_PPC_ADDR16:
2229     case IMAGE_REL_PPC_REL24:
2230     case IMAGE_REL_PPC_ADDR24:
2231     case IMAGE_REL_PPC_TOCREL16:
2232     case IMAGE_REL_PPC_ADDR32:
2233     case IMAGE_REL_PPC_IFGLUE:
2234     case IMAGE_REL_PPC_SECTION:
2235     case IMAGE_REL_PPC_SECREL:
2236       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
2237       break;
2238     case IMAGE_REL_PPC_IMGLUE:
2239       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
2240       break;
2241     default:
2242       fprintf(stderr,
2243               "Warning: Unsupported reloc %s [%d] used -- it may not work.\n",
2244               ppc_coff_howto_table[r_type].name,
2245               r_type);
2246       break;
2247     }
2248
2249   howto = ppc_coff_howto_table + r_type;
2250   return howto;
2251 }
2252
2253
2254 /* a cheesy little macro to make the code a little more readable */
2255 #define HOW2MAP(bfd_rtype,ppc_rtype)  \
2256  case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
2257
2258 static reloc_howto_type *ppc_coff_reloc_type_lookup
2259 PARAMS ((bfd *, bfd_reloc_code_real_type));
2260
2261 static reloc_howto_type *
2262 ppc_coff_reloc_type_lookup (abfd, code)
2263      bfd *abfd;
2264      bfd_reloc_code_real_type code;
2265 {
2266
2267 #ifdef DEBUG_RELOC
2268   fprintf(stderr, "ppc_coff_reloc_type_lookup for %s\n",
2269           bfd_get_reloc_code_name(code));
2270 #endif
2271
2272   switch (code)
2273     {
2274       HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
2275       HOW2MAP(BFD_RELOC_16,           IMAGE_REL_PPC_ADDR16);
2276       HOW2MAP(BFD_RELOC_PPC_B26,      IMAGE_REL_PPC_REL24);
2277       HOW2MAP(BFD_RELOC_PPC_BA26,     IMAGE_REL_PPC_ADDR24);
2278       HOW2MAP(BFD_RELOC_PPC_TOC16,    IMAGE_REL_PPC_TOCREL16);
2279       HOW2MAP(BFD_RELOC_32,           IMAGE_REL_PPC_ADDR32);
2280       HOW2MAP(BFD_RELOC_RVA,          IMAGE_REL_PPC_ADDR32NB);
2281     default:
2282       fprintf(stderr,
2283               "\treturning NULL\n");
2284       return NULL;
2285     }
2286
2287   return NULL;
2288 }
2289
2290 #undef HOW2MAP
2291
2292 \f
2293 /* Tailor coffcode.h -- macro heaven. */
2294
2295 #define RTYPE2HOWTO(cache_ptr, dst)  ppc_coff_rtype2howto (cache_ptr, dst)
2296
2297 #ifndef COFF_IMAGE_WITH_PE
2298 static void
2299 ppc_coff_swap_sym_in_hook ();
2300 #endif
2301
2302 /* We use the special COFF backend linker, with our own special touch.  */
2303
2304 #define coff_bfd_reloc_type_lookup   ppc_coff_reloc_type_lookup
2305 #define coff_rtype_to_howto          coff_ppc_rtype_to_howto
2306 #define coff_relocate_section        coff_ppc_relocate_section
2307
2308 #ifndef COFF_IMAGE_WITH_PE
2309 #define coff_swap_sym_in_hook        ppc_coff_swap_sym_in_hook
2310 #endif
2311
2312 #define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
2313
2314 #define COFF_PAGE_SIZE                       0x1000
2315
2316 #define POWERPC_LE_PE
2317
2318 #include "coffcode.h"
2319
2320 \f
2321
2322 #ifndef COFF_IMAGE_WITH_PE
2323 static void
2324 ppc_coff_swap_sym_in_hook (abfd, ext1, in1)
2325      bfd            *abfd;
2326      PTR ext1;
2327      PTR in1;
2328 {
2329   SYMENT *ext = (SYMENT *)ext1;
2330   struct internal_syment      *in = (struct internal_syment *)in1;
2331
2332 #if 0
2333   if (bfd_of_toc_owner != 0) /* we already have a toc, so go home */
2334     return;
2335 #endif
2336
2337   if (strcmp(in->_n._n_name, ".toc") == 0)
2338     {
2339       flagword flags;
2340       register asection *s;
2341       char *foo;
2342
2343       s = bfd_get_section_by_name ( abfd , TOC_SECTION_NAME);
2344       if (s != NULL)
2345         {
2346           return;
2347         }
2348
2349       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY ;
2350
2351 #ifdef TOC_DEBUG
2352       fprintf(stderr,
2353               "ppc_coff_swap_sym_in_hook: about to create the %s section\n",
2354               TOC_SECTION_NAME);
2355 #endif
2356
2357       s = bfd_make_section (abfd, TOC_SECTION_NAME);
2358
2359       if (s == NULL
2360           || !bfd_set_section_flags (abfd, s, flags)
2361           || !bfd_set_section_alignment (abfd, s, 2))
2362         {
2363           fprintf(stderr,
2364                   "toc section allocation failed!\n");
2365           abort();
2366         }
2367
2368       /* save the bfd for later allocation */
2369       bfd_of_toc_owner = abfd;
2370     }
2371
2372   return;
2373 }
2374 #endif
2375
2376 \f
2377
2378 /* The transfer vectors that lead the outside world to all of the above. */
2379
2380 #ifdef TARGET_LITTLE_SYM
2381 const bfd_target
2382 TARGET_LITTLE_SYM =
2383 {
2384   TARGET_LITTLE_NAME,           /* name or coff-arm-little */
2385   bfd_target_coff_flavour,
2386   false,                        /* data byte order is little */
2387   false,                        /* header byte order is little */
2388
2389   (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
2390    HAS_LINENO | HAS_DEBUG |
2391    HAS_SYMS | HAS_LOCALS | WP_TEXT),
2392
2393   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2394   0,                            /* leading char */
2395   '/',                          /* ar_pad_char */
2396   15,                           /* ar_max_namelen??? FIXMEmgo */
2397
2398   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2399   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2400   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2401
2402   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2403   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2404   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2405
2406   {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
2407      bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2408   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2409      bfd_false},
2410   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
2411      _bfd_write_archive_contents, bfd_false},
2412
2413   BFD_JUMP_TABLE_GENERIC (coff),
2414   BFD_JUMP_TABLE_COPY (coff),
2415   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2416   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2417   BFD_JUMP_TABLE_SYMBOLS (coff),
2418   BFD_JUMP_TABLE_RELOCS (coff),
2419   BFD_JUMP_TABLE_WRITE (coff),
2420   BFD_JUMP_TABLE_LINK (coff),
2421   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2422
2423   COFF_SWAP_TABLE,
2424 };
2425 #endif
2426
2427 #ifdef TARGET_BIG_SYM
2428 const bfd_target
2429 TARGET_BIG_SYM =
2430 {
2431   TARGET_BIG_NAME,
2432   bfd_target_coff_flavour,
2433   true,                         /* data byte order is big */
2434   true,                         /* header byte order is big */
2435
2436   (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
2437    HAS_LINENO | HAS_DEBUG |
2438    HAS_SYMS | HAS_LOCALS | WP_TEXT),
2439
2440   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2441   0,                            /* leading char */
2442   '/',                          /* ar_pad_char */
2443   15,                           /* ar_max_namelen??? FIXMEmgo */
2444
2445   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2446   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2447   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
2448
2449   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2450   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2451   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2452
2453   {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
2454      bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2455   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2456      bfd_false},
2457   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
2458      _bfd_write_archive_contents, bfd_false},
2459
2460   BFD_JUMP_TABLE_GENERIC (coff),
2461   BFD_JUMP_TABLE_COPY (coff),
2462   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2463   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2464   BFD_JUMP_TABLE_SYMBOLS (coff),
2465   BFD_JUMP_TABLE_RELOCS (coff),
2466   BFD_JUMP_TABLE_WRITE (coff),
2467   BFD_JUMP_TABLE_LINK (coff),
2468   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2469
2470   COFF_SWAP_TABLE,
2471 };
2472
2473 #endif