contrib/binutils/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 2 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, 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 /* The reloc processing routine for the optimized COFF linker.  */
 986
 987 static bfd_boolean
 988 coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
 989                            contents, relocs, syms, sections)
 990      bfd *output_bfd;
 991      struct bfd_link_info *info;
 992      bfd *input_bfd;
 993      asection *input_section;
 994      bfd_byte *contents;
 995      struct internal_reloc *relocs;
 996      struct internal_syment *syms;
 997      asection **sections;
 998 {
 999   struct internal_reloc *rel;
1000   struct internal_reloc *relend;
1001   bfd_boolean hihalf;
1002   bfd_vma hihalf_val;
1003   asection *toc_section = 0;
1004   bfd_vma relocation;
1005   reloc_howto_type *howto = 0;
1006
1007   /* If we are performing a relocatable link, we don't need to do a
1008      thing.  The caller will take care of adjusting the reloc
1009      addresses and symbol indices.  */
1010   if (info->relocatable)
1011     return TRUE;
1012
1013   hihalf = FALSE;
1014   hihalf_val = 0;
1015
1016   rel = relocs;
1017   relend = rel + input_section->reloc_count;
1018   for (; rel < relend; rel++)
1019     {
1020       long symndx;
1021       struct ppc_coff_link_hash_entry *h;
1022       struct internal_syment *sym;
1023       bfd_vma val;
1024
1025       asection *sec;
1026       bfd_reloc_status_type rstat;
1027       bfd_byte *loc;
1028
1029       unsigned short r_type  = EXTRACT_TYPE (rel->r_type);
1030       unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
1031
1032       symndx = rel->r_symndx;
1033       loc = contents + rel->r_vaddr - input_section->vma;
1034
1035       /* FIXME: check bounds on r_type */
1036       howto = ppc_coff_howto_table + r_type;
1037
1038       if (symndx == -1)
1039         {
1040           h = NULL;
1041           sym = NULL;
1042         }
1043       else
1044         {
1045           h = (struct ppc_coff_link_hash_entry *)
1046             (obj_coff_sym_hashes (input_bfd)[symndx]);
1047           if (h != 0)
1048             {
1049               HASH_CHECK(h);
1050             }
1051
1052           sym = syms + symndx;
1053         }
1054
1055       if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
1056         {
1057           /* An IMGLUE reloc must have a name. Something is very wrong.  */
1058           abort ();
1059         }
1060
1061       sec = NULL;
1062       val = 0;
1063
1064       /* FIXME: PAIR unsupported in the following code.  */
1065       if (h == NULL)
1066         {
1067           if (symndx == -1)
1068             sec = bfd_abs_section_ptr;
1069           else
1070             {
1071               sec = sections[symndx];
1072               val = (sec->output_section->vma
1073                      + sec->output_offset
1074                      + sym->n_value);
1075               if (! obj_pe (output_bfd))
1076                 val -= sec->vma;
1077             }
1078         }
1079       else
1080         {
1081           HASH_CHECK(h);
1082
1083           if (h->root.root.type == bfd_link_hash_defined
1084               || h->root.root.type == bfd_link_hash_defweak)
1085             {
1086               sec = h->root.root.u.def.section;
1087               val = (h->root.root.u.def.value
1088                      + sec->output_section->vma
1089                      + sec->output_offset);
1090             }
1091           else
1092             {
1093               if (! ((*info->callbacks->undefined_symbol)
1094                      (info, h->root.root.root.string, input_bfd, input_section,
1095                       rel->r_vaddr - input_section->vma, TRUE)))
1096                 return FALSE;
1097             }
1098         }
1099
1100       rstat = bfd_reloc_ok;
1101
1102       /* Each case must do its own relocation, setting rstat appropriately.  */
1103       switch (r_type)
1104         {
1105         default:
1106           (*_bfd_error_handler)
1107             (_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
1108           bfd_set_error (bfd_error_bad_value);
1109           return FALSE;
1110         case IMAGE_REL_PPC_TOCREL16:
1111           {
1112             bfd_signed_vma our_toc_offset;
1113             int fixit;
1114
1115             DUMP_RELOC2(howto->name, rel);
1116
1117             if (toc_section == 0)
1118               {
1119                 toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
1120                                                        TOC_SECTION_NAME);
1121
1122                 if ( toc_section == NULL )
1123                   {
1124                     /* There is no toc section. Something is very wrong.  */
1125                     abort ();
1126                   }
1127               }
1128
1129             /* Amazing bit tricks present. As we may have seen earlier, we
1130                use the 1 bit to tell us whether or not a toc offset has been
1131                allocated. Now that they've all been allocated, we will use
1132                the 1 bit to tell us if we've written this particular toc
1133                entry out.  */
1134             fixit = FALSE;
1135             if (h == 0)
1136               {
1137                 /* It is a file local symbol.  */
1138                 int *local_toc_table;
1139                 const char *name;
1140
1141                 sym = syms + symndx;
1142                 name = sym->_n._n_name;
1143
1144                 local_toc_table = obj_coff_local_toc_table(input_bfd);
1145                 our_toc_offset = local_toc_table[symndx];
1146
1147                 if (IS_WRITTEN(our_toc_offset))
1148                   {
1149                     /* If it has been written out, it is marked with the
1150                        1 bit. Fix up our offset, but do not write it out
1151                        again.  */
1152                     MAKE_ADDR_AGAIN(our_toc_offset);
1153                   }
1154                 else
1155                   {
1156                     /* Write out the toc entry.  */
1157                     record_toc (toc_section, our_toc_offset, priv,
1158                                 strdup (name));
1159
1160                     bfd_put_32 (output_bfd, val,
1161                                toc_section->contents + our_toc_offset);
1162
1163                     MARK_AS_WRITTEN(local_toc_table[symndx]);
1164                     fixit = TRUE;
1165                   }
1166               }
1167             else
1168               {
1169                 const char *name = h->root.root.root.string;
1170                 our_toc_offset = h->toc_offset;
1171
1172                 if ((r_flags & IMAGE_REL_PPC_TOCDEFN)
1173                     == IMAGE_REL_PPC_TOCDEFN )
1174                   {
1175                     /* This is unbelievable cheese. Some knowledgable asm
1176                        hacker has decided to use r2 as a base for loading
1177                        a value. He/She does this by setting the tocdefn bit,
1178                        and not supplying a toc definition. The behaviour is
1179                        then to use the difference between the value of the
1180                        symbol and the actual location of the toc as the toc
1181                        index.
1182
1183                        In fact, what is usually happening is, because the
1184                        Import Address Table is mapped immediately following
1185                        the toc, some trippy library code trying for speed on
1186                        dll linkage, takes advantage of that and considers
1187                        the IAT to be part of the toc, thus saving a load.  */
1188
1189                     our_toc_offset = val - (toc_section->output_section->vma
1190                                             + toc_section->output_offset);
1191
1192                     /* The size must still fit in a 16-bit displacement.  */
1193                     if ((bfd_vma) our_toc_offset >= 65535)
1194                       {
1195                         (*_bfd_error_handler)
1196                           (_("%B: Relocation for %s of %lx exceeds Toc size limit"),
1197                            input_bfd, name,
1198                            (unsigned long) our_toc_offset);
1199                         bfd_set_error (bfd_error_bad_value);
1200                         return FALSE;
1201                       }
1202
1203                     record_toc (toc_section, our_toc_offset, pub,
1204                                 strdup (name));
1205                   }
1206                 else if (IS_WRITTEN (our_toc_offset))
1207                   {
1208                     /* If it has been written out, it is marked with the
1209                        1 bit. Fix up our offset, but do not write it out
1210                        again.  */
1211                     MAKE_ADDR_AGAIN(our_toc_offset);
1212                   }
1213                 else
1214                   {
1215                     record_toc(toc_section, our_toc_offset, pub,
1216                                strdup (name));
1217
1218                     /* Write out the toc entry.  */
1219                     bfd_put_32 (output_bfd, val,
1220                                toc_section->contents + our_toc_offset);
1221
1222                     MARK_AS_WRITTEN(h->toc_offset);
1223                     /* The tricky part is that this is the address that
1224                        needs a .reloc entry for it.  */
1225                     fixit = TRUE;
1226                   }
1227               }
1228
1229             if (fixit && info->base_file)
1230               {
1231                 /* So if this is non pcrelative, and is referenced
1232                    to a section or a common symbol, then it needs a reloc.  */
1233
1234                 /* Relocation to a symbol in a section which
1235                    isn't absolute - we output the address here
1236                    to a file.  */
1237                 bfd_vma addr = (toc_section->output_section->vma
1238                                 + toc_section->output_offset + our_toc_offset);
1239
1240                 if (coff_data (output_bfd)->pe)
1241                   addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
1242
1243                 fwrite (&addr, 1,4, (FILE *) info->base_file);
1244               }
1245
1246             /* FIXME: this test is conservative.  */
1247             if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN
1248                 && (bfd_vma) our_toc_offset > toc_section->size)
1249               {
1250                 (*_bfd_error_handler)
1251                   (_("%B: Relocation exceeds allocated TOC (%lx)"),
1252                    input_bfd, (unsigned long) toc_section->size);
1253                 bfd_set_error (bfd_error_bad_value);
1254                 return FALSE;
1255               }
1256
1257             /* Now we know the relocation for this toc reference.  */
1258             relocation =  our_toc_offset + TOC_LOAD_ADJUSTMENT;
1259             rstat = _bfd_relocate_contents (howto, input_bfd, relocation, loc);
1260           }
1261           break;
1262         case IMAGE_REL_PPC_IFGLUE:
1263           {
1264             /* To solve this, we need to know whether or not the symbol
1265                appearing on the call instruction is a glue function or not.
1266                A glue function must announce itself via a IMGLUE reloc, and
1267                the reloc contains the required toc restore instruction.  */
1268             bfd_vma x;
1269             const char *my_name;
1270
1271             DUMP_RELOC2 (howto->name, rel);
1272
1273             if (h != 0)
1274               {
1275                 my_name = h->root.root.root.string;
1276                 if (h->symbol_is_glue == 1)
1277                   {
1278                     x = bfd_get_32 (input_bfd, loc);
1279                     bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
1280                   }
1281               }
1282           }
1283           break;
1284         case IMAGE_REL_PPC_SECREL:
1285           /* Unimplemented: codeview debugging information.  */
1286           /* For fast access to the header of the section
1287              containing the item.  */
1288           break;
1289         case IMAGE_REL_PPC_SECTION:
1290           /* Unimplemented: codeview debugging information.  */
1291           /* Is used to indicate that the value should be relative
1292              to the beginning of the section that contains the
1293              symbol.  */
1294           break;
1295         case IMAGE_REL_PPC_ABSOLUTE:
1296           {
1297             const char *my_name;
1298
1299             if (h == 0)
1300               my_name = (syms+symndx)->_n._n_name;
1301             else
1302               my_name = h->root.root.root.string;
1303
1304             (*_bfd_error_handler)
1305               (_("Warning: unsupported reloc %s <file %B, section %A>\n"
1306                  "sym %ld (%s), r_vaddr %ld (%lx)"),
1307                input_bfd, input_section, howto->name,
1308                rel->r_symndx, my_name, (long) rel->r_vaddr,
1309                (unsigned long) rel->r_vaddr);
1310           }
1311           break;
1312         case IMAGE_REL_PPC_IMGLUE:
1313           {
1314             /* There is nothing to do now. This reloc was noted in the first
1315                pass over the relocs, and the glue instruction extracted.  */
1316             const char *my_name;
1317
1318             if (h->symbol_is_glue == 1)
1319               break;
1320             my_name = h->root.root.root.string;
1321
1322             (*_bfd_error_handler)
1323               (_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
1324             bfd_set_error (bfd_error_bad_value);
1325             return FALSE;
1326           }
1327
1328         case IMAGE_REL_PPC_ADDR32NB:
1329           {
1330             const char *name = 0;
1331
1332             DUMP_RELOC2 (howto->name, rel);
1333
1334             if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0)
1335               {
1336                 /* Set magic values.  */
1337                 int idata5offset;
1338                 struct coff_link_hash_entry *myh;
1339
1340                 myh = coff_link_hash_lookup (coff_hash_table (info),
1341                                              "__idata5_magic__",
1342                                              FALSE, FALSE, TRUE);
1343                 first_thunk_address = myh->root.u.def.value +
1344                   sec->output_section->vma +
1345                     sec->output_offset -
1346                       pe_data(output_bfd)->pe_opthdr.ImageBase;
1347
1348                 idata5offset = myh->root.u.def.value;
1349                 myh = coff_link_hash_lookup (coff_hash_table (info),
1350                                              "__idata6_magic__",
1351                                              FALSE, FALSE, TRUE);
1352
1353                 thunk_size = myh->root.u.def.value - idata5offset;
1354                 myh = coff_link_hash_lookup (coff_hash_table (info),
1355                                              "__idata4_magic__",
1356                                              FALSE, FALSE, TRUE);
1357                 import_table_size = myh->root.u.def.value;
1358               }
1359
1360             if (h == 0)
1361               {
1362                 /* It is a file local symbol.  */
1363                 sym = syms + symndx;
1364                 name = sym->_n._n_name;
1365               }
1366             else
1367               {
1368                 char *target = 0;
1369
1370                 name = h->root.root.root.string;
1371                 if (strcmp (".idata$2", name) == 0)
1372                   target = "__idata2_magic__";
1373                 else if (strcmp (".idata$4", name) == 0)
1374                   target = "__idata4_magic__";
1375                 else if (strcmp (".idata$5", name) == 0)
1376                   target = "__idata5_magic__";
1377
1378                 if (target != 0)
1379                   {
1380                     struct coff_link_hash_entry *myh;
1381
1382                     myh = coff_link_hash_lookup (coff_hash_table (info),
1383                                                  target,
1384                                                  FALSE, FALSE, TRUE);
1385                     if (myh == 0)
1386                       {
1387                         /* Missing magic cookies. Something is very wrong.  */
1388                         abort ();
1389                       }
1390
1391                     val = myh->root.u.def.value +
1392                       sec->output_section->vma + sec->output_offset;
1393                     if (first_thunk_address == 0)
1394                       {
1395                         int idata5offset;
1396                         myh = coff_link_hash_lookup (coff_hash_table (info),
1397                                                      "__idata5_magic__",
1398                                                      FALSE, FALSE, TRUE);
1399                         first_thunk_address = myh->root.u.def.value +
1400                           sec->output_section->vma +
1401                             sec->output_offset -
1402                               pe_data(output_bfd)->pe_opthdr.ImageBase;
1403
1404                         idata5offset = myh->root.u.def.value;
1405                         myh = coff_link_hash_lookup (coff_hash_table (info),
1406                                                      "__idata6_magic__",
1407                                                      FALSE, FALSE, TRUE);
1408
1409                         thunk_size = myh->root.u.def.value - idata5offset;
1410                         myh = coff_link_hash_lookup (coff_hash_table (info),
1411                                                      "__idata4_magic__",
1412                                                      FALSE, FALSE, TRUE);
1413                         import_table_size = myh->root.u.def.value;
1414                       }
1415                   }
1416               }
1417
1418             rstat = _bfd_relocate_contents (howto,
1419                                             input_bfd,
1420                                             val -
1421                                             pe_data (output_bfd)->pe_opthdr.ImageBase,
1422                                             loc);
1423           }
1424           break;
1425
1426         case IMAGE_REL_PPC_REL24:
1427           DUMP_RELOC2(howto->name, rel);
1428           val -= (input_section->output_section->vma
1429                   + input_section->output_offset);
1430
1431           rstat = _bfd_relocate_contents (howto,
1432                                           input_bfd,
1433                                           val,
1434                                           loc);
1435           break;
1436         case IMAGE_REL_PPC_ADDR16:
1437         case IMAGE_REL_PPC_ADDR24:
1438         case IMAGE_REL_PPC_ADDR32:
1439           DUMP_RELOC2(howto->name, rel);
1440           rstat = _bfd_relocate_contents (howto,
1441                                           input_bfd,
1442                                           val,
1443                                           loc);
1444           break;
1445         }
1446
1447       if (info->base_file)
1448         {
1449           /* So if this is non pcrelative, and is referenced
1450              to a section or a common symbol, then it needs a reloc.  */
1451           if (sym && pe_data(output_bfd)->in_reloc_p (output_bfd, howto))
1452             {
1453               /* Relocation to a symbol in a section which
1454                  isn't absolute - we output the address here
1455                  to a file.  */
1456               bfd_vma addr = rel->r_vaddr
1457                 - input_section->vma
1458                 + input_section->output_offset
1459                   + input_section->output_section->vma;
1460
1461               if (coff_data (output_bfd)->pe)
1462                 addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
1463
1464               fwrite (&addr, 1,4, (FILE *) info->base_file);
1465             }
1466         }
1467
1468       switch (rstat)
1469         {
1470         default:
1471           abort ();
1472         case bfd_reloc_ok:
1473           break;
1474         case bfd_reloc_overflow:
1475           {
1476             const char *name;
1477             char buf[SYMNMLEN + 1];
1478
1479             if (symndx == -1)
1480               name = "*ABS*";
1481             else if (h != NULL)
1482               name = NULL;
1483             else if (sym == NULL)
1484               name = "*unknown*";
1485             else if (sym->_n._n_n._n_zeroes == 0
1486                      && sym->_n._n_n._n_offset != 0)
1487               name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1488             else
1489               {
1490                 strncpy (buf, sym->_n._n_name, SYMNMLEN);
1491                 buf[SYMNMLEN] = '\0';
1492                 name = buf;
1493               }
1494
1495             if (! ((*info->callbacks->reloc_overflow)
1496                    (info, (h ? &h->root.root : NULL), name, howto->name,
1497                     (bfd_vma) 0, input_bfd,
1498                     input_section, rel->r_vaddr - input_section->vma)))
1499               return FALSE;
1500           }
1501         }
1502     }
1503
1504   return TRUE;
1505 }
1506
1507 #ifdef COFF_IMAGE_WITH_PE
1508
1509 /* FIXME: BFD should not use global variables.  This file is compiled
1510    twice, and these variables are shared.  This is confusing and
1511    weird.  */
1512
1513 long int global_toc_size = 4;
1514
1515 bfd* bfd_of_toc_owner = 0;
1516
1517 long int import_table_size;
1518 long int first_thunk_address;
1519 long int thunk_size;
1520
1521 struct list_ele *head;
1522 struct list_ele *tail;
1523
1524 static char *
1525 h1 = N_("\n\t\t\tTOC MAPPING\n\n");
1526 static char *
1527 h2 = N_(" TOC    disassembly  Comments       Name\n");
1528 static char *
1529 h3 = N_(" Offset  spelling                   (if present)\n");
1530
1531 void
1532 dump_toc (vfile)
1533      PTR vfile;
1534 {
1535   FILE *file = (FILE *) vfile;
1536   struct list_ele *t;
1537
1538   fprintf (file, _(h1));
1539   fprintf (file, _(h2));
1540   fprintf (file, _(h3));
1541
1542   for (t = head; t != 0; t=t->next)
1543     {
1544       const char *cat = "";
1545
1546       if (t->cat == priv)
1547         cat = _("private       ");
1548       else if (t->cat == pub)
1549         cat = _("public        ");
1550       else if (t->cat == tocdata)
1551         cat = _("data-in-toc   ");
1552
1553       if (t->offset > global_toc_size)
1554         {
1555           if (t->offset <= global_toc_size + thunk_size)
1556             cat = _("IAT reference ");
1557           else
1558             {
1559               fprintf (file,
1560                       _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
1561                        global_toc_size, global_toc_size,
1562                        thunk_size, thunk_size);
1563               cat = _("Out of bounds!");
1564             }
1565         }
1566
1567       fprintf (file,
1568               " %04lx    (%d)", (unsigned long) t->offset, t->offset - 32768);
1569       fprintf (file,
1570               "    %s %s\n",
1571               cat, t->name);
1572
1573     }
1574
1575   fprintf (file, "\n");
1576 }
1577
1578 bfd_boolean
1579 ppc_allocate_toc_section (info)
1580      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1581 {
1582   asection *s;
1583   bfd_byte *foo;
1584   bfd_size_type amt;
1585   static char test_char = '1';
1586
1587   if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble?  */
1588     return TRUE;
1589
1590   if (bfd_of_toc_owner == 0)
1591     /* No toc owner? Something is very wrong.  */
1592     abort ();
1593
1594   s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
1595   if (s == NULL)
1596     /* No toc section? Something is very wrong.  */
1597     abort ();
1598
1599   amt = global_toc_size;
1600   foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt);
1601   memset(foo, test_char, (size_t) global_toc_size);
1602
1603   s->size = global_toc_size;
1604   s->contents = foo;
1605
1606   return TRUE;
1607 }
1608
1609 bfd_boolean
1610 ppc_process_before_allocation (abfd, info)
1611      bfd *abfd;
1612      struct bfd_link_info *info;
1613 {
1614   asection *sec;
1615   struct internal_reloc *i, *rel;
1616
1617   /* Here we have a bfd that is to be included on the link. We have a hook
1618      to do reloc rummaging, before section sizes are nailed down.  */
1619   _bfd_coff_get_external_symbols (abfd);
1620
1621   /* Rummage around all the relocs and map the toc.  */
1622   sec = abfd->sections;
1623
1624   if (sec == 0)
1625     return TRUE;
1626
1627   for (; sec != 0; sec = sec->next)
1628     {
1629       if (sec->reloc_count == 0)
1630         continue;
1631
1632       /* load the relocs */
1633       /* FIXME: there may be a storage leak here */
1634       i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
1635
1636       if (i == 0)
1637         abort ();
1638
1639       for (rel = i; rel < i + sec->reloc_count; ++rel)
1640         {
1641           unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
1642           unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1643           bfd_boolean ok = TRUE;
1644
1645           DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, rel);
1646
1647           switch(r_type)
1648             {
1649             case IMAGE_REL_PPC_TOCREL16:
1650               /* If TOCDEFN is on, ignore as someone else has allocated the
1651                  toc entry.  */
1652               if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN)
1653                 ok = ppc_record_toc_entry(abfd, info, sec,
1654                                           rel->r_symndx, default_toc);
1655               if (!ok)
1656                 return FALSE;
1657               break;
1658             case IMAGE_REL_PPC_IMGLUE:
1659               ppc_mark_symbol_as_glue (abfd, rel->r_symndx, rel);
1660               break;
1661             default:
1662               break;
1663             }
1664         }
1665     }
1666
1667   return TRUE;
1668 }
1669
1670 #endif
1671
1672 static bfd_reloc_status_type
1673 ppc_refhi_reloc (abfd, reloc_entry, symbol, data,
1674                  input_section, output_bfd, error_message)
1675      bfd *abfd ATTRIBUTE_UNUSED;
1676      arelent *reloc_entry ATTRIBUTE_UNUSED;
1677      asymbol *symbol ATTRIBUTE_UNUSED;
1678      PTR data ATTRIBUTE_UNUSED;
1679      asection *input_section ATTRIBUTE_UNUSED;
1680      bfd *output_bfd;
1681      char **error_message ATTRIBUTE_UNUSED;
1682 {
1683   UN_IMPL("REFHI");
1684   DUMP_RELOC("REFHI",reloc_entry);
1685
1686   if (output_bfd == (bfd *) NULL)
1687     return bfd_reloc_continue;
1688
1689   return bfd_reloc_undefined;
1690 }
1691
1692 static bfd_reloc_status_type
1693 ppc_pair_reloc (abfd, reloc_entry, symbol, data,
1694                 input_section, output_bfd, error_message)
1695      bfd *abfd ATTRIBUTE_UNUSED;
1696      arelent *reloc_entry ATTRIBUTE_UNUSED;
1697      asymbol *symbol ATTRIBUTE_UNUSED;
1698      PTR data ATTRIBUTE_UNUSED;
1699      asection *input_section ATTRIBUTE_UNUSED;
1700      bfd *output_bfd;
1701      char **error_message ATTRIBUTE_UNUSED;
1702 {
1703   UN_IMPL("PAIR");
1704   DUMP_RELOC("PAIR",reloc_entry);
1705
1706   if (output_bfd == (bfd *) NULL)
1707     return bfd_reloc_continue;
1708
1709   return bfd_reloc_undefined;
1710 }
1711 \f
1712 static bfd_reloc_status_type
1713 ppc_toc16_reloc (abfd, reloc_entry, symbol, data,
1714                  input_section, output_bfd, error_message)
1715      bfd *abfd ATTRIBUTE_UNUSED;
1716      arelent *reloc_entry ATTRIBUTE_UNUSED;
1717      asymbol *symbol ATTRIBUTE_UNUSED;
1718      PTR data ATTRIBUTE_UNUSED;
1719      asection *input_section ATTRIBUTE_UNUSED;
1720      bfd *output_bfd;
1721      char **error_message ATTRIBUTE_UNUSED;
1722 {
1723   UN_IMPL ("TOCREL16");
1724   DUMP_RELOC ("TOCREL16",reloc_entry);
1725
1726   if (output_bfd == (bfd *) NULL)
1727     return bfd_reloc_continue;
1728
1729   return bfd_reloc_ok;
1730 }
1731
1732 static bfd_reloc_status_type
1733 ppc_secrel_reloc (abfd, reloc_entry, symbol, data,
1734                   input_section, output_bfd, error_message)
1735      bfd *abfd ATTRIBUTE_UNUSED;
1736      arelent *reloc_entry ATTRIBUTE_UNUSED;
1737      asymbol *symbol ATTRIBUTE_UNUSED;
1738      PTR data ATTRIBUTE_UNUSED;
1739      asection *input_section ATTRIBUTE_UNUSED;
1740      bfd *output_bfd;
1741      char **error_message ATTRIBUTE_UNUSED;
1742 {
1743   UN_IMPL("SECREL");
1744   DUMP_RELOC("SECREL",reloc_entry);
1745
1746   if (output_bfd == (bfd *) NULL)
1747     return bfd_reloc_continue;
1748
1749   return bfd_reloc_ok;
1750 }
1751
1752 static bfd_reloc_status_type
1753 ppc_section_reloc (abfd, reloc_entry, symbol, data,
1754                    input_section, output_bfd, error_message)
1755      bfd *abfd ATTRIBUTE_UNUSED;
1756      arelent *reloc_entry ATTRIBUTE_UNUSED;
1757      asymbol *symbol ATTRIBUTE_UNUSED;
1758      PTR data ATTRIBUTE_UNUSED;
1759      asection *input_section ATTRIBUTE_UNUSED;
1760      bfd *output_bfd;
1761      char **error_message ATTRIBUTE_UNUSED;
1762 {
1763   UN_IMPL("SECTION");
1764   DUMP_RELOC("SECTION",reloc_entry);
1765
1766   if (output_bfd == (bfd *) NULL)
1767     return bfd_reloc_continue;
1768
1769   return bfd_reloc_ok;
1770 }
1771
1772 static bfd_reloc_status_type
1773 ppc_imglue_reloc (abfd, reloc_entry, symbol, data,
1774                   input_section, output_bfd, error_message)
1775      bfd *abfd ATTRIBUTE_UNUSED;
1776      arelent *reloc_entry ATTRIBUTE_UNUSED;
1777      asymbol *symbol ATTRIBUTE_UNUSED;
1778      PTR data ATTRIBUTE_UNUSED;
1779      asection *input_section ATTRIBUTE_UNUSED;
1780      bfd *output_bfd;
1781      char **error_message ATTRIBUTE_UNUSED;
1782 {
1783   UN_IMPL("IMGLUE");
1784   DUMP_RELOC("IMGLUE",reloc_entry);
1785
1786   if (output_bfd == (bfd *) NULL)
1787     return bfd_reloc_continue;
1788
1789   return bfd_reloc_ok;
1790 }
1791 \f
1792 #define MAX_RELOC_INDEX  \
1793       (sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1)
1794
1795 /* FIXME: There is a possibility that when we read in a reloc from a file,
1796           that there are some bits encoded in the upper portion of the
1797           type field. Not yet implemented.  */
1798 static void ppc_coff_rtype2howto PARAMS ((arelent *, struct internal_reloc *));
1799
1800 static void
1801 ppc_coff_rtype2howto (relent, internal)
1802      arelent *relent;
1803      struct internal_reloc *internal;
1804 {
1805   /* We can encode one of three things in the type field, aside from the
1806      type:
1807      1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1808         value, rather than an addition value
1809      2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1810         the branch is expected to be taken or not.
1811      3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1812      For now, we just strip this stuff to find the type, and ignore it other
1813      than that.  */
1814   reloc_howto_type *howto;
1815   unsigned short r_type  = EXTRACT_TYPE (internal->r_type);
1816   unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
1817   unsigned short junk    = EXTRACT_JUNK (internal->r_type);
1818
1819   /* The masking process only slices off the bottom byte for r_type.  */
1820   if ( r_type > MAX_RELOC_INDEX )
1821     abort ();
1822
1823   /* Check for absolute crap.  */
1824   if (junk != 0)
1825     abort ();
1826
1827   switch(r_type)
1828     {
1829     case IMAGE_REL_PPC_ADDR16:
1830     case IMAGE_REL_PPC_REL24:
1831     case IMAGE_REL_PPC_ADDR24:
1832     case IMAGE_REL_PPC_ADDR32:
1833     case IMAGE_REL_PPC_IFGLUE:
1834     case IMAGE_REL_PPC_ADDR32NB:
1835     case IMAGE_REL_PPC_SECTION:
1836     case IMAGE_REL_PPC_SECREL:
1837       DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1838       howto = ppc_coff_howto_table + r_type;
1839       break;
1840     case IMAGE_REL_PPC_IMGLUE:
1841       DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1842       howto = ppc_coff_howto_table + r_type;
1843       break;
1844     case IMAGE_REL_PPC_TOCREL16:
1845       DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1846       if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1847         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1848       else
1849         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1850       break;
1851     default:
1852       fprintf (stderr,
1853               _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
1854               ppc_coff_howto_table[r_type].name,
1855               r_type);
1856       howto = ppc_coff_howto_table + r_type;
1857       break;
1858     }
1859
1860   relent->howto = howto;
1861 }
1862
1863 static reloc_howto_type *
1864 coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
1865      bfd *abfd ATTRIBUTE_UNUSED;
1866      asection *sec;
1867      struct internal_reloc *rel;
1868      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
1869      struct internal_syment *sym ATTRIBUTE_UNUSED;
1870      bfd_vma *addendp;
1871 {
1872   reloc_howto_type *howto;
1873
1874   /* We can encode one of three things in the type field, aside from the
1875      type:
1876      1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1877         value, rather than an addition value
1878      2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1879         the branch is expected to be taken or not.
1880      3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1881      For now, we just strip this stuff to find the type, and ignore it other
1882      than that.  */
1883
1884   unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
1885   unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1886   unsigned short junk    = EXTRACT_JUNK  (rel->r_type);
1887
1888   /* The masking process only slices off the bottom byte for r_type.  */
1889   if (r_type > MAX_RELOC_INDEX)
1890     abort ();
1891
1892   /* Check for absolute crap.  */
1893   if (junk != 0)
1894     abort ();
1895
1896   switch(r_type)
1897     {
1898     case IMAGE_REL_PPC_ADDR32NB:
1899       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1900       *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
1901       howto = ppc_coff_howto_table + r_type;
1902       break;
1903     case IMAGE_REL_PPC_TOCREL16:
1904       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1905       if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1906         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1907       else
1908         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1909       break;
1910     case IMAGE_REL_PPC_ADDR16:
1911     case IMAGE_REL_PPC_REL24:
1912     case IMAGE_REL_PPC_ADDR24:
1913     case IMAGE_REL_PPC_ADDR32:
1914     case IMAGE_REL_PPC_IFGLUE:
1915     case IMAGE_REL_PPC_SECTION:
1916     case IMAGE_REL_PPC_SECREL:
1917       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1918       howto = ppc_coff_howto_table + r_type;
1919       break;
1920     case IMAGE_REL_PPC_IMGLUE:
1921       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1922       howto = ppc_coff_howto_table + r_type;
1923       break;
1924     default:
1925       fprintf (stderr,
1926               _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
1927               ppc_coff_howto_table[r_type].name,
1928               r_type);
1929       howto = ppc_coff_howto_table + r_type;
1930       break;
1931     }
1932
1933   return howto;
1934 }
1935
1936 /* A cheesy little macro to make the code a little more readable.  */
1937 #define HOW2MAP(bfd_rtype,ppc_rtype)  \
1938  case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
1939
1940 static reloc_howto_type *ppc_coff_reloc_type_lookup
1941 PARAMS ((bfd *, bfd_reloc_code_real_type));
1942
1943 static reloc_howto_type *
1944 ppc_coff_reloc_type_lookup (abfd, code)
1945      bfd *abfd ATTRIBUTE_UNUSED;
1946      bfd_reloc_code_real_type code;
1947 {
1948   switch (code)
1949     {
1950       HOW2MAP(BFD_RELOC_32_GOTOFF,    IMAGE_REL_PPC_IMGLUE);
1951       HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
1952       HOW2MAP(BFD_RELOC_16,           IMAGE_REL_PPC_ADDR16);
1953       HOW2MAP(BFD_RELOC_PPC_B26,      IMAGE_REL_PPC_REL24);
1954       HOW2MAP(BFD_RELOC_PPC_BA26,     IMAGE_REL_PPC_ADDR24);
1955       HOW2MAP(BFD_RELOC_PPC_TOC16,    IMAGE_REL_PPC_TOCREL16);
1956       HOW2MAP(BFD_RELOC_16_GOTOFF,    IMAGE_REL_PPC_TOCREL16_DEFN);
1957       HOW2MAP(BFD_RELOC_32,           IMAGE_REL_PPC_ADDR32);
1958       HOW2MAP(BFD_RELOC_RVA,          IMAGE_REL_PPC_ADDR32NB);
1959     default:
1960       return NULL;
1961     }
1962 }
1963 #undef HOW2MAP
1964
1965 static reloc_howto_type *
1966 ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1967                             const char *r_name)
1968 {
1969   unsigned int i;
1970
1971   for (i = 0;
1972        i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]);
1973        i++)
1974     if (ppc_coff_howto_table[i].name != NULL
1975         && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0)
1976       return &ppc_coff_howto_table[i];
1977
1978   return NULL;
1979 }
1980 \f
1981 /* Tailor coffcode.h -- macro heaven.  */
1982
1983 #define RTYPE2HOWTO(cache_ptr, dst)  ppc_coff_rtype2howto (cache_ptr, dst)
1984
1985 /* We use the special COFF backend linker, with our own special touch.  */
1986
1987 #define coff_bfd_reloc_type_lookup   ppc_coff_reloc_type_lookup
1988 #define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup
1989 #define coff_rtype_to_howto          coff_ppc_rtype_to_howto
1990 #define coff_relocate_section        coff_ppc_relocate_section
1991 #define coff_bfd_final_link          ppc_bfd_coff_final_link
1992
1993 #ifndef COFF_IMAGE_WITH_PE
1994 #endif
1995
1996 #define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
1997
1998 #define COFF_PAGE_SIZE                       0x1000
1999
2000 /* FIXME: This controls some code that used to be in peicode.h and is
2001    now in peigen.c.  It will not control the code in peigen.c.  If
2002    anybody wants to get this working, you will need to fix that.  */
2003 #define POWERPC_LE_PE
2004
2005 #define COFF_SECTION_ALIGNMENT_ENTRIES \
2006 { COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \
2007   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
2008 { COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \
2009   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
2010 { COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \
2011   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
2012 { COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \
2013   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
2014 { COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \
2015   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \
2016 { COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \
2017   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }
2018
2019 #include "coffcode.h"
2020 \f
2021 #ifndef COFF_IMAGE_WITH_PE
2022
2023 static bfd_boolean ppc_do_last PARAMS ((bfd *));
2024 static bfd *ppc_get_last PARAMS ((void));
2025
2026 static bfd_boolean
2027 ppc_do_last (abfd)
2028      bfd *abfd;
2029 {
2030   if (abfd == bfd_of_toc_owner)
2031     return TRUE;
2032   else
2033     return FALSE;
2034 }
2035
2036 static bfd *
2037 ppc_get_last()
2038 {
2039   return bfd_of_toc_owner;
2040 }
2041
2042 /* This piece of machinery exists only to guarantee that the bfd that holds
2043    the toc section is written last.
2044
2045    This does depend on bfd_make_section attaching a new section to the
2046    end of the section list for the bfd.
2047
2048    This is otherwise intended to be functionally the same as
2049    cofflink.c:_bfd_coff_final_link(). It is specifically different only
2050    where the POWERPC_LE_PE macro modifies the code. It is left in as a
2051    precise form of comment. krk@cygnus.com  */
2052
2053 /* Do the final link step.  */
2054
2055 bfd_boolean
2056 ppc_bfd_coff_final_link (abfd, info)
2057      bfd *abfd;
2058      struct bfd_link_info *info;
2059 {
2060   bfd_size_type symesz;
2061   struct coff_final_link_info finfo;
2062   bfd_boolean debug_merge_allocated;
2063   asection *o;
2064   struct bfd_link_order *p;
2065   bfd_size_type max_sym_count;
2066   bfd_size_type max_lineno_count;
2067   bfd_size_type max_reloc_count;
2068   bfd_size_type max_output_reloc_count;
2069   bfd_size_type max_contents_size;
2070   file_ptr rel_filepos;
2071   unsigned int relsz;
2072   file_ptr line_filepos;
2073   unsigned int linesz;
2074   bfd *sub;
2075   bfd_byte *external_relocs = NULL;
2076   char strbuf[STRING_SIZE_SIZE];
2077   bfd_size_type amt;
2078
2079   symesz = bfd_coff_symesz (abfd);
2080
2081   finfo.info = info;
2082   finfo.output_bfd = abfd;
2083   finfo.strtab = NULL;
2084   finfo.section_info = NULL;
2085   finfo.last_file_index = -1;
2086   finfo.last_bf_index = -1;
2087   finfo.internal_syms = NULL;
2088   finfo.sec_ptrs = NULL;
2089   finfo.sym_indices = NULL;
2090   finfo.outsyms = NULL;
2091   finfo.linenos = NULL;
2092   finfo.contents = NULL;
2093   finfo.external_relocs = NULL;
2094   finfo.internal_relocs = NULL;
2095   debug_merge_allocated = FALSE;
2096
2097   coff_data (abfd)->link_info = info;
2098
2099   finfo.strtab = _bfd_stringtab_init ();
2100   if (finfo.strtab == NULL)
2101     goto error_return;
2102
2103   if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
2104     goto error_return;
2105   debug_merge_allocated = TRUE;
2106
2107   /* Compute the file positions for all the sections.  */
2108   if (! abfd->output_has_begun)
2109     {
2110       if (! bfd_coff_compute_section_file_positions (abfd))
2111         return FALSE;
2112     }
2113
2114   /* Count the line numbers and relocation entries required for the
2115      output file.  Set the file positions for the relocs.  */
2116   rel_filepos = obj_relocbase (abfd);
2117   relsz = bfd_coff_relsz (abfd);
2118   max_contents_size = 0;
2119   max_lineno_count = 0;
2120   max_reloc_count = 0;
2121
2122   for (o = abfd->sections; o != NULL; o = o->next)
2123     {
2124       o->reloc_count = 0;
2125       o->lineno_count = 0;
2126
2127       for (p = o->map_head.link_order; p != NULL; p = p->next)
2128         {
2129           if (p->type == bfd_indirect_link_order)
2130             {
2131               asection *sec;
2132
2133               sec = p->u.indirect.section;
2134
2135               /* Mark all sections which are to be included in the
2136                  link.  This will normally be every section.  We need
2137                  to do this so that we can identify any sections which
2138                  the linker has decided to not include.  */
2139               sec->linker_mark = TRUE;
2140
2141               if (info->strip == strip_none
2142                   || info->strip == strip_some)
2143                 o->lineno_count += sec->lineno_count;
2144
2145               if (info->relocatable)
2146                 o->reloc_count += sec->reloc_count;
2147
2148               if (sec->rawsize > max_contents_size)
2149                 max_contents_size = sec->rawsize;
2150               if (sec->size > max_contents_size)
2151                 max_contents_size = sec->size;
2152               if (sec->lineno_count > max_lineno_count)
2153                 max_lineno_count = sec->lineno_count;
2154               if (sec->reloc_count > max_reloc_count)
2155                 max_reloc_count = sec->reloc_count;
2156             }
2157           else if (info->relocatable
2158                    && (p->type == bfd_section_reloc_link_order
2159                        || p->type == bfd_symbol_reloc_link_order))
2160             ++o->reloc_count;
2161         }
2162       if (o->reloc_count == 0)
2163         o->rel_filepos = 0;
2164       else
2165         {
2166           o->flags |= SEC_RELOC;
2167           o->rel_filepos = rel_filepos;
2168           rel_filepos += o->reloc_count * relsz;
2169         }
2170     }
2171
2172   /* If doing a relocatable link, allocate space for the pointers we
2173      need to keep.  */
2174   if (info->relocatable)
2175     {
2176       unsigned int i;
2177
2178       /* We use section_count + 1, rather than section_count, because
2179          the target_index fields are 1 based.  */
2180       amt = abfd->section_count + 1;
2181       amt *= sizeof (struct coff_link_section_info);
2182       finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
2183
2184       if (finfo.section_info == NULL)
2185         goto error_return;
2186
2187       for (i = 0; i <= abfd->section_count; i++)
2188         {
2189           finfo.section_info[i].relocs = NULL;
2190           finfo.section_info[i].rel_hashes = NULL;
2191         }
2192     }
2193
2194   /* We now know the size of the relocs, so we can determine the file
2195      positions of the line numbers.  */
2196   line_filepos = rel_filepos;
2197   linesz = bfd_coff_linesz (abfd);
2198   max_output_reloc_count = 0;
2199
2200   for (o = abfd->sections; o != NULL; o = o->next)
2201     {
2202       if (o->lineno_count == 0)
2203         o->line_filepos = 0;
2204       else
2205         {
2206           o->line_filepos = line_filepos;
2207           line_filepos += o->lineno_count * linesz;
2208         }
2209
2210       if (o->reloc_count != 0)
2211         {
2212           /* We don't know the indices of global symbols until we have
2213              written out all the local symbols.  For each section in
2214              the output file, we keep an array of pointers to hash
2215              table entries.  Each entry in the array corresponds to a
2216              reloc.  When we find a reloc against a global symbol, we
2217              set the corresponding entry in this array so that we can
2218              fix up the symbol index after we have written out all the
2219              local symbols.
2220
2221              Because of this problem, we also keep the relocs in
2222              memory until the end of the link.  This wastes memory,
2223              but only when doing a relocatable link, which is not the
2224              common case.  */
2225           BFD_ASSERT (info->relocatable);
2226           amt = o->reloc_count;
2227           amt *= sizeof (struct internal_reloc);
2228           finfo.section_info[o->target_index].relocs =
2229             (struct internal_reloc *) bfd_malloc (amt);
2230           amt = o->reloc_count;
2231           amt *= sizeof (struct coff_link_hash_entry *);
2232           finfo.section_info[o->target_index].rel_hashes =
2233             (struct coff_link_hash_entry **) bfd_malloc (amt);
2234           if (finfo.section_info[o->target_index].relocs == NULL
2235               || finfo.section_info[o->target_index].rel_hashes == NULL)
2236             goto error_return;
2237
2238           if (o->reloc_count > max_output_reloc_count)
2239             max_output_reloc_count = o->reloc_count;
2240         }
2241
2242       /* Reset the reloc and lineno counts, so that we can use them to
2243          count the number of entries we have output so far.  */
2244       o->reloc_count = 0;
2245       o->lineno_count = 0;
2246     }
2247
2248   obj_sym_filepos (abfd) = line_filepos;
2249
2250   /* Figure out the largest number of symbols in an input BFD.  Take
2251      the opportunity to clear the output_has_begun fields of all the
2252      input BFD's.  */
2253   max_sym_count = 0;
2254   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2255     {
2256       bfd_size_type sz;
2257
2258       sub->output_has_begun = FALSE;
2259       sz = obj_raw_syment_count (sub);
2260       if (sz > max_sym_count)
2261         max_sym_count = sz;
2262     }
2263
2264   /* Allocate some buffers used while linking.  */
2265   amt = max_sym_count * sizeof (struct internal_syment);
2266   finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
2267   amt = max_sym_count * sizeof (asection *);
2268   finfo.sec_ptrs = (asection **) bfd_malloc (amt);
2269   amt = max_sym_count * sizeof (long);
2270   finfo.sym_indices = (long *) bfd_malloc (amt);
2271   amt = (max_sym_count + 1) * symesz;
2272   finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
2273   amt = max_lineno_count * bfd_coff_linesz (abfd);
2274   finfo.linenos = (bfd_byte *) bfd_malloc (amt);
2275   finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
2276   finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
2277   if (! info->relocatable)
2278     {
2279       amt = max_reloc_count * sizeof (struct internal_reloc);
2280       finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
2281     }
2282   if ((finfo.internal_syms == NULL && max_sym_count > 0)
2283       || (finfo.sec_ptrs == NULL && max_sym_count > 0)
2284       || (finfo.sym_indices == NULL && max_sym_count > 0)
2285       || finfo.outsyms == NULL
2286       || (finfo.linenos == NULL && max_lineno_count > 0)
2287       || (finfo.contents == NULL && max_contents_size > 0)
2288       || (finfo.external_relocs == NULL && max_reloc_count > 0)
2289       || (! info->relocatable
2290           && finfo.internal_relocs == NULL
2291           && max_reloc_count > 0))
2292     goto error_return;
2293
2294   /* We now know the position of everything in the file, except that
2295      we don't know the size of the symbol table and therefore we don't
2296      know where the string table starts.  We just build the string
2297      table in memory as we go along.  We process all the relocations
2298      for a single input file at once.  */
2299   obj_raw_syment_count (abfd) = 0;
2300
2301   if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
2302     {
2303       if (! bfd_coff_start_final_link (abfd, info))
2304         goto error_return;
2305     }
2306
2307   for (o = abfd->sections; o != NULL; o = o->next)
2308     {
2309       for (p = o->map_head.link_order; p != NULL; p = p->next)
2310         {
2311           if (p->type == bfd_indirect_link_order
2312               && (bfd_get_flavour (p->u.indirect.section->owner)
2313                   == bfd_target_coff_flavour))
2314             {
2315               sub = p->u.indirect.section->owner;
2316 #ifdef POWERPC_LE_PE
2317               if (! sub->output_has_begun && !ppc_do_last(sub))
2318 #else
2319               if (! sub->output_has_begun)
2320 #endif
2321                 {
2322                   if (! _bfd_coff_link_input_bfd (&finfo, sub))
2323                     goto error_return;
2324                   sub->output_has_begun = TRUE;
2325                 }
2326             }
2327           else if (p->type == bfd_section_reloc_link_order
2328                    || p->type == bfd_symbol_reloc_link_order)
2329             {
2330               if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
2331                 goto error_return;
2332             }
2333           else
2334             {
2335               if (! _bfd_default_link_order (abfd, info, o, p))
2336                 goto error_return;
2337             }
2338         }
2339     }
2340
2341 #ifdef POWERPC_LE_PE
2342   {
2343     bfd* last_one = ppc_get_last();
2344     if (last_one)
2345       {
2346         if (! _bfd_coff_link_input_bfd (&finfo, last_one))
2347           goto error_return;
2348       }
2349     last_one->output_has_begun = TRUE;
2350   }
2351 #endif
2352
2353   /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
2354   coff_debug_merge_hash_table_free (&finfo.debug_merge);
2355   debug_merge_allocated = FALSE;
2356
2357   if (finfo.internal_syms != NULL)
2358     {
2359       free (finfo.internal_syms);
2360       finfo.internal_syms = NULL;
2361     }
2362   if (finfo.sec_ptrs != NULL)
2363     {
2364       free (finfo.sec_ptrs);
2365       finfo.sec_ptrs = NULL;
2366     }
2367   if (finfo.sym_indices != NULL)
2368     {
2369       free (finfo.sym_indices);
2370       finfo.sym_indices = NULL;
2371     }
2372   if (finfo.linenos != NULL)
2373     {
2374       free (finfo.linenos);
2375       finfo.linenos = NULL;
2376     }
2377   if (finfo.contents != NULL)
2378     {
2379       free (finfo.contents);
2380       finfo.contents = NULL;
2381     }
2382   if (finfo.external_relocs != NULL)
2383     {
2384       free (finfo.external_relocs);
2385       finfo.external_relocs = NULL;
2386     }
2387   if (finfo.internal_relocs != NULL)
2388     {
2389       free (finfo.internal_relocs);
2390       finfo.internal_relocs = NULL;
2391     }
2392
2393   /* The value of the last C_FILE symbol is supposed to be the symbol
2394      index of the first external symbol.  Write it out again if
2395      necessary.  */
2396   if (finfo.last_file_index != -1
2397       && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
2398     {
2399       file_ptr pos;
2400
2401       finfo.last_file.n_value = obj_raw_syment_count (abfd);
2402       bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
2403                              (PTR) finfo.outsyms);
2404       pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
2405       if (bfd_seek (abfd, pos, SEEK_SET) != 0
2406           || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
2407         return FALSE;
2408     }
2409
2410   /* Write out the global symbols.  */
2411   finfo.failed = FALSE;
2412   coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym,
2413                            (PTR) &finfo);
2414   if (finfo.failed)
2415     goto error_return;
2416
2417   /* The outsyms buffer is used by _bfd_coff_write_global_sym.  */
2418   if (finfo.outsyms != NULL)
2419     {
2420       free (finfo.outsyms);
2421       finfo.outsyms = NULL;
2422     }
2423
2424   if (info->relocatable)
2425     {
2426       /* Now that we have written out all the global symbols, we know
2427          the symbol indices to use for relocs against them, and we can
2428          finally write out the relocs.  */
2429       amt = max_output_reloc_count * relsz;
2430       external_relocs = (bfd_byte *) bfd_malloc (amt);
2431       if (external_relocs == NULL)
2432         goto error_return;
2433
2434       for (o = abfd->sections; o != NULL; o = o->next)
2435         {
2436           struct internal_reloc *irel;
2437           struct internal_reloc *irelend;
2438           struct coff_link_hash_entry **rel_hash;
2439           bfd_byte *erel;
2440
2441           if (o->reloc_count == 0)
2442             continue;
2443
2444           irel = finfo.section_info[o->target_index].relocs;
2445           irelend = irel + o->reloc_count;
2446           rel_hash = finfo.section_info[o->target_index].rel_hashes;
2447           erel = external_relocs;
2448           for (; irel < irelend; irel++, rel_hash++, erel += relsz)
2449             {
2450               if (*rel_hash != NULL)
2451                 {
2452                   BFD_ASSERT ((*rel_hash)->indx >= 0);
2453                   irel->r_symndx = (*rel_hash)->indx;
2454                 }
2455               bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
2456             }
2457
2458           amt = relsz * o->reloc_count;
2459           if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
2460               || bfd_bwrite ((PTR) external_relocs, amt, abfd) != amt)
2461             goto error_return;
2462         }
2463
2464       free (external_relocs);
2465       external_relocs = NULL;
2466     }
2467
2468   /* Free up the section information.  */
2469   if (finfo.section_info != NULL)
2470     {
2471       unsigned int i;
2472
2473       for (i = 0; i < abfd->section_count; i++)
2474         {
2475           if (finfo.section_info[i].relocs != NULL)
2476             free (finfo.section_info[i].relocs);
2477           if (finfo.section_info[i].rel_hashes != NULL)
2478             free (finfo.section_info[i].rel_hashes);
2479         }
2480       free (finfo.section_info);
2481       finfo.section_info = NULL;
2482     }
2483
2484   /* If we have optimized stabs strings, output them.  */
2485   if (coff_hash_table (info)->stab_info.stabstr != NULL)
2486     {
2487       if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
2488         return FALSE;
2489     }
2490
2491   /* Write out the string table.  */
2492   if (obj_raw_syment_count (abfd) != 0)
2493     {
2494       file_ptr pos;
2495
2496       pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
2497       if (bfd_seek (abfd, pos, SEEK_SET) != 0)
2498         return FALSE;
2499
2500 #if STRING_SIZE_SIZE == 4
2501       H_PUT_32 (abfd,
2502                 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
2503                 strbuf);
2504 #else
2505  #error Change H_PUT_32 above
2506 #endif
2507
2508       if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
2509           != STRING_SIZE_SIZE)
2510         return FALSE;
2511
2512       if (! _bfd_stringtab_emit (abfd, finfo.strtab))
2513         return FALSE;
2514     }
2515
2516   _bfd_stringtab_free (finfo.strtab);
2517
2518   /* Setting bfd_get_symcount to 0 will cause write_object_contents to
2519      not try to write out the symbols.  */
2520   bfd_get_symcount (abfd) = 0;
2521
2522   return TRUE;
2523
2524  error_return:
2525   if (debug_merge_allocated)
2526     coff_debug_merge_hash_table_free (&finfo.debug_merge);
2527   if (finfo.strtab != NULL)
2528     _bfd_stringtab_free (finfo.strtab);
2529   if (finfo.section_info != NULL)
2530     {
2531       unsigned int i;
2532
2533       for (i = 0; i < abfd->section_count; i++)
2534         {
2535           if (finfo.section_info[i].relocs != NULL)
2536             free (finfo.section_info[i].relocs);
2537           if (finfo.section_info[i].rel_hashes != NULL)
2538             free (finfo.section_info[i].rel_hashes);
2539         }
2540       free (finfo.section_info);
2541     }
2542   if (finfo.internal_syms != NULL)
2543     free (finfo.internal_syms);
2544   if (finfo.sec_ptrs != NULL)
2545     free (finfo.sec_ptrs);
2546   if (finfo.sym_indices != NULL)
2547     free (finfo.sym_indices);
2548   if (finfo.outsyms != NULL)
2549     free (finfo.outsyms);
2550   if (finfo.linenos != NULL)
2551     free (finfo.linenos);
2552   if (finfo.contents != NULL)
2553     free (finfo.contents);
2554   if (finfo.external_relocs != NULL)
2555     free (finfo.external_relocs);
2556   if (finfo.internal_relocs != NULL)
2557     free (finfo.internal_relocs);
2558   if (external_relocs != NULL)
2559     free (external_relocs);
2560   return FALSE;
2561 }
2562 #endif
2563 \f
2564 /* Forward declaration for use by alternative_target field.  */
2565 #ifdef TARGET_BIG_SYM
2566 extern const bfd_target TARGET_BIG_SYM;
2567 #endif
2568
2569 /* The transfer vectors that lead the outside world to all of the above.  */
2570
2571 #ifdef TARGET_LITTLE_SYM
2572 const bfd_target TARGET_LITTLE_SYM =
2573 {
2574   TARGET_LITTLE_NAME,           /* name or coff-arm-little */
2575   bfd_target_coff_flavour,
2576   BFD_ENDIAN_LITTLE,            /* data byte order is little */
2577   BFD_ENDIAN_LITTLE,            /* header byte order is little */
2578
2579   (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
2580    HAS_LINENO | HAS_DEBUG |
2581    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2582
2583 #ifndef COFF_WITH_PE
2584   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2585 #else
2586   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
2587    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2588 #endif
2589
2590   0,                            /* leading char */
2591   '/',                          /* ar_pad_char */
2592   15,                           /* ar_max_namelen??? FIXMEmgo */
2593
2594   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2595   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2596   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2597
2598   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2599   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2600   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2601
2602   {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
2603      bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2604   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2605      bfd_false},
2606   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
2607      _bfd_write_archive_contents, bfd_false},
2608
2609   BFD_JUMP_TABLE_GENERIC (coff),
2610   BFD_JUMP_TABLE_COPY (coff),
2611   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2612   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2613   BFD_JUMP_TABLE_SYMBOLS (coff),
2614   BFD_JUMP_TABLE_RELOCS (coff),
2615   BFD_JUMP_TABLE_WRITE (coff),
2616   BFD_JUMP_TABLE_LINK (coff),
2617   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2618
2619   /* Alternative_target.  */
2620 #ifdef TARGET_BIG_SYM
2621   & TARGET_BIG_SYM,
2622 #else
2623   NULL,
2624 #endif
2625
2626   COFF_SWAP_TABLE
2627 };
2628 #endif
2629
2630 #ifdef TARGET_BIG_SYM
2631 const bfd_target TARGET_BIG_SYM =
2632 {
2633   TARGET_BIG_NAME,
2634   bfd_target_coff_flavour,
2635   BFD_ENDIAN_BIG,               /* data byte order is big */
2636   BFD_ENDIAN_BIG,               /* header byte order is big */
2637
2638   (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
2639    HAS_LINENO | HAS_DEBUG |
2640    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2641
2642 #ifndef COFF_WITH_PE
2643   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2644 #else
2645   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
2646    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2647 #endif
2648
2649   0,                            /* leading char */
2650   '/',                          /* ar_pad_char */
2651   15,                           /* ar_max_namelen??? FIXMEmgo */
2652
2653   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2654   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2655   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
2656
2657   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2658   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2659   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2660
2661   {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
2662      bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2663   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2664      bfd_false},
2665   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
2666      _bfd_write_archive_contents, bfd_false},
2667
2668   BFD_JUMP_TABLE_GENERIC (coff),
2669   BFD_JUMP_TABLE_COPY (coff),
2670   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2671   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2672   BFD_JUMP_TABLE_SYMBOLS (coff),
2673   BFD_JUMP_TABLE_RELOCS (coff),
2674   BFD_JUMP_TABLE_WRITE (coff),
2675   BFD_JUMP_TABLE_LINK (coff),
2676   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2677
2678   /* Alternative_target.  */
2679 #ifdef TARGET_LITTLE_SYM
2680   & TARGET_LITTLE_SYM,
2681 #else
2682   NULL,
2683 #endif
2684
2685   COFF_SWAP_TABLE
2686 };
2687
2688 #endif