bfd/coff-ppc.c

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