bfd/coff-ppc.c

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