bfd/coff-mcore.c

   1 /* BFD back-end for Motorola MCore COFF/PE
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, 51 Franklin Street - Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "coff/mcore.h"
  26 #include "coff/internal.h"
  27 #include "coff/pe.h"
  28 #include "libcoff.h"
  29
  30 #ifdef BADMAG
  31 #undef BADMAG
  32 #endif
  33 #define BADMAG(x) MCOREBADMAG(x)
  34
  35 #ifndef NUM_ELEM
  36 #define NUM_ELEM(A) (sizeof (A) / sizeof (A)[0])
  37 #endif
  38
  39 /* This file is compiled more than once, but we only compile the
  40    final_link routine once.  */
  41 extern bfd_boolean mcore_bfd_coff_final_link
  42   PARAMS ((bfd *, struct bfd_link_info *));
  43 static bfd_reloc_status_type mcore_coff_unsupported_reloc
  44   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  45 static bfd_boolean coff_mcore_relocate_section
  46   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  47            struct internal_reloc *, struct internal_syment *, asection **));
  48 static reloc_howto_type *mcore_coff_reloc_type_lookup
  49   PARAMS ((bfd *, bfd_reloc_code_real_type));
  50 static reloc_howto_type *coff_mcore_rtype_to_howto
  51   PARAMS ((bfd *, asection *, struct internal_reloc *,
  52            struct coff_link_hash_entry *, struct internal_syment *,
  53            bfd_vma *));
  54 static bfd_boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
  55 \f
  56 /* The NT loader points the toc register to &toc + 32768, in order to
  57    use the complete range of a 16-bit displacement. We have to adjust
  58    for this when we fix up loads displaced off the toc reg.  */
  59 #define TOC_LOAD_ADJUSTMENT (-32768)
  60 #define TOC_SECTION_NAME ".private.toc"
  61
  62 /* The main body of code is in coffcode.h.  */
  63 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
  64
  65 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
  66    from smaller values.  Start with zero, widen, *then* decrement.  */
  67 #define MINUS_ONE       (((bfd_vma)0) - 1)
  68 \f
  69 static reloc_howto_type mcore_coff_howto_table[] =
  70 {
  71   /* Unused: */
  72   HOWTO (IMAGE_REL_MCORE_ABSOLUTE,/* type */
  73          0,                      /* rightshift */
  74          0,                      /* size (0 = byte, 1 = short, 2 = long) */
  75          0,                      /* bitsize */
  76          FALSE,                  /* pc_relative */
  77          0,                      /* bitpos */
  78          complain_overflow_dont, /* dont complain_on_overflow */
  79          NULL,                   /* special_function */
  80          "ABSOLUTE",             /* name */
  81          FALSE,                  /* partial_inplace */
  82          0x00,                   /* src_mask */
  83          0x00,                   /* dst_mask */
  84          FALSE),                 /* pcrel_offset */
  85
  86   HOWTO (IMAGE_REL_MCORE_ADDR32,/* type */
  87          0,                     /* rightshift */
  88          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  89          32,                    /* bitsize */
  90          FALSE,                 /* pc_relative */
  91          0,                     /* bitpos */
  92          complain_overflow_bitfield, /* complain_on_overflow */
  93          NULL,                  /* special_function */
  94          "ADDR32",              /* name */
  95          TRUE,                  /* partial_inplace */
  96          0xffffffff,            /* src_mask */
  97          0xffffffff,            /* dst_mask */
  98          FALSE),                /* pcrel_offset */
  99
 100   /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
 101      Should not appear in object files.  */
 102   HOWTO (IMAGE_REL_MCORE_PCREL_IMM8BY4, /* type */
 103          2,                     /* rightshift */
 104          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 105          8,                     /* bitsize */
 106          TRUE,                  /* pc_relative */
 107          0,                     /* bitpos */
 108          complain_overflow_bitfield, /* complain_on_overflow */
 109          mcore_coff_unsupported_reloc, /* special_function */
 110          "IMM8BY4",             /* name */
 111          FALSE,                 /* partial_inplace */
 112          0,                     /* src_mask */
 113          0,                     /* dst_mask */
 114          TRUE),                 /* pcrel_offset */
 115
 116   /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
 117      Span 2k instructions == 4k bytes.
 118      Only useful pieces at the relocated address are the opcode (5 bits) */
 119   HOWTO (IMAGE_REL_MCORE_PCREL_IMM11BY2,/* type */
 120          1,                     /* rightshift */
 121          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 122          11,                    /* bitsize */
 123          TRUE,                  /* pc_relative */
 124          0,                     /* bitpos */
 125          complain_overflow_signed, /* complain_on_overflow */
 126          NULL,                  /* special_function */
 127          "IMM11BY2",            /* name */
 128          FALSE,                 /* partial_inplace */
 129          0x0,                   /* src_mask */
 130          0x7ff,                 /* dst_mask */
 131          TRUE),                 /* pcrel_offset */
 132
 133   /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported.  */
 134   HOWTO (IMAGE_REL_MCORE_PCREL_IMM4BY2, /* type */
 135          1,                     /* rightshift */
 136          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 137          4,                     /* bitsize */
 138          TRUE,                  /* pc_relative */
 139          0,                     /* bitpos */
 140          complain_overflow_bitfield, /* complain_on_overflow */
 141          mcore_coff_unsupported_reloc, /* special_function */
 142          "IMM4BY2",              /* name */
 143          FALSE,                 /* partial_inplace */
 144          0,                     /* src_mask */
 145          0,                     /* dst_mask */
 146          TRUE),                 /* pcrel_offset */
 147
 148   /* 32-bit pc-relative. Eventually this will help support PIC code.  */
 149   HOWTO (IMAGE_REL_MCORE_PCREL_32,/* type */
 150          0,                     /* rightshift */
 151          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 152          32,                    /* bitsize */
 153          TRUE,                  /* pc_relative */
 154          0,                     /* bitpos */
 155          complain_overflow_bitfield, /* complain_on_overflow */
 156          NULL,                  /* special_function */
 157          "PCREL_32",            /* name */
 158          FALSE,                 /* partial_inplace */
 159          0x0,                   /* src_mask */
 160          0xffffffff,            /* dst_mask */
 161          TRUE),                 /* pcrel_offset */
 162
 163   /* Like PCREL_IMM11BY2, this relocation indicates that there is a
 164      'jsri' at the specified address. There is a separate relocation
 165      entry for the literal pool entry that it references, but we
 166      might be able to change the jsri to a bsr if the target turns out
 167      to be close enough [even though we won't reclaim the literal pool
 168      entry, we'll get some runtime efficiency back]. Note that this
 169      is a relocation that we are allowed to safely ignore.  */
 170   HOWTO (IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2,/* type */
 171          1,                     /* rightshift */
 172          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 173          11,                    /* bitsize */
 174          TRUE,                  /* pc_relative */
 175          0,                     /* bitpos */
 176          complain_overflow_signed, /* complain_on_overflow */
 177          NULL,                  /* special_function */
 178          "JSR_IMM11BY2",        /* name */
 179          FALSE,                 /* partial_inplace */
 180          0x0,                   /* src_mask */
 181          0x7ff,                 /* dst_mask */
 182          TRUE),                 /* pcrel_offset */
 183
 184   HOWTO (IMAGE_REL_MCORE_RVA,   /* type */
 185          0,                     /* rightshift */
 186          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 187          32,                    /* bitsize */
 188          FALSE,                 /* pc_relative */
 189          0,                     /* bitpos */
 190          complain_overflow_signed, /* complain_on_overflow */
 191          NULL,                  /* special_function */
 192          "MCORE_RVA",           /* name */
 193          TRUE,                  /* partial_inplace */
 194          0xffffffff,            /* src_mask */
 195          0xffffffff,            /* dst_mask */
 196          TRUE)                  /* pcrel_offset */
 197 };
 198 \f
 199 /* Extend the coff_link_hash_table structure with a few M*Core specific fields.
 200    This allows us to store global data here without actually creating any
 201    global variables, which is a no-no in the BFD world.  */
 202 typedef struct coff_mcore_link_hash_table
 203 {
 204   /* The original coff_link_hash_table structure.  MUST be first field.  */
 205   struct coff_link_hash_table   root;
 206
 207   bfd *                         bfd_of_toc_owner;
 208   long int                      global_toc_size;
 209   long int                      import_table_size;
 210   long int                      first_thunk_address;
 211   long int                      thunk_size;
 212 }
 213 mcore_hash_table;
 214
 215 /* Get the MCore coff linker hash table from a link_info structure.  */
 216 #define coff_mcore_hash_table(info) \
 217   ((mcore_hash_table *) ((info)->hash))
 218
 219 \f
 220 /* Add an entry to the base file.  */
 221
 222 static bfd_boolean
 223 mcore_emit_base_file_entry (struct bfd_link_info *info,
 224                             bfd *output_bfd,
 225                             asection *input_section,
 226                             bfd_vma reloc_offset)
 227 {
 228   bfd_vma addr = reloc_offset
 229                  - input_section->vma
 230                  + input_section->output_offset
 231                  + input_section->output_section->vma;
 232
 233   if (coff_data (output_bfd)->pe)
 234      addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
 235
 236   if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
 237     return TRUE;
 238
 239   bfd_set_error (bfd_error_system_call);
 240   return FALSE;
 241 }
 242 \f
 243 static bfd_reloc_status_type
 244 mcore_coff_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
 245                            output_bfd, error_message)
 246      bfd * abfd;
 247      arelent * reloc_entry;
 248      asymbol * symbol ATTRIBUTE_UNUSED;
 249      PTR data ATTRIBUTE_UNUSED;
 250      asection * input_section ATTRIBUTE_UNUSED;
 251      bfd * output_bfd ATTRIBUTE_UNUSED;
 252      char ** error_message ATTRIBUTE_UNUSED;
 253 {
 254   BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
 255
 256   _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
 257                       abfd,
 258                       reloc_entry->howto->name,
 259                       reloc_entry->howto->type);
 260
 261   return bfd_reloc_notsupported;
 262 }
 263 \f
 264 /* A cheesy little macro to make the code a little more readable.  */
 265 #define HOW2MAP(bfd_rtype, mcore_rtype)  \
 266  case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]
 267
 268 static reloc_howto_type *
 269 mcore_coff_reloc_type_lookup (abfd, code)
 270      bfd * abfd ATTRIBUTE_UNUSED;
 271      bfd_reloc_code_real_type code;
 272 {
 273   switch (code)
 274     {
 275       HOW2MAP (BFD_RELOC_32,                       IMAGE_REL_MCORE_ADDR32);
 276       HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM8BY4,      IMAGE_REL_MCORE_PCREL_IMM8BY4);
 277       HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM11BY2,     IMAGE_REL_MCORE_PCREL_IMM11BY2);
 278       HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM4BY2,      IMAGE_REL_MCORE_PCREL_IMM4BY2);
 279       HOW2MAP (BFD_RELOC_32_PCREL,                 IMAGE_REL_MCORE_PCREL_32);
 280       HOW2MAP (BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2);
 281       HOW2MAP (BFD_RELOC_RVA,                      IMAGE_REL_MCORE_RVA);
 282    default:
 283       return NULL;
 284     }
 285   /*NOTREACHED*/
 286 }
 287 #undef HOW2MAP
 288
 289 static reloc_howto_type *
 290 mcore_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 291                               const char *r_name)
 292 {
 293   unsigned int i;
 294
 295   for (i = 0;
 296        i < (sizeof (mcore_coff_howto_table)
 297             / sizeof (mcore_coff_howto_table[0]));
 298        i++)
 299     if (mcore_coff_howto_table[i].name != NULL
 300         && strcasecmp (mcore_coff_howto_table[i].name, r_name) == 0)
 301       return &mcore_coff_howto_table[i];
 302
 303   return NULL;
 304 }
 305
 306 #define RTYPE2HOWTO(cache_ptr, dst) \
 307   (cache_ptr)->howto = mcore_coff_howto_table + (dst)->r_type;
 308
 309 static reloc_howto_type *
 310 coff_mcore_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
 311      bfd * abfd ATTRIBUTE_UNUSED;
 312      asection * sec;
 313      struct internal_reloc * rel;
 314      struct coff_link_hash_entry * h ATTRIBUTE_UNUSED;
 315      struct internal_syment * sym;
 316      bfd_vma * addendp;
 317 {
 318   reloc_howto_type * howto;
 319
 320   if (rel->r_type >= NUM_ELEM (mcore_coff_howto_table))
 321     return NULL;
 322
 323   howto = mcore_coff_howto_table + rel->r_type;
 324
 325   if (rel->r_type == IMAGE_REL_MCORE_RVA)
 326     * addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
 327
 328   else if (howto->pc_relative)
 329     {
 330       * addendp = sec->vma - 2; /* XXX guess - is this right ? */
 331
 332       /* If the symbol is defined, then the generic code is going to
 333          add back the symbol value in order to cancel out an
 334          adjustment it made to the addend.  However, we set the addend
 335          to 0 at the start of this function.  We need to adjust here,
 336          to avoid the adjustment the generic code will make.  FIXME:
 337          This is getting a bit hackish.  */
 338       if (sym != NULL && sym->n_scnum != 0)
 339         * addendp -= sym->n_value;
 340     }
 341   else
 342     * addendp = 0;
 343
 344   return howto;
 345 }
 346
 347 /* Return TRUE if this relocation should appear in the output .reloc section.
 348    This function is referenced in pe_mkobject in peicode.h.  */
 349
 350 static bfd_boolean
 351 in_reloc_p (abfd, howto)
 352      bfd * abfd ATTRIBUTE_UNUSED;
 353      reloc_howto_type * howto;
 354 {
 355   return ! howto->pc_relative && howto->type != IMAGE_REL_MCORE_RVA;
 356 }
 357 \f
 358 /* The reloc processing routine for the optimized COFF linker.  */
 359 static bfd_boolean
 360 coff_mcore_relocate_section (output_bfd, info, input_bfd, input_section,
 361                            contents, relocs, syms, sections)
 362      bfd * output_bfd;
 363      struct bfd_link_info * info;
 364      bfd * input_bfd;
 365      asection * input_section;
 366      bfd_byte * contents;
 367      struct internal_reloc * relocs;
 368      struct internal_syment * syms;
 369      asection ** sections;
 370 {
 371   struct internal_reloc * rel;
 372   struct internal_reloc * relend;
 373   bfd_boolean hihalf;
 374   bfd_vma hihalf_val;
 375
 376   /* If we are performing a relocatable link, we don't need to do a
 377      thing.  The caller will take care of adjusting the reloc
 378      addresses and symbol indices.  */
 379   if (info->relocatable)
 380     return TRUE;
 381
 382   /* Check if we have the same endianess */
 383   if (   input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
 384       && output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
 385     {
 386       (*_bfd_error_handler)
 387         (_("%B: compiled for a %s system and target is %s.\n"),
 388          input_bfd,
 389          bfd_big_endian (input_bfd) ? _("big endian") : _("little endian"),
 390          bfd_big_endian (output_bfd) ? _("big endian") : _("little endian"));
 391
 392       bfd_set_error (bfd_error_wrong_format);
 393       return FALSE;
 394     }
 395
 396   hihalf = FALSE;
 397   hihalf_val = 0;
 398
 399   rel = relocs;
 400   relend = rel + input_section->reloc_count;
 401
 402   for (; rel < relend; rel++)
 403     {
 404       long                           symndx;
 405       struct internal_syment *       sym;
 406       bfd_vma                        val;
 407       bfd_vma                        addend;
 408       bfd_reloc_status_type          rstat;
 409       bfd_byte *                     loc;
 410       unsigned short                 r_type = rel->r_type;
 411       reloc_howto_type *             howto = NULL;
 412       struct coff_link_hash_entry *  h;
 413       const char *                   my_name;
 414
 415       symndx = rel->r_symndx;
 416       loc = contents + rel->r_vaddr - input_section->vma;
 417
 418       if (symndx == -1)
 419         {
 420           h = NULL;
 421           sym = NULL;
 422         }
 423       else
 424         {
 425           h = obj_coff_sym_hashes (input_bfd)[symndx];
 426           sym = syms + symndx;
 427         }
 428
 429       addend = 0;
 430
 431       /* Get the howto and initialise the addend.  */
 432       howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
 433                                        sym, & addend);
 434       if (howto == NULL)
 435         return FALSE;
 436
 437       val = 0;
 438
 439       if (h == NULL)
 440         {
 441           if (symndx == -1)
 442             my_name = "*ABS*";
 443           else
 444             {
 445               asection * sec = sections[symndx];
 446
 447               val = (sym->n_value
 448                      + sec->output_section->vma
 449                      + sec->output_offset);
 450
 451               if (sym == NULL)
 452                 my_name = "*unknown*";
 453               else if (   sym->_n._n_n._n_zeroes == 0
 454                        && sym->_n._n_n._n_offset != 0)
 455                 my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
 456               else
 457                 {
 458                   static char buf [SYMNMLEN + 1];
 459
 460                   strncpy (buf, sym->_n._n_name, SYMNMLEN);
 461                   buf[SYMNMLEN] = '\0';
 462                   my_name = buf;
 463                 }
 464             }
 465         }
 466       else
 467         {
 468           if (   h->root.type == bfd_link_hash_defined
 469               || h->root.type == bfd_link_hash_defweak)
 470             {
 471               asection * sec = h->root.u.def.section;
 472
 473               val = (h->root.u.def.value
 474                      + sec->output_section->vma
 475                      + sec->output_offset);
 476             }
 477           else
 478             {
 479               if (! ((*info->callbacks->undefined_symbol)
 480                      (info, h->root.root.string, input_bfd, input_section,
 481                       rel->r_vaddr - input_section->vma, TRUE)))
 482                 return FALSE;
 483             }
 484
 485           my_name = h->root.root.string;
 486         }
 487
 488       rstat = bfd_reloc_ok;
 489
 490       /* Each case must do its own relocation, setting rstat appropriately.  */
 491       switch (r_type)
 492         {
 493         default:
 494           _bfd_error_handler (_("%B: unsupported relocation type 0x%02x"),
 495                               input_bfd, r_type);
 496           bfd_set_error (bfd_error_bad_value);
 497           return FALSE;
 498
 499         case IMAGE_REL_MCORE_ABSOLUTE:
 500           _bfd_error_handler
 501             (_("Warning: unsupported reloc %s <file %B, section %A>\n"
 502                "sym %ld (%s), r_vaddr %ld (%lx)"),
 503              input_bfd, input_section, howto->name,
 504              rel->r_symndx, my_name, (long) rel->r_vaddr,
 505              (unsigned long) rel->r_vaddr);
 506           break;
 507
 508         case IMAGE_REL_MCORE_PCREL_IMM8BY4:
 509         case IMAGE_REL_MCORE_PCREL_IMM11BY2:
 510         case IMAGE_REL_MCORE_PCREL_IMM4BY2:
 511         case IMAGE_REL_MCORE_PCREL_32:
 512         case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
 513         case IMAGE_REL_MCORE_ADDR32:
 514           /* XXX fixme - shouldn't this be like the code for the RVA reloc ? */
 515           rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
 516           break;
 517
 518         case IMAGE_REL_MCORE_RVA:
 519           rstat = _bfd_final_link_relocate
 520             (howto, input_bfd,
 521              input_section, contents, rel->r_vaddr - input_section->vma,
 522              val, addend);
 523           break;
 524         }
 525
 526       /* Emit a reloc if the backend thinks it needs it.  */
 527       if (info->base_file
 528           && sym
 529           && pe_data (output_bfd)->in_reloc_p (output_bfd, howto)
 530           && !mcore_emit_base_file_entry (info, output_bfd, input_section,
 531                                           rel->r_vaddr))
 532         return FALSE;
 533
 534       switch (rstat)
 535         {
 536         default:
 537           abort ();
 538
 539         case bfd_reloc_ok:
 540           break;
 541
 542         case bfd_reloc_overflow:
 543           if (! ((*info->callbacks->reloc_overflow)
 544                  (info, (h ? &h->root : NULL), my_name, howto->name,
 545                   (bfd_vma) 0, input_bfd,
 546                   input_section, rel->r_vaddr - input_section->vma)))
 547             return FALSE;
 548         }
 549     }
 550
 551   return TRUE;
 552 }
 553 \f
 554 /* Tailor coffcode.h -- macro heaven.  */
 555
 556 /* We use the special COFF backend linker, with our own special touch.  */
 557
 558 #define coff_bfd_reloc_type_lookup   mcore_coff_reloc_type_lookup
 559 #define coff_bfd_reloc_name_lookup mcore_coff_reloc_name_lookup
 560 #define coff_relocate_section        coff_mcore_relocate_section
 561 #define coff_rtype_to_howto          coff_mcore_rtype_to_howto
 562
 563 #define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;}
 564
 565 /* Make sure that the 'r_offset' field is copied properly
 566    so that identical binaries will compare the same.  */
 567 #define SWAP_IN_RELOC_OFFSET         H_GET_32
 568 #define SWAP_OUT_RELOC_OFFSET        H_PUT_32
 569
 570 #define COFF_PAGE_SIZE               0x1000
 571
 572 #include "coffcode.h"
 573 \f
 574 /* Forward declaration to initialise alternative_target field.  */
 575 extern const bfd_target TARGET_LITTLE_SYM;
 576
 577 /* The transfer vectors that lead the outside world to all of the above.  */
 578 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED,
 579                             (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
 580                             0, & TARGET_LITTLE_SYM, COFF_SWAP_TABLE)
 581 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED,
 582                                (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
 583                                0, & TARGET_BIG_SYM, COFF_SWAP_TABLE)