bfd/coff-ppc.c

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