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