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