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