as.c revision 89857 
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	  printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
528	  printf (_("Copyright 2002 Free Software Foundation, Inc.\n"));
529	  printf (_("\
530This program is free software; you may redistribute it under the terms of\n\
531the GNU General Public License.  This program has absolutely no warranty.\n"));
532	  printf (_("This assembler was configured for a target of `%s'.\n"),
533		  TARGET_ALIAS);
534	  exit (EXIT_SUCCESS);
535
536	case OPTION_EMULATION:
537#ifdef USE_EMULATIONS
538	  if (strcmp (optarg, this_emulation->name))
539	    as_fatal (_("multiple emulation names specified"));
540#else
541	  as_fatal (_("emulations not handled in this configuration"));
542#endif
543	  break;
544
545	case OPTION_DUMPCONFIG:
546	  fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
547	  fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
548	  fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
549#ifdef TARGET_OBJ_FORMAT
550	  fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
551#endif
552#ifdef TARGET_FORMAT
553	  fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
554#endif
555	  exit (EXIT_SUCCESS);
556
557	case OPTION_DEFSYM:
558	  {
559	    char *s;
560	    valueT i;
561	    struct defsym_list *n;
562
563	    for (s = optarg; *s != '\0' && *s != '='; s++)
564	      ;
565	    if (*s == '\0')
566	      as_fatal (_("bad defsym; format is --defsym name=value"));
567	    *s++ = '\0';
568#ifdef BFD_ASSEMBLER
569	    i = bfd_scan_vma (s, (const char **) NULL, 0);
570#else
571	    i = strtol (s, (char **) NULL, 0);
572#endif
573	    n = (struct defsym_list *) xmalloc (sizeof *n);
574	    n->next = defsyms;
575	    n->name = optarg;
576	    n->value = i;
577	    defsyms = n;
578	  }
579	  break;
580
581	case OPTION_INSTTBL:
582	case 't':
583	  {
584	    /* optarg is the name of the file containing the instruction
585	       formats, opcodes, register names, etc.  */
586	    struct itbl_file_list *n;
587
588	    if (optarg == NULL)
589	      {
590		as_warn (_("no file name following -t option"));
591		break;
592	      }
593
594	    n = (struct itbl_file_list *) xmalloc (sizeof *n);
595	    n->next = itbl_files;
596	    n->name = optarg;
597	    itbl_files = n;
598
599	    /* Parse the file and add the new instructions to our internal
600	       table.  If multiple instruction tables are specified, the
601	       information from this table gets appended onto the existing
602	       internal table.  */
603	    itbl_files->name = xstrdup (optarg);
604	    if (itbl_parse (itbl_files->name) != 0)
605	      as_fatal (_("failed to read instruction table %s\n"),
606			itbl_files->name);
607	  }
608	  break;
609
610	case OPTION_DEPFILE:
611	  start_dependencies (optarg);
612	  break;
613
614	case OPTION_GSTABS:
615	  debug_type = DEBUG_STABS;
616	  break;
617
618	case OPTION_GDWARF2:
619	  debug_type = DEBUG_DWARF2;
620	  break;
621
622	case 'J':
623	  flag_signed_overflow_ok = 1;
624	  break;
625
626#ifndef WORKING_DOT_WORD
627	case 'K':
628	  flag_warn_displacement = 1;
629	  break;
630#endif
631
632	case 'L':
633	  flag_keep_locals = 1;
634	  break;
635
636	case OPTION_LISTING_LHS_WIDTH:
637	  listing_lhs_width = atoi (optarg);
638	  if (listing_lhs_width_second < listing_lhs_width)
639	    listing_lhs_width_second = listing_lhs_width;
640	  break;
641	case OPTION_LISTING_LHS_WIDTH2:
642	  {
643	    int tmp = atoi (optarg);
644	    if (tmp > listing_lhs_width)
645	      listing_lhs_width_second = tmp;
646	  }
647	  break;
648	case OPTION_LISTING_RHS_WIDTH:
649	  listing_rhs_width = atoi (optarg);
650	  break;
651	case OPTION_LISTING_CONT_LINES:
652	  listing_lhs_cont_lines = atoi (optarg);
653	  break;
654
655	case 'M':
656	  flag_mri = 1;
657#ifdef TC_M68K
658	  flag_m68k_mri = 1;
659#endif
660	  break;
661
662	case 'R':
663	  flag_readonly_data_in_text = 1;
664	  break;
665
666	case 'W':
667	  flag_no_warnings = 1;
668	  break;
669
670	case OPTION_WARN:
671	  flag_no_warnings = 0;
672	  flag_fatal_warnings = 0;
673	  break;
674
675	case OPTION_WARN_FATAL:
676	  flag_no_warnings = 0;
677	  flag_fatal_warnings = 1;
678	  break;
679
680	case 'Z':
681	  flag_always_generate_output = 1;
682	  break;
683
684	case 'a':
685	  if (optarg)
686	    {
687	      if (md_parse_option (optc, optarg) != 0)
688		break;
689
690	      while (*optarg)
691		{
692		  switch (*optarg)
693		    {
694		    case 'c':
695		      listing |= LISTING_NOCOND;
696		      break;
697		    case 'd':
698		      listing |= LISTING_NODEBUG;
699		      break;
700		    case 'h':
701		      listing |= LISTING_HLL;
702		      break;
703		    case 'l':
704		      listing |= LISTING_LISTING;
705		      break;
706		    case 'm':
707		      listing |= LISTING_MACEXP;
708		      break;
709		    case 'n':
710		      listing |= LISTING_NOFORM;
711		      break;
712		    case 's':
713		      listing |= LISTING_SYMBOLS;
714		      break;
715		    case '=':
716		      listing_filename = xstrdup (optarg + 1);
717		      optarg += strlen (listing_filename);
718		      break;
719		    default:
720		      as_fatal (_("invalid listing option `%c'"), *optarg);
721		      break;
722		    }
723		  optarg++;
724		}
725	    }
726	  if (!listing)
727	    listing = LISTING_DEFAULT;
728	  break;
729
730	case 'D':
731	  /* DEBUG is implemented: it debugs different
732	     things from other people's assemblers.  */
733	  flag_debug = 1;
734	  break;
735
736	case 'f':
737	  flag_no_comments = 1;
738	  break;
739
740	case 'I':
741	  {			/* Include file directory.  */
742	    char *temp = xstrdup (optarg);
743	    add_include_dir (temp);
744	    break;
745	  }
746
747	case 'o':
748	  out_file_name = xstrdup (optarg);
749	  break;
750
751	case 'w':
752	  break;
753
754	case 'X':
755	  /* -X means treat warnings as errors.  */
756	  break;
757	}
758    }
759
760  free (shortopts);
761  free (longopts);
762
763  *pargc = new_argc;
764  *pargv = new_argv;
765
766#ifdef md_after_parse_args
767  md_after_parse_args ();
768#endif
769}
770
771static long start_time;
772
773int main PARAMS ((int, char **));
774
775int
776main (argc, argv)
777     int argc;
778     char **argv;
779{
780  int macro_alternate;
781  int macro_strip_at;
782  int keep_it;
783
784  start_time = get_run_time ();
785
786#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
787  setlocale (LC_MESSAGES, "");
788#endif
789#if defined (HAVE_SETLOCALE)
790  setlocale (LC_CTYPE, "");
791#endif
792  bindtextdomain (PACKAGE, LOCALEDIR);
793  textdomain (PACKAGE);
794
795  if (debug_memory)
796    {
797#ifdef BFD_ASSEMBLER
798      extern long _bfd_chunksize;
799      _bfd_chunksize = 64;
800#endif
801      chunksize = 64;
802    }
803
804#ifdef HOST_SPECIAL_INIT
805  HOST_SPECIAL_INIT (argc, argv);
806#endif
807
808  myname = argv[0];
809  xmalloc_set_program_name (myname);
810
811  START_PROGRESS (myname, 0);
812
813#ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
814#define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
815#endif
816
817  out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
818
819  hex_init ();
820#ifdef BFD_ASSEMBLER
821  bfd_init ();
822  bfd_set_error_program_name (myname);
823#endif
824
825#ifdef USE_EMULATIONS
826  select_emulation_mode (argc, argv);
827#endif
828
829  PROGRESS (1);
830  symbol_begin ();
831  frag_init ();
832  subsegs_begin ();
833  parse_args (&argc, &argv);
834  read_begin ();
835  input_scrub_begin ();
836  expr_begin ();
837
838  if (flag_print_statistics)
839    xatexit (dump_statistics);
840
841  macro_alternate = 0;
842  macro_strip_at = 0;
843#ifdef TC_I960
844  macro_strip_at = flag_mri;
845#endif
846#ifdef TC_A29K
847  /* For compatibility with the AMD 29K family macro assembler
848     specification.  */
849  macro_alternate = 1;
850  macro_strip_at = 1;
851#endif
852
853  macro_init (macro_alternate, flag_mri, macro_strip_at, macro_expr);
854
855  PROGRESS (1);
856
857#ifdef BFD_ASSEMBLER
858  output_file_create (out_file_name);
859  assert (stdoutput != 0);
860#endif
861
862#ifdef tc_init_after_args
863  tc_init_after_args ();
864#endif
865
866  itbl_init ();
867
868  /* Now that we have fully initialized, and have created the output
869     file, define any symbols requested by --defsym command line
870     arguments.  */
871  while (defsyms != NULL)
872    {
873      symbolS *sym;
874      struct defsym_list *next;
875
876      sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
877			&zero_address_frag);
878      symbol_table_insert (sym);
879      next = defsyms->next;
880      free (defsyms);
881      defsyms = next;
882    }
883
884  PROGRESS (1);
885
886  /* Assemble it.  */
887  perform_an_assembly_pass (argc, argv);
888
889  cond_finish_check (-1);
890
891#ifdef md_end
892  md_end ();
893#endif
894
895  /* If we've been collecting dwarf2 .debug_line info, either for
896     assembly debugging or on behalf of the compiler, emit it now.  */
897  dwarf2_finish ();
898
899  if (seen_at_least_1_file ()
900      && (flag_always_generate_output || had_errors () == 0))
901    keep_it = 1;
902  else
903    keep_it = 0;
904
905#if defined (BFD_ASSEMBLER) || !defined (BFD)
906  /* This used to be done at the start of write_object_file in
907     write.c, but that caused problems when doing listings when
908     keep_it was zero.  This could probably be moved above md_end, but
909     I didn't want to risk the change.  */
910  subsegs_finish ();
911#endif
912
913  if (keep_it)
914    write_object_file ();
915
916#ifndef NO_LISTING
917  listing_print (listing_filename);
918#endif
919
920#ifndef OBJ_VMS /* does its own file handling */
921#ifndef BFD_ASSEMBLER
922  if (keep_it)
923#endif
924    output_file_close (out_file_name);
925#endif
926
927  if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0)
928    as_bad (_("%d warnings, treating warnings as errors"), had_warnings ());
929
930  if (had_errors () > 0 && ! flag_always_generate_output)
931    keep_it = 0;
932
933  if (!keep_it)
934    unlink (out_file_name);
935
936  input_scrub_end ();
937
938  END_PROGRESS (myname);
939
940  /* Use xexit instead of return, because under VMS environments they
941     may not place the same interpretation on the value given.  */
942  if (had_errors () > 0)
943    xexit (EXIT_FAILURE);
944
945  /* Only generate dependency file if assembler was successful.  */
946  print_dependencies ();
947
948  xexit (EXIT_SUCCESS);
949}
950
951static void
952dump_statistics ()
953{
954#ifdef HAVE_SBRK
955  char *lim = (char *) sbrk (0);
956#endif
957  long run_time = get_run_time () - start_time;
958
959  fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
960	   myname, run_time / 1000000, run_time % 1000000);
961#ifdef HAVE_SBRK
962  fprintf (stderr, _("%s: data size %ld\n"),
963	   myname, (long) (lim - (char *) &environ));
964#endif
965
966  subsegs_print_statistics (stderr);
967  write_print_statistics (stderr);
968  symbol_print_statistics (stderr);
969  read_print_statistics (stderr);
970
971#ifdef tc_print_statistics
972  tc_print_statistics (stderr);
973#endif
974#ifdef obj_print_statistics
975  obj_print_statistics (stderr);
976#endif
977}
978
979/* Here to attempt 1 pass over each input file.
980   We scan argv[*] looking for filenames or exactly "" which is
981   shorthand for stdin. Any argv that is NULL is not a file-name.
982   We set need_pass_2 TRUE if, after this, we still have unresolved
983   expressions of the form (unknown value)+-(unknown value).
984
985   Note the un*x semantics: there is only 1 logical input file, but it
986   may be a catenation of many 'physical' input files.  */
987
988static void
989perform_an_assembly_pass (argc, argv)
990     int argc;
991     char **argv;
992{
993  int saw_a_file = 0;
994#ifdef BFD_ASSEMBLER
995  flagword applicable;
996#endif
997
998  need_pass_2 = 0;
999
1000#ifndef BFD_ASSEMBLER
1001#ifdef MANY_SEGMENTS
1002  {
1003    unsigned int i;
1004    for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1005      segment_info[i].fix_root = 0;
1006  }
1007  /* Create the three fixed ones.  */
1008  {
1009    segT seg;
1010
1011#ifdef TE_APOLLO
1012    seg = subseg_new (".wtext", 0);
1013#else
1014    seg = subseg_new (".text", 0);
1015#endif
1016    assert (seg == SEG_E0);
1017    seg = subseg_new (".data", 0);
1018    assert (seg == SEG_E1);
1019    seg = subseg_new (".bss", 0);
1020    assert (seg == SEG_E2);
1021#ifdef TE_APOLLO
1022    create_target_segments ();
1023#endif
1024  }
1025
1026#else /* not MANY_SEGMENTS */
1027  text_fix_root = NULL;
1028  data_fix_root = NULL;
1029  bss_fix_root = NULL;
1030#endif /* not MANY_SEGMENTS */
1031#else /* BFD_ASSEMBLER */
1032  /* Create the standard sections, and those the assembler uses
1033     internally.  */
1034  text_section = subseg_new (TEXT_SECTION_NAME, 0);
1035  data_section = subseg_new (DATA_SECTION_NAME, 0);
1036  bss_section = subseg_new (BSS_SECTION_NAME, 0);
1037  /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1038     to have relocs, otherwise we don't find out in time.  */
1039  applicable = bfd_applicable_section_flags (stdoutput);
1040  bfd_set_section_flags (stdoutput, text_section,
1041			 applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1042				       | SEC_CODE | SEC_READONLY));
1043  bfd_set_section_flags (stdoutput, data_section,
1044			 applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1045				       | SEC_DATA));
1046  bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
1047  seg_info (bss_section)->bss = 1;
1048  subseg_new (BFD_ABS_SECTION_NAME, 0);
1049  subseg_new (BFD_UND_SECTION_NAME, 0);
1050  reg_section = subseg_new ("*GAS `reg' section*", 0);
1051  expr_section = subseg_new ("*GAS `expr' section*", 0);
1052
1053#endif /* BFD_ASSEMBLER */
1054
1055  subseg_set (text_section, 0);
1056
1057  /* This may add symbol table entries, which requires having an open BFD,
1058     and sections already created, in BFD_ASSEMBLER mode.  */
1059  md_begin ();
1060
1061#ifdef obj_begin
1062  obj_begin ();
1063#endif
1064
1065  /* Skip argv[0].  */
1066  argv++;
1067  argc--;
1068
1069  while (argc--)
1070    {
1071      if (*argv)
1072	{			/* Is it a file-name argument?  */
1073	  PROGRESS (1);
1074	  saw_a_file++;
1075	  /* argv->"" if stdin desired, else->filename  */
1076	  read_a_source_file (*argv);
1077	}
1078      argv++;			/* completed that argv  */
1079    }
1080  if (!saw_a_file)
1081    read_a_source_file ("");
1082}
1083
1084/* The interface between the macro code and gas expression handling.  */
1085
1086static int
1087macro_expr (emsg, idx, in, val)
1088     const char *emsg;
1089     int idx;
1090     sb *in;
1091     int *val;
1092{
1093  char *hold;
1094  expressionS ex;
1095
1096  sb_terminate (in);
1097
1098  hold = input_line_pointer;
1099  input_line_pointer = in->ptr + idx;
1100  expression (&ex);
1101  idx = input_line_pointer - in->ptr;
1102  input_line_pointer = hold;
1103
1104  if (ex.X_op != O_constant)
1105    as_bad ("%s", emsg);
1106
1107  *val = (int) ex.X_add_number;
1108
1109  return idx;
1110}
1111