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