bfd/coff-ppc.c

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