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