as.c revision 104834 
1/* as.c - GAS main program.
2   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3   1999, 2000, 2001, 2002
4   Free Software Foundation, Inc.
5
6   This file is part of GAS, the GNU Assembler.
7
8   GAS is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2, or (at your option)
11   any later version.
12
13   GAS is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with GAS; see the file COPYING.  If not, write to the Free
20   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21   02111-1307, USA.  */
22
23/* Main program for AS; a 32-bit assembler of GNU.
24 * Understands command arguments.
25 * Has a few routines that don't fit in other modules because they
26 * are shared.
27 *
28 *			bugs
29 *
30 * : initialisers
31 *	Since no-one else says they will support them in future: I
32 * don't support them now.
33 */
34
35#include "ansidecl.h"
36
37#define COMMON
38
39#include "as.h"
40#include "subsegs.h"
41#include "output-file.h"
42#include "sb.h"
43#include "macro.h"
44#include "dwarf2dbg.h"
45
46#ifdef HAVE_ITBL_CPU
47#include "itbl-ops.h"
48#else
49#define itbl_parse(itbl_file) 1
50#define itbl_init()
51#endif
52
53#ifdef HAVE_SBRK
54#ifdef NEED_DECLARATION_SBRK
55extern PTR sbrk ();
56#endif
57#endif
58
59static void show_usage PARAMS ((FILE *));
60static void parse_args PARAMS ((int *, char ***));
61static void dump_statistics PARAMS ((void));
62static void perform_an_assembly_pass PARAMS ((int argc, char **argv));
63static int macro_expr PARAMS ((const char *, int, sb *, int *));
64
65/* True if a listing is wanted.  */
66int listing;
67
68/* Name of listing file.  */
69static char *listing_filename = NULL;
70
71/* Type of debugging to generate.  */
72
73enum debug_info_type debug_type = DEBUG_UNSPECIFIED;
74
75/* Maximum level of macro nesting.  */
76int max_macro_nest = 100;
77
78/* argv[0]  */
79char *myname;
80#ifdef BFD_ASSEMBLER
81segT reg_section, expr_section;
82segT text_section, data_section, bss_section;
83#endif
84
85/* The default obstack chunk size.  If we set this to zero, the
86   obstack code will use whatever will fit in a 4096 byte block.  */
87int chunksize = 0;
88
89/* To monitor memory allocation more effectively, make this non-zero.
90   Then the chunk sizes for gas and bfd will be reduced.  */
91int debug_memory = 0;
92
93/* We build a list of defsyms as we read the options, and then define
94   them after we have initialized everything.  */
95
96struct defsym_list {
97  struct defsym_list *next;
98  char *name;
99  valueT value;
100};
101
102static struct defsym_list *defsyms;
103
104/* Keep a record of the itbl files we read in.  */
105
106struct itbl_file_list {
107  struct itbl_file_list *next;
108  char *name;
109};
110
111static struct itbl_file_list *itbl_files;
112
113#ifdef USE_EMULATIONS
114#define EMULATION_ENVIRON "AS_EMULATION"
115
116extern struct emulation mipsbelf, mipslelf, mipself;
117extern struct emulation mipsbecoff, mipslecoff, mipsecoff;
118extern struct emulation i386coff, i386elf, i386aout;
119extern struct emulation crisaout, criself;
120
121static struct emulation *const emulations[] = { EMULATIONS };
122static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]);
123
124static void select_emulation_mode PARAMS ((int, char **));
125
126static void
127select_emulation_mode (argc, argv)
128     int argc;
129     char **argv;
130{
131  int i;
132  char *p, *em = 0;
133
134  for (i = 1; i < argc; i++)
135    if (!strncmp ("--em", argv[i], 4))
136      break;
137
138  if (i == argc)
139    goto do_default;
140
141  p = strchr (argv[i], '=');
142  if (p)
143    p++;
144  else
145    p = argv[i + 1];
146
147  if (!p || !*p)
148    as_fatal (_("missing emulation mode name"));
149  em = p;
150
151 do_default:
152  if (em == 0)
153    em = getenv (EMULATION_ENVIRON);
154  if (em == 0)
155    em = DEFAULT_EMULATION;
156
157  if (em)
158    {
159      for (i = 0; i < n_emulations; i++)
160	if (!strcmp (emulations[i]->name, em))
161	  break;
162      if (i == n_emulations)
163	as_fatal (_("unrecognized emulation name `%s'"), em);
164      this_emulation = emulations[i];
165    }
166  else
167    this_emulation = emulations[0];
168
169  this_emulation->init ();
170}
171
172const char *
173default_emul_bfd_name ()
174{
175  abort ();
176  return NULL;
177}
178
179void
180common_emul_init ()
181{
182  this_format = this_emulation->format;
183
184  if (this_emulation->leading_underscore == 2)
185    this_emulation->leading_underscore = this_format->dfl_leading_underscore;
186
187  if (this_emulation->default_endian != 2)
188    target_big_endian = this_emulation->default_endian;
189
190  if (this_emulation->fake_label_name == 0)
191    {
192      if (this_emulation->leading_underscore)
193	this_emulation->fake_label_name = "L0\001";
194      else
195	/* What other parameters should we test?  */
196	this_emulation->fake_label_name = ".L0\001";
197    }
198}
199#endif
200
201void
202print_version_id ()
203{
204  static int printed;
205  if (printed)
206    return;
207  printed = 1;
208
209#ifdef BFD_ASSEMBLER
210  fprintf (stderr, _("GNU assembler version %s (%s) using BFD version %s"),
211	   VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
212#else
213  fprintf (stderr, _("GNU assembler version %s (%s)"), VERSION, TARGET_ALIAS);
214#endif
215  fprintf (stderr, "\n");
216}
217
218static void
219show_usage (stream)
220     FILE *stream;
221{
222  fprintf (stream, _("Usage: %s [option...] [asmfile...]\n"), myname);
223
224  fprintf (stream, _("\
225Options:\n\
226  -a[sub-option...]	  turn on listings\n\
227                      	  Sub-options [default hls]:\n\
228                      	  c      omit false conditionals\n\
229                      	  d      omit debugging directives\n\
230                      	  h      include high-level source\n\
231                      	  l      include assembly\n\
232                      	  m      include macro expansions\n\
233                      	  n      omit forms processing\n\
234                      	  s      include symbols\n\
235                      	  =FILE  list to FILE (must be last sub-option)\n"));
236
237  fprintf (stream, _("\
238  -D                      produce assembler debugging messages\n"));
239  fprintf (stream, _("\
240  --defsym SYM=VAL        define symbol SYM to given value\n"));
241#ifdef USE_EMULATIONS
242  {
243    int i;
244    char *def_em;
245
246    fprintf (stream, "\
247  --em=[");
248    for (i = 0; i < n_emulations - 1; i++)
249      fprintf (stream, "%s | ", emulations[i]->name);
250    fprintf (stream, "%s]\n", emulations[i]->name);
251
252    def_em = getenv (EMULATION_ENVIRON);
253    if (!def_em)
254      def_em = DEFAULT_EMULATION;
255    fprintf (stream, _("\
256                          emulate output (default %s)\n"), def_em);
257  }
258#endif
259  fprintf (stream, _("\
260  -f                      skip whitespace and comment preprocessing\n"));
261  fprintf (stream, _("\
262  --gstabs                generate stabs debugging information\n"));
263  fprintf (stream, _("\
264  --gdwarf2               generate DWARF2 debugging information\n"));
265  fprintf (stream, _("\
266  --help                  show this message and exit\n"));
267  fprintf (stream, _("\
268  --target-help           show target specific options\n"));
269  fprintf (stream, _("\
270  -I DIR                  add DIR to search list for .include directives\n"));
271  fprintf (stream, _("\
272  -J                      don't warn about signed overflow\n"));
273  fprintf (stream, _("\
274  -K                      warn when differences altered for long displacements\n"));
275  fprintf (stream, _("\
276  -L,--keep-locals        keep local symbols (e.g. starting with `L')\n"));
277  fprintf (stream, _("\
278  -M,--mri                assemble in MRI compatibility mode\n"));
279  fprintf (stream, _("\
280  --MD FILE               write dependency information in FILE (default none)\n"));
281  fprintf (stream, _("\
282  -nocpp                  ignored\n"));
283  fprintf (stream, _("\
284  -o OBJFILE              name the object-file output OBJFILE (default a.out)\n"));
285  fprintf (stream, _("\
286  -R                      fold data section into text section\n"));
287  fprintf (stream, _("\
288  --statistics            print various measured statistics from execution\n"));
289  fprintf (stream, _("\
290  --strip-local-absolute  strip local absolute symbols\n"));
291  fprintf (stream, _("\
292  --traditional-format    Use same format as native assembler when possible\n"));
293  fprintf (stream, _("\
294  --version               print assembler version number and exit\n"));
295  fprintf (stream, _("\
296  -W  --no-warn           suppress warnings\n"));
297  fprintf (stream, _("\
298  --warn                  don't suppress warnings\n"));
299  fprintf (stream, _("\
300  --fatal-warnings        treat warnings as errors\n"));
301  fprintf (stream, _("\
302  --itbl INSTTBL          extend instruction set to include instructions\n\
303                          matching the specifications defined in file INSTTBL\n"));
304  fprintf (stream, _("\
305  -w                      ignored\n"));
306  fprintf (stream, _("\
307  -X                      ignored\n"));
308  fprintf (stream, _("\
309  -Z                      generate object file even after errors\n"));
310  fprintf (stream, _("\
311  --listing-lhs-width     set the width in words of the output data column of\n\
312                          the listing\n"));
313  fprintf (stream, _("\
314  --listing-lhs-width2    set the width in words of the continuation lines\n\
315                          of the output data column; ignored if smaller than\n\
316                          the width of the first line\n"));
317  fprintf (stream, _("\
318  --listing-rhs-width     set the max width in characters of the lines from\n\
319                          the source file\n"));
320  fprintf (stream, _("\
321  --listing-cont-lines    set the maximum number of continuation lines used\n\
322                          for the output data column of the listing\n"));
323
324  md_show_usage (stream);
325
326  fputc ('\n', stream);
327  fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
328}
329
330/* Since it is easy to do here we interpret the special arg "-"
331   to mean "use stdin" and we set that argv[] pointing to "".
332   After we have munged argv[], the only things left are source file
333   name(s) and ""(s) denoting stdin. These file names are used
334   (perhaps more than once) later.
335
336   check for new machine-dep cmdline options in
337   md_parse_option definitions in config/tc-*.c.  */
338
339static void
340parse_args (pargc, pargv)
341     int *pargc;
342     char ***pargv;
343{
344  int old_argc, new_argc;
345  char **old_argv, **new_argv;
346
347  /* Starting the short option string with '-' is for programs that
348     expect options and other ARGV-elements in any order and that care about
349     the ordering of the two.  We describe each non-option ARGV-element
350     as if it were the argument of an option with character code 1.  */
351
352  char *shortopts;
353  extern const char *md_shortopts;
354  static const char std_shortopts[] = {
355    '-', 'J',
356#ifndef WORKING_DOT_WORD
357    /* -K is not meaningful if .word is not being hacked.  */
358    'K',
359#endif
360    'L', 'M', 'R', 'W', 'Z', 'f', 'a', ':', ':', 'D', 'I', ':', 'o', ':',
361#ifndef VMS
362    /* -v takes an argument on VMS, so we don't make it a generic
363       option.  */
364    'v',
365#endif
366    'w', 'X',
367    /* New option for extending instruction set (see also --itbl below)  */
368    't', ':',
369    '\0'
370  };
371  struct option *longopts;
372  extern struct option md_longopts[];
373  extern size_t md_longopts_size;
374  static const struct option std_longopts[] = {
375#define OPTION_HELP (OPTION_STD_BASE)
376    {"help", no_argument, NULL, OPTION_HELP},
377    {"keep-locals", no_argument, NULL, 'L'},
378    {"mri", no_argument, NULL, 'M'},
379#define OPTION_NOCPP (OPTION_STD_BASE + 1)
380    {"nocpp", no_argument, NULL, OPTION_NOCPP},
381#define OPTION_STATISTICS (OPTION_STD_BASE + 2)
382    {"statistics", no_argument, NULL, OPTION_STATISTICS},
383#define OPTION_VERSION (OPTION_STD_BASE + 3)
384    {"version", no_argument, NULL, OPTION_VERSION},
385#define OPTION_DUMPCONFIG (OPTION_STD_BASE + 4)
386    {"dump-config", no_argument, NULL, OPTION_DUMPCONFIG},
387#define OPTION_VERBOSE (OPTION_STD_BASE + 5)
388    {"verbose", no_argument, NULL, OPTION_VERBOSE},
389#define OPTION_EMULATION (OPTION_STD_BASE + 6)
390    {"emulation", required_argument, NULL, OPTION_EMULATION},
391#define OPTION_DEFSYM (OPTION_STD_BASE + 7)
392    {"defsym", required_argument, NULL, OPTION_DEFSYM},
393#define OPTION_INSTTBL (OPTION_STD_BASE + 8)
394    /* New option for extending instruction set (see also -t above).
395       The "-t file" or "--itbl file" option extends the basic set of
396       valid instructions by reading "file", a text file containing a
397       list of instruction formats.  The additional opcodes and their
398       formats are added to the built-in set of instructions, and
399       mnemonics for new registers may also be defined.  */
400    {"itbl", required_argument, NULL, OPTION_INSTTBL},
401#define OPTION_LISTING_LHS_WIDTH (OPTION_STD_BASE + 9)
402    {"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH},
403#define OPTION_LISTING_LHS_WIDTH2 (OPTION_STD_BASE + 10)
404    {"listing-lhs-width2", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2},
405#define OPTION_LISTING_RHS_WIDTH (OPTION_STD_BASE + 11)
406    {"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH},
407#define OPTION_LISTING_CONT_LINES (OPTION_STD_BASE + 12)
408    {"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES},
409#define OPTION_DEPFILE (OPTION_STD_BASE + 13)
410    {"MD", required_argument, NULL, OPTION_DEPFILE},
411#define OPTION_GSTABS (OPTION_STD_BASE + 14)
412    {"gstabs", no_argument, NULL, OPTION_GSTABS},
413#define OPTION_STRIP_LOCAL_ABSOLUTE (OPTION_STD_BASE + 15)
414    {"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE},
415#define OPTION_TRADITIONAL_FORMAT (OPTION_STD_BASE + 16)
416    {"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT},
417#define OPTION_GDWARF2 (OPTION_STD_BASE + 17)
418    {"gdwarf2", no_argument, NULL, OPTION_GDWARF2},
419    {"no-warn", no_argument, NULL, 'W'},
420#define OPTION_WARN (OPTION_STD_BASE + 18)
421    {"warn", no_argument, NULL, OPTION_WARN},
422#define OPTION_TARGET_HELP (OPTION_STD_BASE + 19)
423    {"target-help", no_argument, NULL, OPTION_TARGET_HELP},
424#define OPTION_WARN_FATAL (OPTION_STD_BASE + 20)
425    {"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
426    /* When you add options here, check that they do not collide with
427       OPTION_MD_BASE.  See as.h.  */
428  };
429
430  /* Construct the option lists from the standard list and the target
431     dependent list.  Include space for an extra NULL option and
432     always NULL terminate.  */
433  shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
434  longopts = (struct option *) xmalloc (sizeof (std_longopts)
435					+ md_longopts_size
436					+ sizeof (struct option));
437  memcpy (longopts, std_longopts, sizeof (std_longopts));
438  memcpy ((char *) longopts + sizeof (std_longopts),
439	  md_longopts, md_longopts_size);
440  memset ((char *) longopts + sizeof (std_longopts) + md_longopts_size,
441	  0, sizeof (struct option));
442
443  /* Make a local copy of the old argv.  */
444  old_argc = *pargc;
445  old_argv = *pargv;
446
447  /* Initialize a new argv that contains no options.  */
448  new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1));
449  new_argv[0] = old_argv[0];
450  new_argc = 1;
451  new_argv[new_argc] = NULL;
452
453  while (1)
454    {
455      /* getopt_long_only is like getopt_long, but '-' as well as '--' can
456	 indicate a long option.  */
457      int longind;
458      int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
459				   &longind);
460
461      if (optc == -1)
462	break;
463
464      switch (optc)
465	{
466	default:
467	  /* md_parse_option should return 1 if it recognizes optc,
468	     0 if not.  */
469	  if (md_parse_option (optc, optarg) != 0)
470	    break;
471	  /* `-v' isn't included in the general short_opts list, so check for
472	     it explicity here before deciding we've gotten a bad argument.  */
473	  if (optc == 'v')
474	    {
475#ifdef VMS
476	      /* Telling getopt to treat -v's value as optional can result
477		 in it picking up a following filename argument here.  The
478		 VMS code in md_parse_option can return 0 in that case,
479		 but it has no way of pushing the filename argument back.  */
480	      if (optarg && *optarg)
481		new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL;
482	      else
483#else
484	      case 'v':
485#endif
486	      case OPTION_VERBOSE:
487		print_version_id ();
488	      break;
489	    }
490	  /* Fall through.  */
491
492	case '?':
493	  exit (EXIT_FAILURE);
494
495	case 1:			/* File name.  */
496	  if (!strcmp (optarg, "-"))
497	    optarg = "";
498	  new_argv[new_argc++] = optarg;
499	  new_argv[new_argc] = NULL;
500	  break;
501
502	case OPTION_TARGET_HELP:
503	  md_show_usage (stdout);
504	  exit (EXIT_SUCCESS);
505
506	case OPTION_HELP:
507	  show_usage (stdout);
508	  exit (EXIT_SUCCESS);
509
510	case OPTION_NOCPP:
511	  break;
512
513	case OPTION_STATISTICS:
514	  flag_print_statistics = 1;
515	  break;
516
517	case OPTION_STRIP_LOCAL_ABSOLUTE:
518	  flag_strip_local_absolute = 1;
519	  break;
520
521	case OPTION_TRADITIONAL_FORMAT:
522	  flag_traditional_format = 1;
523	  break;
524
525	case OPTION_VERSION:
526	  /* This output is intended to follow the GNU standards document.  */
527#ifdef BFD_ASSEMBLER
528	  printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
529#else
530	  printf (_("GNU assembler %s\n"), VERSION);
531#endif
532	  printf (_("Copyright 2002 Free Software Foundation, Inc.\n"));
533	  printf (_("\
534This program is free software; you may redistribute it under the terms of\n\
535the GNU General Public License.  This program has absolutely no warranty.\n"));
536	  printf (_("This assembler was configured for a target of `%s'.\n"),
537		  TARGET_ALIAS);
538	  exit (EXIT_SUCCESS);
539
540	case OPTION_EMULATION:
541#ifdef USE_EMULATIONS
542	  if (strcmp (optarg, this_emulation->name))
543	    as_fatal (_("multiple emulation names specified"));
544#else
545	  as_fatal (_("emulations not handled in this configuration"));
546#endif
547	  break;
548
549	case OPTION_DUMPCONFIG:
550	  fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
551	  fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
552	  fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
553#ifdef TARGET_OBJ_FORMAT
554	  fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
555#endif
556#ifdef TARGET_FORMAT
557	  fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
558#endif
559	  exit (EXIT_SUCCESS);
560
561	case OPTION_DEFSYM:
562	  {
563	    char *s;
564	    valueT i;
565	    struct defsym_list *n;
566
567	    for (s = optarg; *s != '\0' && *s != '='; s++)
568	      ;
569	    if (*s == '\0')
570	      as_fatal (_("bad defsym; format is --defsym name=value"));
571	    *s++ = '\0';
572#ifdef BFD_ASSEMBLER
573	    i = bfd_scan_vma (s, (const char **) NULL, 0);
574#else
575	    i = strtol (s, (char **) NULL, 0);
576#endif
577	    n = (struct defsym_list *) xmalloc (sizeof *n);
578	    n->next = defsyms;
579	    n->name = optarg;
580	    n->value = i;
581	    defsyms = n;
582	  }
583	  break;
584
585	case OPTION_INSTTBL:
586	case 't':
587	  {
588	    /* optarg is the name of the file containing the instruction
589	       formats, opcodes, register names, etc.  */
590	    struct itbl_file_list *n;
591
592	    if (optarg == NULL)
593	      {
594		as_warn (_("no file name following -t option"));
595		break;
596	      }
597
598	    n = (struct itbl_file_list *) xmalloc (sizeof *n);
599	    n->next = itbl_files;
600	    n->name = optarg;
601	    itbl_files = n;
602
603	    /* Parse the file and add the new instructions to our internal
604	       table.  If multiple instruction tables are specified, the
605	       information from this table gets appended onto the existing
606	       internal table.  */
607	    itbl_files->name = xstrdup (optarg);
608	    if (itbl_parse (itbl_files->name) != 0)
609	      as_fatal (_("failed to read instruction table %s\n"),
610			itbl_files->name);
611	  }
612	  break;
613
614	case OPTION_DEPFILE:
615	  start_dependencies (optarg);
616	  break;
617
618	case OPTION_GSTABS:
619	  debug_type = DEBUG_STABS;
620	  break;
621
622	case OPTION_GDWARF2:
623	  debug_type = DEBUG_DWARF2;
624	  break;
625
626	case 'J':
627	  flag_signed_overflow_ok = 1;
628	  break;
629
630#ifndef WORKING_DOT_WORD
631	case 'K':
632	  flag_warn_displacement = 1;
633	  break;
634#endif
635
636	case 'L':
637	  flag_keep_locals = 1;
638	  break;
639
640	case OPTION_LISTING_LHS_WIDTH:
641	  listing_lhs_width = atoi (optarg);
642	  if (listing_lhs_width_second < listing_lhs_width)
643	    listing_lhs_width_second = listing_lhs_width;
644	  break;
645	case OPTION_LISTING_LHS_WIDTH2:
646	  {
647	    int tmp = atoi (optarg);
648	    if (tmp > listing_lhs_width)
649	      listing_lhs_width_second = tmp;
650	  }
651	  break;
652	case OPTION_LISTING_RHS_WIDTH:
653	  listing_rhs_width = atoi (optarg);
654	  break;
655	case OPTION_LISTING_CONT_LINES:
656	  listing_lhs_cont_lines = atoi (optarg);
657	  break;
658
659	case 'M':
660	  flag_mri = 1;
661#ifdef TC_M68K
662	  flag_m68k_mri = 1;
663#endif
664	  break;
665
666	case 'R':
667	  flag_readonly_data_in_text = 1;
668	  break;
669
670	case 'W':
671	  flag_no_warnings = 1;
672	  break;
673
674	case OPTION_WARN:
675	  flag_no_warnings = 0;
676	  flag_fatal_warnings = 0;
677	  break;
678
679	case OPTION_WARN_FATAL:
680	  flag_no_warnings = 0;
681	  flag_fatal_warnings = 1;
682	  break;
683
684	case 'Z':
685	  flag_always_generate_output = 1;
686	  break;
687
688	case 'a':
689	  if (optarg)
690	    {
691	      if (md_parse_option (optc, optarg) != 0)
692		break;
693
694	      while (*optarg)
695		{
696		  switch (*optarg)
697		    {
698		    case 'c':
699		      listing |= LISTING_NOCOND;
700		      break;
701		    case 'd':
702		      listing |= LISTING_NODEBUG;
703		      break;
704		    case 'h':
705		      listing |= LISTING_HLL;
706		      break;
707		    case 'l':
708		      listing |= LISTING_LISTING;
709		      break;
710		    case 'm':
711		      listing |= LISTING_MACEXP;
712		      break;
713		    case 'n':
714		      listing |= LISTING_NOFORM;
715		      break;
716		    case 's':
717		      listing |= LISTING_SYMBOLS;
718		      break;
719		    case '=':
720		      listing_filename = xstrdup (optarg + 1);
721		      optarg += strlen (listing_filename);
722		      break;
723		    default:
724		      as_fatal (_("invalid listing option `%c'"), *optarg);
725		      break;
726		    }
727		  optarg++;
728		}
729	    }
730	  if (!listing)
731	    listing = LISTING_DEFAULT;
732	  break;
733
734	case 'D':
735	  /* DEBUG is implemented: it debugs different
736	     things from other people's assemblers.  */
737	  flag_debug = 1;
738	  break;
739
740	case 'f':
741	  flag_no_comments = 1;
742	  break;
743
744	case 'I':
745	  {			/* Include file directory.  */
746	    char *temp = xstrdup (optarg);
747	    add_include_dir (temp);
748	    break;
749	  }
750
751	case 'o':
752	  out_file_name = xstrdup (optarg);
753	  break;
754
755	case 'w':
756	  break;
757
758	case 'X':
759	  /* -X means treat warnings as errors.  */
760	  break;
761	}
762    }
763
764  free (shortopts);
765  free (longopts);
766
767  *pargc = new_argc;
768  *pargv = new_argv;
769
770#ifdef md_after_parse_args
771  md_after_parse_args ();
772#endif
773}
774
775static long start_time;
776
777int main PARAMS ((int, char **));
778
779int
780main (argc, argv)
781     int argc;
782     char **argv;
783{
784  int macro_alternate;
785  int macro_strip_at;
786  int keep_it;
787
788  start_time = get_run_time ();
789
790#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
791  setlocale (LC_MESSAGES, "");
792#endif
793#if defined (HAVE_SETLOCALE)
794  setlocale (LC_CTYPE, "");
795#endif
796  bindtextdomain (PACKAGE, LOCALEDIR);
797  textdomain (PACKAGE);
798
799  if (debug_memory)
800    chunksize = 64;
801
802#ifdef HOST_SPECIAL_INIT
803  HOST_SPECIAL_INIT (argc, argv);
804#endif
805
806  myname = argv[0];
807  xmalloc_set_program_name (myname);
808
809  START_PROGRESS (myname, 0);
810
811#ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
812#define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
813#endif
814
815  out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
816
817  hex_init ();
818#ifdef BFD_ASSEMBLER
819  bfd_init ();
820  bfd_set_error_program_name (myname);
821#endif
822
823#ifdef USE_EMULATIONS
824  select_emulation_mode (argc, argv);
825#endif
826
827  PROGRESS (1);
828  symbol_begin ();
829  frag_init ();
830  subsegs_begin ();
831  parse_args (&argc, &argv);
832  read_begin ();
833  input_scrub_begin ();
834  expr_begin ();
835
836  if (flag_print_statistics)
837    xatexit (dump_statistics);
838
839  macro_alternate = 0;
840  macro_strip_at = 0;
841#ifdef TC_I960
842  macro_strip_at = flag_mri;
843#endif
844#ifdef TC_A29K
845  /* For compatibility with the AMD 29K family macro assembler
846     specification.  */
847  macro_alternate = 1;
848  macro_strip_at = 1;
849#endif
850
851  macro_init (macro_alternate, flag_mri, macro_strip_at, macro_expr);
852
853  PROGRESS (1);
854
855#ifdef BFD_ASSEMBLER
856  output_file_create (out_file_name);
857  assert (stdoutput != 0);
858#endif
859
860#ifdef tc_init_after_args
861  tc_init_after_args ();
862#endif
863
864  itbl_init ();
865
866  /* Now that we have fully initialized, and have created the output
867     file, define any symbols requested by --defsym command line
868     arguments.  */
869  while (defsyms != NULL)
870    {
871      symbolS *sym;
872      struct defsym_list *next;
873
874      sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
875			&zero_address_frag);
876      symbol_table_insert (sym);
877      next = defsyms->next;
878      free (defsyms);
879      defsyms = next;
880    }
881
882  PROGRESS (1);
883
884  /* Assemble it.  */
885  perform_an_assembly_pass (argc, argv);
886
887  cond_finish_check (-1);
888
889#ifdef md_end
890  md_end ();
891#endif
892
893  /* If we've been collecting dwarf2 .debug_line info, either for
894     assembly debugging or on behalf of the compiler, emit it now.  */
895  dwarf2_finish ();
896
897  if (seen_at_least_1_file ()
898      && (flag_always_generate_output || had_errors () == 0))
899    keep_it = 1;
900  else
901    keep_it = 0;
902
903#if defined (BFD_ASSEMBLER) || !defined (BFD)
904  /* This used to be done at the start of write_object_file in
905     write.c, but that caused problems when doing listings when
906     keep_it was zero.  This could probably be moved above md_end, but
907     I didn't want to risk the change.  */
908  subsegs_finish ();
909#endif
910
911  if (keep_it)
912    write_object_file ();
913
914#ifndef NO_LISTING
915  listing_print (listing_filename);
916#endif
917
918#ifndef OBJ_VMS /* does its own file handling */
919#ifndef BFD_ASSEMBLER
920  if (keep_it)
921#endif
922    output_file_close (out_file_name);
923#endif
924
925  if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0)
926    as_bad (_("%d warnings, treating warnings as errors"), had_warnings ());
927
928  if (had_errors () > 0 && ! flag_always_generate_output)
929    keep_it = 0;
930
931  if (!keep_it)
932    unlink (out_file_name);
933
934  input_scrub_end ();
935
936  END_PROGRESS (myname);
937
938  /* Use xexit instead of return, because under VMS environments they
939     may not place the same interpretation on the value given.  */
940  if (had_errors () > 0)
941    xexit (EXIT_FAILURE);
942
943  /* Only generate dependency file if assembler was successful.  */
944  print_dependencies ();
945
946  xexit (EXIT_SUCCESS);
947}
948
949static void
950dump_statistics ()
951{
952#ifdef HAVE_SBRK
953  char *lim = (char *) sbrk (0);
954#endif
955  long run_time = get_run_time () - start_time;
956
957  fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
958	   myname, run_time / 1000000, run_time % 1000000);
959#ifdef HAVE_SBRK
960  fprintf (stderr, _("%s: data size %ld\n"),
961	   myname, (long) (lim - (char *) &environ));
962#endif
963
964  subsegs_print_statistics (stderr);
965  write_print_statistics (stderr);
966  symbol_print_statistics (stderr);
967  read_print_statistics (stderr);
968
969#ifdef tc_print_statistics
970  tc_print_statistics (stderr);
971#endif
972#ifdef obj_print_statistics
973  obj_print_statistics (stderr);
974#endif
975}
976
977/* Here to attempt 1 pass over each input file.
978   We scan argv[*] looking for filenames or exactly "" which is
979   shorthand for stdin. Any argv that is NULL is not a file-name.
980   We set need_pass_2 TRUE if, after this, we still have unresolved
981   expressions of the form (unknown value)+-(unknown value).
982
983   Note the un*x semantics: there is only 1 logical input file, but it
984   may be a catenation of many 'physical' input files.  */
985
986static void
987perform_an_assembly_pass (argc, argv)
988     int argc;
989     char **argv;
990{
991  int saw_a_file = 0;
992#ifdef BFD_ASSEMBLER
993  flagword applicable;
994#endif
995
996  need_pass_2 = 0;
997
998#ifndef BFD_ASSEMBLER
999#ifdef MANY_SEGMENTS
1000  {
1001    unsigned int i;
1002    for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1003      segment_info[i].fix_root = 0;
1004  }
1005  /* Create the three fixed ones.  */
1006  {
1007    segT seg;
1008
1009#ifdef TE_APOLLO
1010    seg = subseg_new (".wtext", 0);
1011#else
1012    seg = subseg_new (".text", 0);
1013#endif
1014    assert (seg == SEG_E0);
1015    seg = subseg_new (".data", 0);
1016    assert (seg == SEG_E1);
1017    seg = subseg_new (".bss", 0);
1018    assert (seg == SEG_E2);
1019#ifdef TE_APOLLO
1020    create_target_segments ();
1021#endif
1022  }
1023
1024#else /* not MANY_SEGMENTS */
1025  text_fix_root = NULL;
1026  data_fix_root = NULL;
1027  bss_fix_root = NULL;
1028#endif /* not MANY_SEGMENTS */
1029#else /* BFD_ASSEMBLER */
1030  /* Create the standard sections, and those the assembler uses
1031     internally.  */
1032  text_section = subseg_new (TEXT_SECTION_NAME, 0);
1033  data_section = subseg_new (DATA_SECTION_NAME, 0);
1034  bss_section = subseg_new (BSS_SECTION_NAME, 0);
1035  /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1036     to have relocs, otherwise we don't find out in time.  */
1037  applicable = bfd_applicable_section_flags (stdoutput);
1038  bfd_set_section_flags (stdoutput, text_section,
1039			 applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1040				       | SEC_CODE | SEC_READONLY));
1041  bfd_set_section_flags (stdoutput, data_section,
1042			 applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1043				       | SEC_DATA));
1044  bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
1045  seg_info (bss_section)->bss = 1;
1046  subseg_new (BFD_ABS_SECTION_NAME, 0);
1047  subseg_new (BFD_UND_SECTION_NAME, 0);
1048  reg_section = subseg_new ("*GAS `reg' section*", 0);
1049  expr_section = subseg_new ("*GAS `expr' section*", 0);
1050
1051#endif /* BFD_ASSEMBLER */
1052
1053  subseg_set (text_section, 0);
1054
1055  /* This may add symbol table entries, which requires having an open BFD,
1056     and sections already created, in BFD_ASSEMBLER mode.  */
1057  md_begin ();
1058
1059#ifdef obj_begin
1060  obj_begin ();
1061#endif
1062
1063  /* Skip argv[0].  */
1064  argv++;
1065  argc--;
1066
1067  while (argc--)
1068    {
1069      if (*argv)
1070	{			/* Is it a file-name argument?  */
1071	  PROGRESS (1);
1072	  saw_a_file++;
1073	  /* argv->"" if stdin desired, else->filename  */
1074	  read_a_source_file (*argv);
1075	}
1076      argv++;			/* completed that argv  */
1077    }
1078  if (!saw_a_file)
1079    read_a_source_file ("");
1080}
1081
1082/* The interface between the macro code and gas expression handling.  */
1083
1084static int
1085macro_expr (emsg, idx, in, val)
1086     const char *emsg;
1087     int idx;
1088     sb *in;
1089     int *val;
1090{
1091  char *hold;
1092  expressionS ex;
1093
1094  sb_terminate (in);
1095
1096  hold = input_line_pointer;
1097  input_line_pointer = in->ptr + idx;
1098  expression (&ex);
1099  idx = input_line_pointer - in->ptr;
1100  input_line_pointer = hold;
1101
1102  if (ex.X_op != O_constant)
1103    as_bad ("%s", emsg);
1104
1105  *val = (int) ex.X_add_number;
1106
1107  return idx;
1108}
1109