bfd/coff-mcore.c

   1 /* BFD back-end for Motorolla MCore COFF/PE
   2    Copyright 1999
   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 2 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, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.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 boolean mcore_bfd_coff_final_link
  42   PARAMS ((bfd *, struct bfd_link_info *));
  43
  44 static struct bfd_link_hash_table * coff_mcore_link_hash_table_create
  45   PARAMS ((bfd *));
  46 static bfd_reloc_status_type        mcore_coff_unsupported_reloc
  47   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  48 static boolean                      coff_mcore_relocate_section
  49   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  50            struct internal_reloc *, struct internal_syment *, asection **));
  51 static reloc_howto_type *           mcore_coff_reloc_type_lookup
  52   PARAMS ((bfd *, bfd_reloc_code_real_type));
  53 static reloc_howto_type *           coff_mcore_rtype_to_howto
  54   PARAMS ((bfd *, asection *, struct internal_reloc *,
  55            struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *));
  56 static const bfd_target *           pe_object_p
  57   PARAMS ((bfd *));
  58
  59
  60 \f
  61 /* The NT loader points the toc register to &toc + 32768, in order to
  62    use the complete range of a 16-bit displacement. We have to adjust
  63    for this when we fix up loads displaced off the toc reg.  */
  64 #define TOC_LOAD_ADJUSTMENT (-32768)
  65 #define TOC_SECTION_NAME ".private.toc"
  66
  67 /* The main body of code is in coffcode.h.  */
  68 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
  69
  70 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
  71    from smaller values.  Start with zero, widen, *then* decrement.  */
  72 #define MINUS_ONE       (((bfd_vma)0) - 1)
  73
  74 \f
  75 static reloc_howto_type mcore_coff_howto_table[] =
  76 {
  77   /* Unused: */
  78   HOWTO (IMAGE_REL_MCORE_ABSOLUTE,/* type */
  79          0,                      /* rightshift */
  80          0,                      /* size (0 = byte, 1 = short, 2 = long) */
  81          0,                      /* bitsize */
  82          false,                  /* pc_relative */
  83          0,                      /* bitpos */
  84          complain_overflow_dont, /* dont complain_on_overflow */
  85          NULL,                   /* special_function */
  86          "ABSOLUTE",             /* name */
  87          false,                  /* partial_inplace */
  88          0x00,                   /* src_mask */
  89          0x00,                   /* dst_mask */
  90          false),                 /* pcrel_offset */
  91
  92   HOWTO (IMAGE_REL_MCORE_ADDR32,/* type */
  93          0,                     /* rightshift */
  94          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  95          32,                    /* bitsize */
  96          false,                 /* pc_relative */
  97          0,                     /* bitpos */
  98          complain_overflow_bitfield, /* complain_on_overflow */
  99          NULL,                  /* special_function */
 100          "ADDR32",              /* name */
 101          true,                  /* partial_inplace */
 102          0xffffffff,            /* src_mask */
 103          0xffffffff,            /* dst_mask */
 104          false),                /* pcrel_offset */
 105
 106   /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
 107      Should not appear in object files. */
 108   HOWTO (IMAGE_REL_MCORE_PCREL_IMM8BY4, /* type */
 109          2,                     /* rightshift */
 110          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 111          8,                     /* bitsize */
 112          true,                  /* pc_relative */
 113          0,                     /* bitpos */
 114          complain_overflow_bitfield, /* complain_on_overflow */
 115          mcore_coff_unsupported_reloc, /* special_function */
 116          "IMM8BY4",             /* name */
 117          false,                 /* partial_inplace */
 118          0,                     /* src_mask */
 119          0,                     /* dst_mask */
 120          true),                 /* pcrel_offset */
 121
 122   /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
 123      Span 2k instructions == 4k bytes.
 124      Only useful pieces at the relocated address are the opcode (5 bits) */
 125   HOWTO (IMAGE_REL_MCORE_PCREL_IMM11BY2,/* type */
 126          1,                     /* rightshift */
 127          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 128          11,                    /* bitsize */
 129          true,                  /* pc_relative */
 130          0,                     /* bitpos */
 131          complain_overflow_signed, /* complain_on_overflow */
 132          NULL,                  /* special_function */
 133          "IMM11BY2",            /* name */
 134          false,                 /* partial_inplace */
 135          0x0,                   /* src_mask */
 136          0x7ff,                 /* dst_mask */
 137          true),                 /* pcrel_offset */
 138
 139   /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported. */
 140   HOWTO (IMAGE_REL_MCORE_PCREL_IMM4BY2, /* type */
 141          1,                     /* rightshift */
 142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 143          4,                     /* bitsize */
 144          true,                  /* pc_relative */
 145          0,                     /* bitpos */
 146          complain_overflow_bitfield, /* complain_on_overflow */
 147          mcore_coff_unsupported_reloc, /* special_function */
 148          "IMM4BY2",              /* name */
 149          false,                 /* partial_inplace */
 150          0,                     /* src_mask */
 151          0,                     /* dst_mask */
 152          true),                 /* pcrel_offset */
 153
 154   /* 32-bit pc-relative. Eventually this will help support PIC code. */
 155   HOWTO (IMAGE_REL_MCORE_PCREL_32,/* type */
 156          0,                     /* rightshift */
 157          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 158          32,                    /* bitsize */
 159          true,                  /* pc_relative */
 160          0,                     /* bitpos */
 161          complain_overflow_bitfield, /* complain_on_overflow */
 162          NULL,                  /* special_function */
 163          "PCREL_32",            /* name */
 164          false,                 /* partial_inplace */
 165          0x0,                   /* src_mask */
 166          0xffffffff,            /* dst_mask */
 167          true),                 /* pcrel_offset */
 168
 169   /* Like PCREL_IMM11BY2, this relocation indicates that there is a
 170      'jsri' at the specified address. There is a separate relocation
 171      entry for the literal pool entry that it references, but we
 172      might be able to change the jsri to a bsr if the target turns out
 173      to be close enough [even though we won't reclaim the literal pool
 174      entry, we'll get some runtime efficiency back]. Note that this
 175      is a relocation that we are allowed to safely ignore.  */
 176   HOWTO (IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2,/* type */
 177          1,                     /* rightshift */
 178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 179          11,                    /* bitsize */
 180          true,                  /* pc_relative */
 181          0,                     /* bitpos */
 182          complain_overflow_signed, /* complain_on_overflow */
 183          NULL,                  /* special_function */
 184          "JSR_IMM11BY2",        /* name */
 185          false,                 /* partial_inplace */
 186          0x0,                   /* src_mask */
 187          0x7ff,                 /* dst_mask */
 188          true),                 /* pcrel_offset */
 189
 190   HOWTO (IMAGE_REL_MCORE_RVA,   /* type */
 191          0,                     /* rightshift */
 192          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 193          32,                    /* bitsize */
 194          false,                 /* pc_relative */
 195          0,                     /* bitpos */
 196          complain_overflow_signed, /* complain_on_overflow */
 197          NULL,                  /* special_function */
 198          "MCORE_RVA",           /* name */
 199          true,                  /* partial_inplace */
 200          0xffffffff,            /* src_mask */
 201          0xffffffff,            /* dst_mask */
 202          true)                  /* pcrel_offset */
 203 };
 204 \f
 205 /* Extend the coff_link_hash_table structure with a few M*Core specific fields.
 206    This allows us to store global data here without actually creating any
 207    global variables, which is a no-no in the BFD world.  */
 208 typedef struct coff_mcore_link_hash_table
 209 {
 210   /* The original coff_link_hash_table structure.  MUST be first field.  */
 211   struct coff_link_hash_table   root;
 212
 213   bfd *                         bfd_of_toc_owner;
 214   long int                      global_toc_size;
 215   long int                      import_table_size;
 216   long int                      first_thunk_address;
 217   long int                      thunk_size;
 218 }
 219 mcore_hash_table;
 220
 221 /* Get the MCore coff linker hash table from a link_info structure.  */
 222 #define coff_mcore_hash_table(info) \
 223   ((mcore_hash_table *) ((info)->hash))
 224
 225 /* Create an MCore coff linker hash table.  */
 226 static struct bfd_link_hash_table *
 227 coff_mcore_link_hash_table_create (abfd)
 228      bfd * abfd;
 229 {
 230   mcore_hash_table * ret;
 231
 232   ret = ((mcore_hash_table *) bfd_alloc (abfd, sizeof (* ret)));
 233   if (ret == (mcore_hash_table *) NULL)
 234     return NULL;
 235
 236   if (! _bfd_coff_link_hash_table_init
 237       (& ret->root, abfd, _bfd_coff_link_hash_newfunc))
 238     {
 239       bfd_release (abfd, ret);
 240       return (struct bfd_link_hash_table *) NULL;
 241     }
 242
 243   ret->bfd_of_toc_owner = NULL;
 244   ret->global_toc_size  = 0;
 245   ret->import_table_size = 0;
 246   ret->first_thunk_address = 0;
 247   ret->thunk_size = 0;
 248
 249   return & ret->root.root;
 250 }
 251 \f
 252 /*ARGSUSED*/
 253 static bfd_reloc_status_type
 254 mcore_coff_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
 255                            output_bfd, error_message)
 256      bfd * abfd;
 257      arelent * reloc_entry;
 258      asymbol * symbol;
 259      PTR data;
 260      asection * input_section;
 261      bfd * output_bfd;
 262      char ** error_message;
 263 {
 264   BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
 265
 266   _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
 267                       bfd_get_filename (abfd),
 268                       reloc_entry->howto->name,
 269                       reloc_entry->howto->type);
 270
 271   return bfd_reloc_notsupported;
 272 }
 273
 274 \f
 275 /* A cheesy little macro to make the code a little more readable. */
 276 #define HOW2MAP(bfd_rtype, mcore_rtype)  \
 277  case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]
 278
 279 static reloc_howto_type *
 280 mcore_coff_reloc_type_lookup (abfd, code)
 281      bfd * abfd;
 282      bfd_reloc_code_real_type code;
 283 {
 284   switch (code)
 285     {
 286       HOW2MAP (BFD_RELOC_32,                       IMAGE_REL_MCORE_ADDR32);
 287       HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM8BY4,      IMAGE_REL_MCORE_PCREL_IMM8BY4);
 288       HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM11BY2,     IMAGE_REL_MCORE_PCREL_IMM11BY2);
 289       HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM4BY2,      IMAGE_REL_MCORE_PCREL_IMM4BY2);
 290       HOW2MAP (BFD_RELOC_32_PCREL,                 IMAGE_REL_MCORE_PCREL_32);
 291       HOW2MAP (BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2);
 292       HOW2MAP (BFD_RELOC_RVA,                      IMAGE_REL_MCORE_RVA);
 293    default:
 294       return NULL;
 295     }
 296   /*NOTREACHED*/
 297 }
 298
 299 #undef HOW2MAP
 300
 301 #define RTYPE2HOWTO(cache_ptr, dst) \
 302   (cache_ptr)->howto = mcore_coff_howto_table + (dst)->r_type;
 303
 304 static reloc_howto_type *
 305 coff_mcore_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
 306      bfd * abfd;
 307      asection * sec;
 308      struct internal_reloc * rel;
 309      struct coff_link_hash_entry * h;
 310      struct internal_syment * sym;
 311      bfd_vma * addendp;
 312 {
 313   reloc_howto_type * howto;
 314
 315
 316   if (rel->r_type >= NUM_ELEM (mcore_coff_howto_table))
 317     return NULL;
 318
 319   howto = mcore_coff_howto_table + rel->r_type;
 320
 321   if (rel->r_type == IMAGE_REL_MCORE_RVA)
 322     * addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
 323
 324   if (howto->pc_relative)
 325     {
 326       * addendp = sec->vma - 2; /* XXX guess - is this right ? */
 327
 328       /* If the symbol is defined, then the generic code is going to
 329          add back the symbol value in order to cancel out an
 330          adjustment it made to the addend.  However, we set the addend
 331          to 0 at the start of this function.  We need to adjust here,
 332          to avoid the adjustment the generic code will make.  FIXME:
 333          This is getting a bit hackish.  */
 334       if (sym != NULL && sym->n_scnum != 0)
 335         * addendp -= sym->n_value;
 336     }
 337   else
 338     * addendp = 0;
 339
 340   return howto;
 341 }
 342 \f
 343 /* The reloc processing routine for the optimized COFF linker.  */
 344 static boolean
 345 coff_mcore_relocate_section (output_bfd, info, input_bfd, input_section,
 346                            contents, relocs, syms, sections)
 347      bfd * output_bfd;
 348      struct bfd_link_info * info;
 349      bfd * input_bfd;
 350      asection * input_section;
 351      bfd_byte * contents;
 352      struct internal_reloc * relocs;
 353      struct internal_syment * syms;
 354      asection ** sections;
 355 {
 356   struct internal_reloc * rel;
 357   struct internal_reloc * relend;
 358   boolean hihalf;
 359   bfd_vma hihalf_val;
 360
 361   /* If we are performing a relocateable link, we don't need to do a
 362      thing.  The caller will take care of adjusting the reloc
 363      addresses and symbol indices.  */
 364   if (info->relocateable)
 365     return true;
 366
 367   /* Check if we have the same endianess */
 368   if (   input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
 369       && output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
 370     {
 371       (*_bfd_error_handler)
 372         (_("%s: compiled for a %s endian system and target is %s endian.\n"),
 373          bfd_get_filename (input_bfd),
 374          bfd_big_endian (input_bfd) ? "big" : "little",
 375          bfd_big_endian (output_bfd) ? "big" : "little");
 376
 377       bfd_set_error (bfd_error_wrong_format);
 378       return false;
 379     }
 380
 381   hihalf = false;
 382   hihalf_val = 0;
 383
 384   rel = relocs;
 385   relend = rel + input_section->reloc_count;
 386
 387   for (; rel < relend; rel++)
 388     {
 389       asection *                     toc_section = NULL;
 390       bfd_vma                        relocation;
 391       long                           symndx;
 392       struct internal_syment *       sym;
 393       bfd_vma                        val;
 394       bfd_vma                        addend;
 395       bfd_reloc_status_type          rstat;
 396       bfd_byte *                     loc;
 397       unsigned short                 r_type = rel->r_type;
 398       reloc_howto_type *             howto = NULL;
 399       struct coff_link_hash_entry *  h;
 400       const char *                   my_name;
 401
 402       symndx = rel->r_symndx;
 403       loc = contents + rel->r_vaddr - input_section->vma;
 404
 405       if (symndx == -1)
 406         {
 407           h = NULL;
 408           sym = NULL;
 409         }
 410       else
 411         {
 412           h = obj_coff_sym_hashes (input_bfd)[symndx];
 413           sym = syms + symndx;
 414         }
 415
 416       /* Get the howto and initialise the addend.  */
 417       howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
 418                                        sym, & addend);
 419       if (howto == NULL)
 420         return false;
 421
 422       val = 0;
 423
 424       if (h == NULL)
 425         {
 426           if (symndx == -1)
 427             my_name = "*ABS*";
 428           else
 429             {
 430               asection * sec = sections[symndx];
 431
 432               val = (sym->n_value
 433                      + sec->output_section->vma
 434                      + sec->output_offset);
 435
 436               if (sym == NULL)
 437                 my_name = "*unknown*";
 438               else if (   sym->_n._n_n._n_zeroes == 0
 439                        && sym->_n._n_n._n_offset != 0)
 440                 my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
 441               else
 442                 {
 443                   static char buf [SYMNMLEN + 1];
 444
 445                   strncpy (buf, sym->_n._n_name, SYMNMLEN);
 446                   buf[SYMNMLEN] = '\0';
 447                   my_name = buf;
 448                 }
 449             }
 450         }
 451       else
 452         {
 453           if (   h->root.type == bfd_link_hash_defined
 454               || h->root.type == bfd_link_hash_defweak)
 455             {
 456               asection * sec = h->root.u.def.section;
 457
 458               val = (h->root.u.def.value
 459                      + sec->output_section->vma
 460                      + sec->output_offset);
 461             }
 462           else
 463             {
 464               if (! ((*info->callbacks->undefined_symbol)
 465                      (info, h->root.root.string, input_bfd, input_section,
 466                       rel->r_vaddr - input_section->vma)))
 467                 return false;
 468             }
 469
 470           my_name = h->root.root.string;
 471         }
 472
 473       rstat = bfd_reloc_ok;
 474
 475       /* Each case must do its own relocation, setting rstat appropriately.  */
 476       switch (r_type)
 477         {
 478         default:
 479           _bfd_error_handler (_("%s: unsupported relocation type 0x%02x"),
 480                               bfd_get_filename (input_bfd), r_type);
 481           bfd_set_error (bfd_error_bad_value);
 482           return false;
 483
 484         case IMAGE_REL_MCORE_ABSOLUTE:
 485           fprintf (stderr,
 486                    _("Warning: unsupported reloc %s <file %s, section %s>\n"),
 487                    howto->name,
 488                    bfd_get_filename (input_bfd),
 489                    input_section->name);
 490
 491           fprintf (stderr,"sym %ld (%s), r_vaddr %ld (%lx)\n",
 492                    rel->r_symndx, my_name, (long) rel->r_vaddr,
 493                    (unsigned long) rel->r_vaddr);
 494           break;
 495
 496         case IMAGE_REL_MCORE_PCREL_IMM8BY4:
 497         case IMAGE_REL_MCORE_PCREL_IMM11BY2:
 498         case IMAGE_REL_MCORE_PCREL_IMM4BY2:
 499         case IMAGE_REL_MCORE_PCREL_32:
 500         case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
 501         case IMAGE_REL_MCORE_ADDR32:
 502         case IMAGE_REL_MCORE_RVA:
 503           rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
 504           break;
 505         }
 506
 507       switch (rstat)
 508         {
 509         default:
 510           abort ();
 511
 512         case bfd_reloc_ok:
 513           break;
 514
 515         case bfd_reloc_overflow:
 516           if (! ((*info->callbacks->reloc_overflow)
 517                  (info, my_name, howto->name,
 518                   (bfd_vma) 0, input_bfd,
 519                   input_section, rel->r_vaddr - input_section->vma)))
 520             return false;
 521         }
 522     }
 523
 524   return true;
 525 }
 526
 527 \f
 528 /* Tailor coffcode.h -- macro heaven. */
 529
 530 /* We use the special COFF backend linker, with our own special touch.  */
 531
 532 #define coff_bfd_reloc_type_lookup   mcore_coff_reloc_type_lookup
 533 #define coff_relocate_section        coff_mcore_relocate_section
 534 #define coff_rtype_to_howto          coff_mcore_rtype_to_howto
 535
 536 #define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;}
 537
 538 #define COFF_PAGE_SIZE               0x1000
 539
 540 #include "coffcode.h"
 541 \f
 542 static const bfd_target *
 543 pe_object_p (abfd)
 544      bfd * abfd;
 545 {
 546 #ifdef COFF_IMAGE_WITH_PE
 547   /* We need to hack badly to handle a PE image correctly.  In PE
 548      images created by the GNU linker, the offset to the COFF header
 549      is always the size.  However, this is not the case in images
 550      generated by other PE linkers.  The PE format stores a four byte
 551      offset to the PE signature just before the COFF header at
 552      location 0x3c of the file.  We pick up that offset, verify that
 553      the PE signature is there, and then set ourselves up to read in
 554      the COFF header.  */
 555   {
 556     bfd_byte ext_offset[4];
 557     file_ptr offset;
 558     bfd_byte ext_signature[4];
 559     unsigned long signature;
 560
 561     if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0
 562         || bfd_read (ext_offset, 1, 4, abfd) != 4)
 563       {
 564         if (bfd_get_error () != bfd_error_system_call)
 565           bfd_set_error (bfd_error_wrong_format);
 566         return NULL;
 567       }
 568
 569     offset = bfd_h_get_32 (abfd, ext_offset);
 570
 571     if (bfd_seek (abfd, offset, SEEK_SET) != 0
 572         || bfd_read (ext_signature, 1, 4, abfd) != 4)
 573       {
 574         if (bfd_get_error () != bfd_error_system_call)
 575           bfd_set_error (bfd_error_wrong_format);
 576
 577         return NULL;
 578       }
 579
 580     signature = bfd_h_get_32 (abfd, ext_signature);
 581
 582     if (signature != 0x4550)
 583       {
 584         bfd_set_error (bfd_error_wrong_format);
 585         return NULL;
 586       }
 587
 588     /* Here is the hack.  coff_object_p wants to read filhsz bytes to
 589        pick up the COFF header.  We adjust so that that will work.  20
 590        is the size of the mips COFF filehdr.  */
 591     if (bfd_seek (abfd, (bfd_tell (abfd) - bfd_coff_filhsz (abfd) + 20),
 592                   SEEK_SET) != 0)
 593       {
 594         if (bfd_get_error () != bfd_error_system_call)
 595           bfd_set_error (bfd_error_wrong_format);
 596
 597         return NULL;
 598       }
 599   }
 600 #endif
 601
 602   return coff_object_p (abfd);
 603 }
 604 \f
 605 /* The transfer vectors that lead the outside world to all of the above. */
 606
 607 const bfd_target
 608 TARGET_BIG_SYM =
 609 {
 610   TARGET_BIG_NAME,
 611   bfd_target_coff_flavour,
 612   BFD_ENDIAN_BIG,               /* data byte order is big */
 613   BFD_ENDIAN_BIG,               /* header byte order is big */
 614
 615   (HAS_RELOC | EXEC_P |         /* object flags */
 616    HAS_LINENO | HAS_DEBUG |
 617    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 618
 619   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
 620    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
 621
 622   0,                            /* leading char */
 623   '/',                          /* ar_pad_char */
 624   15,                           /* ar_max_namelen */
 625
 626   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 627   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 628   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
 629
 630   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 631   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 632   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 633
 634   { _bfd_dummy_target,
 635     pe_object_p,                /* bfd_check_format */
 636     bfd_generic_archive_p,      /* _bfd_dummy_target */
 637     pe_object_p
 638   },
 639   { bfd_false,
 640     coff_mkobject,
 641     _bfd_generic_mkarchive,     /* bfd_set_format */
 642     bfd_false
 643   },
 644   { bfd_false,
 645     coff_write_object_contents, /* bfd_write_contents */
 646     _bfd_write_archive_contents,
 647     bfd_false
 648   },
 649
 650   BFD_JUMP_TABLE_GENERIC (coff),
 651   BFD_JUMP_TABLE_COPY (coff),
 652   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 653   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 654   BFD_JUMP_TABLE_SYMBOLS (coff),
 655   BFD_JUMP_TABLE_RELOCS (coff),
 656   BFD_JUMP_TABLE_WRITE (coff),
 657   BFD_JUMP_TABLE_LINK (coff),
 658   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 659
 660   COFF_SWAP_TABLE,
 661 };
 662
 663 const bfd_target
 664 TARGET_LITTLE_SYM =
 665 {
 666   TARGET_LITTLE_NAME,
 667   bfd_target_coff_flavour,
 668   BFD_ENDIAN_LITTLE,            /* data byte order is little */
 669   BFD_ENDIAN_LITTLE,            /* header byte order is little */
 670
 671   (HAS_RELOC | EXEC_P |         /* object flags */
 672    HAS_LINENO | HAS_DEBUG |
 673    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 674
 675   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
 676    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
 677
 678   0,                            /* leading underscore */
 679   '/',                          /* ar_pad_char */
 680   15,                           /* ar_max_namelen */
 681
 682   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 683   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 684   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 685
 686   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 687   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 688   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 689
 690 /* Note that we allow an object file to be treated as a core file as well. */
 691   {
 692     _bfd_dummy_target,
 693     pe_object_p,                /* bfd_check_format */
 694     bfd_generic_archive_p,
 695     pe_object_p
 696   },
 697   {
 698     bfd_false,
 699     coff_mkobject,
 700     _bfd_generic_mkarchive,     /* bfd_set_format */
 701     bfd_false
 702   },
 703   {
 704     bfd_false,
 705     coff_write_object_contents, /* bfd_write_contents */
 706     _bfd_write_archive_contents,
 707     bfd_false
 708   },
 709
 710   BFD_JUMP_TABLE_GENERIC (coff),
 711   BFD_JUMP_TABLE_COPY (coff),
 712   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 713   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 714   BFD_JUMP_TABLE_SYMBOLS (coff),
 715   BFD_JUMP_TABLE_RELOCS (coff),
 716   BFD_JUMP_TABLE_WRITE (coff),
 717   BFD_JUMP_TABLE_LINK (coff),
 718   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 719
 720   COFF_SWAP_TABLE,
 721 };
 722