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