bfd/coff-ppc.c

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