X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fas.c;h=0f6d4af2612f2e3251459b161160608641dcdc1d;hb=0e389e770d54185d8107db1972d3ae0576d0fa1d;hp=c183fb9b5ad36f7bf98199f5292139ff05d89dcd;hpb=ebd6f11797d7beb545cd48111210b07fdec806ce;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/as.c b/gas/as.c index c183fb9b5a..0f6d4af261 100644 --- a/gas/as.c +++ b/gas/as.c @@ -1,5 +1,7 @@ /* as.c - GAS main program. - Copyright (C) 1987, 1990, 1991, 1992, 1994 Free Software Foundation, Inc. + Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2001 + Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. @@ -14,73 +16,188 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with GAS; see the file COPYING. If not, write to - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + along with GAS; see the file COPYING. If not, write to the Free + Software Foundation, 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ -/* - * Main program for AS; a 32-bit assembler of GNU. +/* Main program for AS; a 32-bit assembler of GNU. * Understands command arguments. * Has a few routines that don't fit in other modules because they * are shared. * - * * bugs * * : initialisers * Since no-one else says they will support them in future: I * don't support them now. - * */ #include "ansidecl.h" -#include "libiberty.h" - -#include -#include - -#ifdef _POSIX_SOURCE -#include /* For pid_t in signal.h */ -#endif -#include #define COMMON #include "as.h" #include "subsegs.h" #include "output-file.h" +#include "sb.h" +#include "macro.h" +#include "dwarf2dbg.h" -#ifndef SIGTY -#ifdef __STDC__ -#define SIGTY void +#ifdef HAVE_ITBL_CPU +#include "itbl-ops.h" #else -#define SIGTY int -#endif /* __STDC__ */ -#endif /* SIGTY */ +#define itbl_parse(itbl_file) 1 +#define itbl_init() +#endif -#if 0 -/* Not currently used. */ -static SIGTY got_sig PARAMS ((int sig)); +#ifdef HAVE_SBRK +#ifdef NEED_DECLARATION_SBRK +extern PTR sbrk (); +#endif #endif + +static void show_usage PARAMS ((FILE *)); +static void parse_args PARAMS ((int *, char ***)); +static void dump_statistics PARAMS ((void)); static void perform_an_assembly_pass PARAMS ((int argc, char **argv)); +static int macro_expr PARAMS ((const char *, int, sb *, int *)); -#ifndef EXIT_SUCCESS -#define EXIT_SUCCESS 0 -#define EXIT_FAILURE 1 -#endif +/* True if a listing is wanted. */ +int listing; + +/* Name of listing file. */ +static char *listing_filename = NULL; -int listing; /* true if a listing is wanted */ +/* Type of debugging to generate. */ -char *myname; /* argv[0] */ +enum debug_info_type debug_type = DEBUG_UNSPECIFIED; + +/* Maximum level of macro nesting. */ +int max_macro_nest = 100; + +/* argv[0] */ +char *myname; #ifdef BFD_ASSEMBLER segT reg_section, expr_section; segT text_section, data_section, bss_section; #endif -/* This is true if the assembler should output time and space usage. */ +/* The default obstack chunk size. If we set this to zero, the + obstack code will use whatever will fit in a 4096 byte block. */ +int chunksize = 0; + +/* To monitor memory allocation more effectively, make this non-zero. + Then the chunk sizes for gas and bfd will be reduced. */ +int debug_memory = 0; -static int statistics_flag = 0; +/* We build a list of defsyms as we read the options, and then define + them after we have initialized everything. */ +struct defsym_list { + struct defsym_list *next; + char *name; + valueT value; +}; + +static struct defsym_list *defsyms; + +/* Keep a record of the itbl files we read in. */ + +struct itbl_file_list { + struct itbl_file_list *next; + char *name; +}; + +static struct itbl_file_list *itbl_files; +#ifdef USE_EMULATIONS +#define EMULATION_ENVIRON "AS_EMULATION" + +extern struct emulation mipsbelf, mipslelf, mipself; +extern struct emulation mipsbecoff, mipslecoff, mipsecoff; +extern struct emulation i386coff, i386elf, i386aout; +extern struct emulation crisaout, criself; + +static struct emulation *const emulations[] = { EMULATIONS }; +static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]); + +static void select_emulation_mode PARAMS ((int, char **)); + +static void +select_emulation_mode (argc, argv) + int argc; + char **argv; +{ + int i; + char *p, *em = 0; + + for (i = 1; i < argc; i++) + if (!strncmp ("--em", argv[i], 4)) + break; + + if (i == argc) + goto do_default; + + p = strchr (argv[i], '='); + if (p) + p++; + else + p = argv[i + 1]; + + if (!p || !*p) + as_fatal (_("missing emulation mode name")); + em = p; + + do_default: + if (em == 0) + em = getenv (EMULATION_ENVIRON); + if (em == 0) + em = DEFAULT_EMULATION; + + if (em) + { + for (i = 0; i < n_emulations; i++) + if (!strcmp (emulations[i]->name, em)) + break; + if (i == n_emulations) + as_fatal (_("unrecognized emulation name `%s'"), em); + this_emulation = emulations[i]; + } + else + this_emulation = emulations[0]; + + this_emulation->init (); +} + +const char * +default_emul_bfd_name () +{ + abort (); + return NULL; +} + +void +common_emul_init () +{ + this_format = this_emulation->format; + + if (this_emulation->leading_underscore == 2) + this_emulation->leading_underscore = this_format->dfl_leading_underscore; + + if (this_emulation->default_endian != 2) + target_big_endian = this_emulation->default_endian; + + if (this_emulation->fake_label_name == 0) + { + if (this_emulation->leading_underscore) + this_emulation->fake_label_name = "L0\001"; + else + /* What other parameters should we test? */ + this_emulation->fake_label_name = ".L0\001"; + } +} +#endif + void print_version_id () { @@ -89,476 +206,644 @@ print_version_id () return; printed = 1; - fprintf (stderr, "GNU assembler version %s (%s)", GAS_VERSION, TARGET_ALIAS); #ifdef BFD_ASSEMBLER - fprintf (stderr, ", using BFD version %s", BFD_VERSION); + fprintf (stderr, _("GNU assembler version %s (%s) using BFD version %s"), + VERSION, TARGET_ALIAS, BFD_VERSION); +#else + fprintf (stderr, _("GNU assembler version %s (%s)"), VERSION, TARGET_ALIAS); #endif fprintf (stderr, "\n"); } -void +static void show_usage (stream) FILE *stream; { - fprintf (stream, "Usage: %s [option...] [asmfile...]\n", myname); + fprintf (stream, _("Usage: %s [option...] [asmfile...]\n"), myname); - fprintf (stream, "\ + fprintf (stream, _("\ Options:\n\ --a[sub-option...] turn on listings\n\ - Sub-options [default hls]:\n\ - d omit debugging directives\n\ - h include high-level source\n\ - l include assembly\n\ - n omit forms processing\n\ - s include symbols\n\ --D ignored\n\ --f skip whitespace and comment preprocessing\n\ ---help show this message and exit\n\ --I DIR add DIR to search list for .include directives\n\ --J don't warn about signed overflow\n\ --K warn when differences altered for long displacements\n\ --L keep local symbols (starting with `L')\n"); - fprintf (stream, "\ --o OBJFILE name the object-file output OBJFILE [default a.out]\n\ --R fold data section into text section\n\ ---statistics print maximum bytes and total seconds used\n\ --v, -version print assembler version number\n\ ---version print assembler version number and exit\n\ --W suppress warnings\n\ --w ignored\n\ --x ignored\n\ --Z generate object file even after errors\n"); - -#ifdef TC_ALPHA - fprintf(stream, "\ -ALPHA options:\n\ --32addr treat addresses as 32-bit values\n\ --F lack floating point instructions support\n\ --nocpp ignored\n"); -#endif - -#ifdef TC_I960 - fprintf(stream, "\ -I960 options:\n\ --ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC\n\ - specify variant of 960 architecture\n\ --b add code to collect statistics about branches taken\n\ --linkrelax make relocatable instructions undefined (?)\n\ --norelax don't alter compare-and-branch instructions for\n\ - long displacements\n"); -#endif - -#ifdef TC_M68K - fprintf(stream, "\ -680X0 options:\n\ --l use 1 word for refs to undefined symbols [default 2]\n\ --m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040\n\ - | -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -mcpu32\n\ - specify variant of 680X0 architecture [default 68020]\n\ --m68881 | -m68882 | -mno-68881 | -mno-68882\n\ - target has/lacks floating-point coprocessor\n\ - [default yes for 68020, 68030, and cpu32]\n\ --m68851 | -mno-68851\n\ - target has/lacks memory-management unit coprocessor\n\ - [default yes for 68020 and up]\n\ --pic, -k (sun3) generate position independent code\n\ --S turn jbsr into jsr\n\ ---register-prefix-optional\n\ - recognize register names without prefix character\n"); -#endif - -#ifdef TC_MIPS - fprintf(stream, "\ -MIPS options:\n\ --membedded-pic generate embedded position independent code\n\ --nocpp ignored\n\ --EB generate big endian output\n\ --EL generate little endian output\n\ --g, -g2 do not remove uneeded NOPs or swap branches\n\ --G NUM allow referencing objects up to NUM bytes\n\ - implicitly with the gp register [default 8]\n\ --mips1, -mcpu=r{2,3}000 generate code for r2000 and r3000\n\ --mips2, -mcpu=r6000 generate code for r6000\n\ --mips3, -mcpu=r4000 generate code for r4000\n\ --O0 remove unneeded NOPs, do not swap branches\n\ --O remove unneeded NOPs and swap branches\n\ ---trap, --no-break trap exception on div by 0 and mult overflow\n\ ---break, --no-trap break exception on div by 0 and mult overflow\n"); -#ifdef OBJ_ELF - fprintf(stream, "\ -MIPS ELF options:\n\ --KPIC, -call_shared generate SVR4 position independent code\n\ --non_shared do not generate position independent code\n"); -#endif -#endif - -#ifdef TC_NS32K - fprintf(stream, "\ -NS32K options:\n\ --m32032 | -m32532 select variant of NS32K architecture\n"); -#endif - -#ifdef TC_PPC - fprintf(stream, "\ -PowerPC options:\n\ --u ignored\n\ --mpwrx generate code for IBM POWER/2 (RIOS2)\n\ --mpwr generate code for IBM POWER (RIOS1)\n\ --m601 generate code for Motorola PowerPC 601\n\ --mppc generate code for Motorola PowerPC 603/604\n\ --many generate code for any architecture (PWR/PWRX/PPC)\n"); -#ifdef OBJ_ELF - fprintf(stream, "\ -PowerPC ELF options:\n\ --V print assembler version number\n\ --Qy, -Qn ignored\n"); -#endif -#endif - -#ifdef TC_SH - fprintf(stream, "\ -SH options:\n\ --relax alter jump instructions for long displacements\n"); -#endif - -#ifdef TC_SPARC - fprintf(stream, "\ -SPARC options:\n\ --Av6 | -Av7 | -Av8 | -Asparclite\n\ - specify variant of SPARC architecture\n\ --bump warn when assembler switches architectures\n\ --sparc ignored\n"); -#ifdef OBJ_ELF - fprintf(stream, "\ -SPARC ELF options:\n\ --V print assembler version number\n\ --q ignored\n\ --Qy, -Qn ignored\n\ --s ignored\n"); -#endif -#endif - -#ifdef TC_TAHOE - fprintf(stream, "\ -Tahoe options:\n\ --a ignored\n\ --d LENGTH ignored\n\ --J ignored\n\ --S ignored\n\ --t FILE ignored\n\ --T ignored\n\ --V ignored\n"); -#endif - -#ifdef TC_VAX - fprintf(stream, "\ -VAX options:\n\ --d LENGTH ignored\n\ --J ignored\n\ --S ignored\n\ --t FILE ignored\n\ --T ignored\n\ --V ignored\n"); -#endif - -#ifdef TC_Z8K - fprintf(stream, "\ -Z8K options:\n\ --z8001 generate segmented code\n\ --z8002 generate unsegmented code\n"); + -a[sub-option...] turn on listings\n\ + Sub-options [default hls]:\n\ + c omit false conditionals\n\ + d omit debugging directives\n\ + h include high-level source\n\ + l include assembly\n\ + m include macro expansions\n\ + n omit forms processing\n\ + s include symbols\n\ + =FILE list to FILE (must be last sub-option)\n")); + + fprintf (stream, _("\ + -D produce assembler debugging messages\n")); + fprintf (stream, _("\ + --defsym SYM=VAL define symbol SYM to given value\n")); +#ifdef USE_EMULATIONS + { + int i; + char *def_em; + + fprintf (stream, "\ + --em=["); + for (i = 0; i < n_emulations - 1; i++) + fprintf (stream, "%s | ", emulations[i]->name); + fprintf (stream, "%s]\n", emulations[i]->name); + + def_em = getenv (EMULATION_ENVIRON); + if (!def_em) + def_em = DEFAULT_EMULATION; + fprintf (stream, _("\ + emulate output (default %s)\n"), def_em); + } #endif + fprintf (stream, _("\ + -f skip whitespace and comment preprocessing\n")); + fprintf (stream, _("\ + --gstabs generate stabs debugging information\n")); + fprintf (stream, _("\ + --gdwarf2 generate DWARF2 debugging information\n")); + fprintf (stream, _("\ + --help show this message and exit\n")); + fprintf (stream, _("\ + --target-help show target specific options\n")); + fprintf (stream, _("\ + -I DIR add DIR to search list for .include directives\n")); + fprintf (stream, _("\ + -J don't warn about signed overflow\n")); + fprintf (stream, _("\ + -K warn when differences altered for long displacements\n")); + fprintf (stream, _("\ + -L,--keep-locals keep local symbols (e.g. starting with `L')\n")); + fprintf (stream, _("\ + -M,--mri assemble in MRI compatibility mode\n")); + fprintf (stream, _("\ + --MD FILE write dependency information in FILE (default none)\n")); + fprintf (stream, _("\ + -nocpp ignored\n")); + fprintf (stream, _("\ + -o OBJFILE name the object-file output OBJFILE (default a.out)\n")); + fprintf (stream, _("\ + -R fold data section into text section\n")); + fprintf (stream, _("\ + --statistics print various measured statistics from execution\n")); + fprintf (stream, _("\ + --strip-local-absolute strip local absolute symbols\n")); + fprintf (stream, _("\ + --traditional-format Use same format as native assembler when possible\n")); + fprintf (stream, _("\ + --version print assembler version number and exit\n")); + fprintf (stream, _("\ + -W --no-warn suppress warnings\n")); + fprintf (stream, _("\ + --warn don't suppress warnings\n")); + fprintf (stream, _("\ + --fatal-warnings treat warnings as errors\n")); + fprintf (stream, _("\ + --itbl INSTTBL extend instruction set to include instructions\n\ + matching the specifications defined in file INSTTBL\n")); + fprintf (stream, _("\ + -w ignored\n")); + fprintf (stream, _("\ + -X ignored\n")); + fprintf (stream, _("\ + -Z generate object file even after errors\n")); + fprintf (stream, _("\ + --listing-lhs-width set the width in words of the output data column of\n\ + the listing\n")); + fprintf (stream, _("\ + --listing-lhs-width2 set the width in words of the continuation lines\n\ + of the output data column; ignored if smaller than\n\ + the width of the first line\n")); + fprintf (stream, _("\ + --listing-rhs-width set the max width in characters of the lines from\n\ + the source file\n")); + fprintf (stream, _("\ + --listing-cont-lines set the maximum number of continuation lines used\n\ + for the output data column of the listing\n")); + + md_show_usage (stream); + + fputc ('\n', stream); + fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); } -/* - * Parse arguments, but we are only interested in flags. - * When we find a flag, we process it then make it's argv[] NULL. - * This helps any future argv[] scanners avoid what we processed. - * Since it is easy to do here we interpret the special arg "-" - * to mean "use stdin" and we set that argv[] pointing to "". - * After we have munged argv[], the only things left are source file - * name(s) and ""(s) denoting stdin. These file names are used - * (perhaps more than once) later. - */ -/* FIXME-SOMEDAY this should use getopt. */ -/* - * check for new machine-dep cmdline options in - * md_parse_option definitions in config/tc-*.c - */ - -void -parse_args (argc, argv) - int argc; - char **argv; -{ - char *arg; /* an arg to program */ - char a; /* an arg flag (after -) */ +/* Since it is easy to do here we interpret the special arg "-" + to mean "use stdin" and we set that argv[] pointing to "". + After we have munged argv[], the only things left are source file + name(s) and ""(s) denoting stdin. These file names are used + (perhaps more than once) later. - argc--; /* don't count argv[0] */ - argv++; /* skip argv[0] */ + check for new machine-dep cmdline options in + md_parse_option definitions in config/tc-*.c. */ - for (; argc--; argv++) +static void +parse_args (pargc, pargv) + int *pargc; + char ***pargv; +{ + int old_argc, new_argc; + char **old_argv, **new_argv; + + /* Starting the short option string with '-' is for programs that + expect options and other ARGV-elements in any order and that care about + the ordering of the two. We describe each non-option ARGV-element + as if it were the argument of an option with character code 1. */ + + char *shortopts; + extern CONST char *md_shortopts; + static const char std_shortopts[] = { + '-', 'J', +#ifndef WORKING_DOT_WORD + /* -K is not meaningful if .word is not being hacked. */ + 'K', +#endif + 'L', 'M', 'R', 'W', 'Z', 'f', 'a', ':', ':', 'D', 'I', ':', 'o', ':', +#ifndef VMS + /* -v takes an argument on VMS, so we don't make it a generic + option. */ + 'v', +#endif + 'w', 'X', + /* New option for extending instruction set (see also --itbl below) */ + 't', ':', + '\0' + }; + struct option *longopts; + extern struct option md_longopts[]; + extern size_t md_longopts_size; + static const struct option std_longopts[] = { +#define OPTION_HELP (OPTION_STD_BASE) + {"help", no_argument, NULL, OPTION_HELP}, + {"keep-locals", no_argument, NULL, 'L'}, + {"mri", no_argument, NULL, 'M'}, +#define OPTION_NOCPP (OPTION_STD_BASE + 1) + {"nocpp", no_argument, NULL, OPTION_NOCPP}, +#define OPTION_STATISTICS (OPTION_STD_BASE + 2) + {"statistics", no_argument, NULL, OPTION_STATISTICS}, +#define OPTION_VERSION (OPTION_STD_BASE + 3) + {"version", no_argument, NULL, OPTION_VERSION}, +#define OPTION_DUMPCONFIG (OPTION_STD_BASE + 4) + {"dump-config", no_argument, NULL, OPTION_DUMPCONFIG}, +#define OPTION_VERBOSE (OPTION_STD_BASE + 5) + {"verbose", no_argument, NULL, OPTION_VERBOSE}, +#define OPTION_EMULATION (OPTION_STD_BASE + 6) + {"emulation", required_argument, NULL, OPTION_EMULATION}, +#define OPTION_DEFSYM (OPTION_STD_BASE + 7) + {"defsym", required_argument, NULL, OPTION_DEFSYM}, +#define OPTION_INSTTBL (OPTION_STD_BASE + 8) + /* New option for extending instruction set (see also -t above). + The "-t file" or "--itbl file" option extends the basic set of + valid instructions by reading "file", a text file containing a + list of instruction formats. The additional opcodes and their + formats are added to the built-in set of instructions, and + mnemonics for new registers may also be defined. */ + {"itbl", required_argument, NULL, OPTION_INSTTBL}, +#define OPTION_LISTING_LHS_WIDTH (OPTION_STD_BASE + 9) + {"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH}, +#define OPTION_LISTING_LHS_WIDTH2 (OPTION_STD_BASE + 10) + {"listing-lhs-width2", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2}, +#define OPTION_LISTING_RHS_WIDTH (OPTION_STD_BASE + 11) + {"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH}, +#define OPTION_LISTING_CONT_LINES (OPTION_STD_BASE + 12) + {"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES}, +#define OPTION_DEPFILE (OPTION_STD_BASE + 13) + {"MD", required_argument, NULL, OPTION_DEPFILE}, +#define OPTION_GSTABS (OPTION_STD_BASE + 14) + {"gstabs", no_argument, NULL, OPTION_GSTABS}, +#define OPTION_STRIP_LOCAL_ABSOLUTE (OPTION_STD_BASE + 15) + {"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE}, +#define OPTION_TRADITIONAL_FORMAT (OPTION_STD_BASE + 16) + {"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT}, +#define OPTION_GDWARF2 (OPTION_STD_BASE + 17) + {"gdwarf2", no_argument, NULL, OPTION_GDWARF2}, + {"no-warn", no_argument, NULL, 'W'}, +#define OPTION_WARN (OPTION_STD_BASE + 18) + {"warn", no_argument, NULL, OPTION_WARN}, +#define OPTION_TARGET_HELP (OPTION_STD_BASE + 19) + {"target-help", no_argument, NULL, OPTION_TARGET_HELP}, +#define OPTION_WARN_FATAL (OPTION_STD_BASE + 20) + {"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL} + /* When you add options here, check that they do not collide with + OPTION_MD_BASE. See as.h. */ + }; + + /* Construct the option lists from the standard list and the target + dependent list. Include space for an extra NULL option and + always NULL terminate. */ + shortopts = concat (std_shortopts, md_shortopts, (char *) NULL); + longopts = (struct option *) xmalloc (sizeof (std_longopts) + + md_longopts_size + + sizeof (struct option)); + memcpy (longopts, std_longopts, sizeof (std_longopts)); + memcpy ((char *) longopts + sizeof (std_longopts), + md_longopts, md_longopts_size); + memset ((char *) longopts + sizeof (std_longopts) + md_longopts_size, + 0, sizeof (struct option)); + + /* Make a local copy of the old argv. */ + old_argc = *pargc; + old_argv = *pargv; + + /* Initialize a new argv that contains no options. */ + new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1)); + new_argv[0] = old_argv[0]; + new_argc = 1; + new_argv[new_argc] = NULL; + + while (1) { - arg = *argv; /* argv points to this argument */ + /* getopt_long_only is like getopt_long, but '-' as well as '--' can + indicate a long option. */ + int longind; + int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts, + &longind); + + if (optc == -1) + break; - if (*arg != '-') /* Filename. We need it later. */ - continue; /* Keep scanning args looking for flags. */ - /* Handle double-dash options. */ - if (arg[1] == '-') + switch (optc) { - if (arg[2] == 0) - { - /* "--" as an argument means read stdin. */ - /* On this scan, we don't want to think about filenames. */ - *argv = ""; /* A code that means 'use stdin'. */ - } - else if (strcmp (arg, "--statistics") == 0) - { - statistics_flag = 1; - *argv = NULL; - } - else if (strcmp (arg, "--help") == 0) - { - show_usage (stdout); - exit (0); - } - else if (strcmp (arg, "--version") == 0) + default: + /* md_parse_option should return 1 if it recognizes optc, + 0 if not. */ + if (md_parse_option (optc, optarg) != 0) + break; + /* `-v' isn't included in the general short_opts list, so check for + it explicity here before deciding we've gotten a bad argument. */ + if (optc == 'v') { - print_version_id (); - exit (0); - } -#ifdef md_parse_long_option - else if (md_parse_long_option (arg)) - *argv = NULL; +#ifdef VMS + /* Telling getopt to treat -v's value as optional can result + in it picking up a following filename argument here. The + VMS code in md_parse_option can return 0 in that case, + but it has no way of pushing the filename argument back. */ + if (optarg && *optarg) + new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL; + else +#else + case 'v': #endif - else - { - as_warn ("Unknown option `%s' ignored", arg); - *argv = NULL; + case OPTION_VERBOSE: + print_version_id (); + break; } - continue; - } - - /* This better be a switch. */ - arg++; /*->letter. */ - - while ((a = *arg) != '\0') - { /* scan all the 1-char flags */ - arg++; /* arg->after letter. */ - a &= 0x7F; /* ascii only please */ - flagseen[(unsigned char) a] = 1; - switch (a) - { - case 'a': + /* Fall through. */ + + case '?': + exit (EXIT_FAILURE); + + case 1: /* File name. */ + if (!strcmp (optarg, "-")) + optarg = ""; + new_argv[new_argc++] = optarg; + new_argv[new_argc] = NULL; + break; + + case OPTION_TARGET_HELP: + md_show_usage (stdout); + exit (EXIT_SUCCESS); + + case OPTION_HELP: + show_usage (stdout); + exit (EXIT_SUCCESS); + + case OPTION_NOCPP: + break; + + case OPTION_STATISTICS: + flag_print_statistics = 1; + break; + + case OPTION_STRIP_LOCAL_ABSOLUTE: + flag_strip_local_absolute = 1; + break; + + case OPTION_TRADITIONAL_FORMAT: + flag_traditional_format = 1; + break; + + case OPTION_VERSION: + /* This output is intended to follow the GNU standards document. */ + printf (_("GNU assembler %s\n"), VERSION); + printf (_("Copyright 2001 Free Software Foundation, Inc.\n")); + printf (_("\ +This program is free software; you may redistribute it under the terms of\n\ +the GNU General Public License. This program has absolutely no warranty.\n")); + printf (_("This assembler was configured for a target of `%s'.\n"), + TARGET_ALIAS); + exit (EXIT_SUCCESS); + + case OPTION_EMULATION: +#ifdef USE_EMULATIONS + if (strcmp (optarg, this_emulation->name)) + as_fatal (_("multiple emulation names specified")); +#else + as_fatal (_("emulations not handled in this configuration")); +#endif + break; + + case OPTION_DUMPCONFIG: + fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS); + fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL); + fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU); +#ifdef TARGET_OBJ_FORMAT + fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT); +#endif +#ifdef TARGET_FORMAT + fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT); +#endif + exit (EXIT_SUCCESS); + + case OPTION_DEFSYM: + { + char *s; + valueT i; + struct defsym_list *n; + + for (s = optarg; *s != '\0' && *s != '='; s++) + ; + if (*s == '\0') + as_fatal (_("bad defsym; format is --defsym name=value")); + *s++ = '\0'; +#ifdef BFD_ASSEMBLER + i = bfd_scan_vma (s, (const char **) NULL, 0); +#else + i = strtol (s, (char **) NULL, 0); +#endif + n = (struct defsym_list *) xmalloc (sizeof *n); + n->next = defsyms; + n->name = optarg; + n->value = i; + defsyms = n; + } + break; + + case OPTION_INSTTBL: + case 't': + { + /* optarg is the name of the file containing the instruction + formats, opcodes, register names, etc. */ + struct itbl_file_list *n; + + if (optarg == NULL) { - int loop = 1; - - while (loop) - { - switch (*arg) - { - case 'l': - listing |= LISTING_LISTING; - arg++; - break; - case 's': - listing |= LISTING_SYMBOLS; - arg++; - break; - case 'h': - listing |= LISTING_HLL; - arg++; - break; - - case 'n': - listing |= LISTING_NOFORM; - arg++; - break; - case 'd': - listing |= LISTING_NODEBUG; - arg++; - break; - default: - if (!listing) - listing = LISTING_DEFAULT; - loop = 0; - break; - } - } - } - - break; - - - case 'f': - break; /* -f means fast - no need for "app" preprocessor. */ - - case 'D': - /* DEBUG is implemented: it debugs different */ - /* things to other people's assemblers. */ - break; - - case 'I': - { /* Include file directory */ - - char *temp = NULL; - if (*arg) - { - temp = strdup (arg); - if (!temp) - as_fatal ("virtual memory exhausted"); - } - else if (argc) - { - *argv = NULL; - argc--; - temp = *++argv; - } - else - as_warn ("%s: I expected a filename after -I", myname); - add_include_dir (temp); - arg = ""; /* Finished with this arg. */ + as_warn (_("no file name following -t option")); break; } -#ifdef WARN_SIGNED_OVERFLOW_WORD - /* Don't warn about signed overflow. */ - case 'J': - break; -#endif + n = (struct itbl_file_list *) xmalloc (sizeof *n); + n->next = itbl_files; + n->name = optarg; + itbl_files = n; + + /* Parse the file and add the new instructions to our internal + table. If multiple instruction tables are specified, the + information from this table gets appended onto the existing + internal table. */ + itbl_files->name = xstrdup (optarg); + if (itbl_parse (itbl_files->name) != 0) + as_fatal (_("failed to read instruction table %s\n"), + itbl_files->name); + } + break; + + case OPTION_DEPFILE: + start_dependencies (optarg); + break; + + case OPTION_GSTABS: + debug_type = DEBUG_STABS; + break; + + case OPTION_GDWARF2: + debug_type = DEBUG_DWARF2; + break; + + case 'J': + flag_signed_overflow_ok = 1; + break; #ifndef WORKING_DOT_WORD - case 'K': - break; + case 'K': + flag_warn_displacement = 1; + break; #endif - case 'L': /* -L means keep L* symbols */ - break; - - case 'o': - if (*arg) /* Rest of argument is object file-name. */ - { - out_file_name = strdup (arg); - if (!out_file_name) - as_fatal ("virtual memory exhausted"); - } - else if (argc) - { /* Want next arg for a file-name. */ - *argv = NULL; /* This is not a file-name. */ - argc--; - out_file_name = *++argv; - } - else - as_warn ("%s: I expected a filename after -o. \"%s\" assumed.", - myname, out_file_name); - arg = ""; /* Finished with this arg. */ - break; + case 'L': + flag_keep_locals = 1; + break; + + case OPTION_LISTING_LHS_WIDTH: + listing_lhs_width = atoi (optarg); + if (listing_lhs_width_second < listing_lhs_width) + listing_lhs_width_second = listing_lhs_width; + break; + case OPTION_LISTING_LHS_WIDTH2: + { + int tmp = atoi (optarg); + if (tmp > listing_lhs_width) + listing_lhs_width_second = tmp; + } + break; + case OPTION_LISTING_RHS_WIDTH: + listing_rhs_width = atoi (optarg); + break; + case OPTION_LISTING_CONT_LINES: + listing_lhs_cont_lines = atoi (optarg); + break; + + case 'M': + flag_mri = 1; +#ifdef TC_M68K + flag_m68k_mri = 1; +#endif + break; - case 'n': - if (*arg && strcmp(arg, "ocpp") == 0) - ; - else - { - as_warn ("Unknown option `-n%s' ignored", arg); - arg += strlen (arg); - break; - } + case 'R': + flag_readonly_data_in_text = 1; + break; - case 'R': - /* -R means put data into text segment */ - flag_readonly_data_in_text = 1; - break; + case 'W': + flag_no_warnings = 1; + break; - case 'v': -#ifdef VMS - { - extern char *compiler_version_string; - compiler_version_string = arg; - } -#else /* not VMS */ - if (*arg && strcmp (arg, "ersion")) - { - as_warn ("Unknown option `-v%s' ignored", arg); - arg += strlen (arg); - break; - } + case OPTION_WARN: + flag_no_warnings = 0; + flag_fatal_warnings = 0; + break; - print_version_id (); -#endif /* not VMS */ - while (*arg) - arg++; /* Skip the rest */ - break; + case OPTION_WARN_FATAL: + flag_no_warnings = 0; + flag_fatal_warnings = 1; + break; - case 'W': - /* -W means don't warn about things */ - flag_suppress_warnings = 1; - break; + case 'Z': + flag_always_generate_output = 1; + break; - case 'w': - case 'X': - /* -X means treat warnings as errors */ - break; - case 'Z': - /* -Z means attempt to generate object file even after errors. */ - flag_always_generate_output = 1; - break; + case 'a': + if (optarg) + { + if (md_parse_option (optc, optarg) != 0) + break; - default: - --arg; - if (md_parse_option (&arg, &argc, &argv) == 0) - as_warn ("%s: I don't understand '%c' flag.", myname, a); - if (arg && *arg) - arg++; - break; + while (*optarg) + { + switch (*optarg) + { + case 'c': + listing |= LISTING_NOCOND; + break; + case 'd': + listing |= LISTING_NODEBUG; + break; + case 'h': + listing |= LISTING_HLL; + break; + case 'l': + listing |= LISTING_LISTING; + break; + case 'm': + listing |= LISTING_MACEXP; + break; + case 'n': + listing |= LISTING_NOFORM; + break; + case 's': + listing |= LISTING_SYMBOLS; + break; + case '=': + listing_filename = xstrdup (optarg + 1); + optarg += strlen (listing_filename); + break; + default: + as_fatal (_("invalid listing option `%c'"), *optarg); + break; + } + optarg++; + } } + if (!listing) + listing = LISTING_DEFAULT; + break; + + case 'D': + /* DEBUG is implemented: it debugs different + things from other people's assemblers. */ + flag_debug = 1; + break; + + case 'f': + flag_no_comments = 1; + break; + + case 'I': + { /* Include file directory. */ + char *temp = xstrdup (optarg); + add_include_dir (temp); + break; + } + + case 'o': + out_file_name = xstrdup (optarg); + break; + + case 'w': + break; + + case 'X': + /* -X means treat warnings as errors. */ + break; } - /* - * We have just processed a "-..." arg, which was not a - * file-name. Smash it so the - * things that look for filenames won't ever see it. - * - * Whatever argv points to, it has already been used - * as part of a flag, so DON'T re-use it as a filename. - */ - *argv = NULL; /* NULL means 'not a file-name' */ } + + free (shortopts); + free (longopts); + + *pargc = new_argc; + *pargv = new_argv; } -int +static long start_time; + +int main (argc, argv) int argc; char **argv; { - char a; + int macro_alternate; + int macro_strip_at; int keep_it; - long start_time = get_run_time (); -#if 0 /* do we need any of this?? */ - { - static const int sig[] = {SIGHUP, SIGINT, SIGPIPE, SIGTERM, 0}; + start_time = get_run_time (); - for (a = 0; sig[a] != 0; a++) - if (signal (sig[a], SIG_IGN) != SIG_IGN) - signal (sig[a], got_sig); - } +#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) + setlocale (LC_MESSAGES, ""); +#endif + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + + if (debug_memory) + { +#ifdef BFD_ASSEMBLER + extern long _bfd_chunksize; + _bfd_chunksize = 64; +#endif + chunksize = 64; + } + +#ifdef HOST_SPECIAL_INIT + HOST_SPECIAL_INIT (argc, argv); #endif myname = argv[0]; - memset (flagseen, '\0', sizeof (flagseen)); /* aint seen nothing yet */ + xmalloc_set_program_name (myname); + + START_PROGRESS (myname, 0); + #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out" #endif + out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME; + hex_init (); #ifdef BFD_ASSEMBLER bfd_init (); + bfd_set_error_program_name (myname); #endif +#ifdef USE_EMULATIONS + select_emulation_mode (argc, argv); +#endif + + PROGRESS (1); symbol_begin (); + frag_init (); subsegs_begin (); + parse_args (&argc, &argv); read_begin (); input_scrub_begin (); - frag_init (); - parse_args (argc, argv); + expr_begin (); + + if (flag_print_statistics) + xatexit (dump_statistics); + + macro_alternate = 0; + macro_strip_at = 0; +#ifdef TC_I960 + macro_strip_at = flag_mri; +#endif +#ifdef TC_A29K + /* For compatibility with the AMD 29K family macro assembler + specification. */ + macro_alternate = 1; + macro_strip_at = 1; +#endif + + macro_init (macro_alternate, flag_mri, macro_strip_at, macro_expr); + + PROGRESS (1); #ifdef BFD_ASSEMBLER output_file_create (out_file_name); @@ -569,24 +854,58 @@ main (argc, argv) tc_init_after_args (); #endif - /* Here with flags set up in flagseen[]. */ - perform_an_assembly_pass (argc, argv); /* Assemble it. */ -#ifdef TC_I960 - brtab_emit (); + itbl_init (); + + /* Now that we have fully initialized, and have created the output + file, define any symbols requested by --defsym command line + arguments. */ + while (defsyms != NULL) + { + symbolS *sym; + struct defsym_list *next; + + sym = symbol_new (defsyms->name, absolute_section, defsyms->value, + &zero_address_frag); + symbol_table_insert (sym); + next = defsyms->next; + free (defsyms); + defsyms = next; + } + + PROGRESS (1); + + /* Assemble it. */ + perform_an_assembly_pass (argc, argv); + + cond_finish_check (-1); + +#ifdef md_end + md_end (); #endif + /* If we've been collecting dwarf2 .debug_line info, either for + assembly debugging or on behalf of the compiler, emit it now. */ + dwarf2_finish (); + if (seen_at_least_1_file () - && !((had_warnings () && flag_always_generate_output) - || had_errors () > 0)) + && (flag_always_generate_output || had_errors () == 0)) keep_it = 1; else keep_it = 0; +#if defined (BFD_ASSEMBLER) || !defined (BFD) + /* This used to be done at the start of write_object_file in + write.c, but that caused problems when doing listings when + keep_it was zero. This could probably be moved above md_end, but + I didn't want to risk the change. */ + subsegs_finish (); +#endif + if (keep_it) write_object_file (); #ifndef NO_LISTING - listing_print (""); + listing_print (listing_filename); #endif #ifndef OBJ_VMS /* does its own file handling */ @@ -596,45 +915,68 @@ main (argc, argv) output_file_close (out_file_name); #endif + if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0) + as_bad (_("%d warnings, treating warnings as errors"), had_warnings ()); + + if (had_errors () > 0 && ! flag_always_generate_output) + keep_it = 0; + if (!keep_it) unlink (out_file_name); input_scrub_end (); -#ifdef md_end - md_end (); + + END_PROGRESS (myname); + + /* Use xexit instead of return, because under VMS environments they + may not place the same interpretation on the value given. */ + if (had_errors () > 0) + xexit (EXIT_FAILURE); + + /* Only generate dependency file if assembler was successful. */ + print_dependencies (); + + xexit (EXIT_SUCCESS); +} + +static void +dump_statistics () +{ +#ifdef HAVE_SBRK + char *lim = (char *) sbrk (0); #endif + long run_time = get_run_time () - start_time; - if (statistics_flag) - { - extern char **environ; - char *lim = (char *) sbrk (0); - long run_time = get_run_time () - start_time; - - fprintf (stderr, "%s: total time in assembly: %ld.%06ld\n", - myname, run_time / 1000000, run_time % 1000000); - fprintf (stderr, "%s: data size %ld\n", - myname, (long) (lim - (char *) &environ)); - } + fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"), + myname, run_time / 1000000, run_time % 1000000); +#ifdef HAVE_SBRK + fprintf (stderr, _("%s: data size %ld\n"), + myname, (long) (lim - (char *) &environ)); +#endif + + subsegs_print_statistics (stderr); + write_print_statistics (stderr); + symbol_print_statistics (stderr); + read_print_statistics (stderr); - if ((had_warnings () && flagseen['Z']) - || had_errors () > 0) - return EXIT_FAILURE; - return EXIT_SUCCESS; +#ifdef tc_print_statistics + tc_print_statistics (stderr); +#endif +#ifdef obj_print_statistics + obj_print_statistics (stderr); +#endif } +/* Here to attempt 1 pass over each input file. + We scan argv[*] looking for filenames or exactly "" which is + shorthand for stdin. Any argv that is NULL is not a file-name. + We set need_pass_2 TRUE if, after this, we still have unresolved + expressions of the form (unknown value)+-(unknown value). -/* perform_an_assembly_pass() - * - * Here to attempt 1 pass over each input file. - * We scan argv[*] looking for filenames or exactly "" which is - * shorthand for stdin. Any argv that is NULL is not a file-name. - * We set need_pass_2 TRUE if, after this, we still have unresolved - * expressions of the form (unknown value)+-(unknown value). - * - * Note the un*x semantics: there is only 1 logical input file, but it - * may be a catenation of many 'physical' input files. - */ -static void + Note the un*x semantics: there is only 1 logical input file, but it + may be a catenation of many 'physical' input files. */ + +static void perform_an_assembly_pass (argc, argv) int argc; char **argv; @@ -653,7 +995,7 @@ perform_an_assembly_pass (argc, argv) for (i = SEG_E0; i < SEG_UNKNOWN; i++) segment_info[i].fix_root = 0; } - /* Create the three fixed ones */ + /* Create the three fixed ones. */ { segT seg; @@ -680,18 +1022,18 @@ perform_an_assembly_pass (argc, argv) #else /* BFD_ASSEMBLER */ /* Create the standard sections, and those the assembler uses internally. */ - text_section = subseg_new (".text", 0); - data_section = subseg_new (".data", 0); - bss_section = subseg_new (".bss", 0); + text_section = subseg_new (TEXT_SECTION_NAME, 0); + data_section = subseg_new (DATA_SECTION_NAME, 0); + bss_section = subseg_new (BSS_SECTION_NAME, 0); /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed - to have relocs, otherwise we don't find out in time. */ + to have relocs, otherwise we don't find out in time. */ applicable = bfd_applicable_section_flags (stdoutput); bfd_set_section_flags (stdoutput, text_section, applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_READONLY)); - /* @@ FIXME -- SEC_CODE seems to mean code only, rather than code possibly.*/ bfd_set_section_flags (stdoutput, data_section, - applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)); + applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC + | SEC_DATA)); bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC); seg_info (bss_section)->bss = 1; subseg_new (BFD_ABS_SECTION_NAME, 0); @@ -707,37 +1049,53 @@ perform_an_assembly_pass (argc, argv) and sections already created, in BFD_ASSEMBLER mode. */ md_begin (); - argv++; /* skip argv[0] */ - argc--; /* skip argv[0] */ +#ifdef obj_begin + obj_begin (); +#endif + + /* Skip argv[0]. */ + argv++; + argc--; + while (argc--) { if (*argv) - { /* Is it a file-name argument? */ + { /* Is it a file-name argument? */ + PROGRESS (1); saw_a_file++; - /* argv->"" if stdin desired, else->filename */ + /* argv->"" if stdin desired, else->filename */ read_a_source_file (*argv); } - argv++; /* completed that argv */ + argv++; /* completed that argv */ } if (!saw_a_file) read_a_source_file (""); -} /* perform_an_assembly_pass() */ - -#if 0 -/* This is not currently used. */ -static SIGTY -got_sig (sig) - int sig; +} + +/* The interface between the macro code and gas expression handling. */ + +static int +macro_expr (emsg, idx, in, val) + const char *emsg; + int idx; + sb *in; + int *val; { - static here_before = 0; + char *hold; + expressionS ex; - as_bad ("Interrupted by signal %d", sig); - if (here_before++) - exit (EXIT_FAILURE); -#if 0 /* If SIGTY is void, this produces warnings. */ - return ((SIGTY) 0); -#endif -} -#endif + sb_terminate (in); + + hold = input_line_pointer; + input_line_pointer = in->ptr + idx; + expression (&ex); + idx = input_line_pointer - in->ptr; + input_line_pointer = hold; -/* end of as.c */ + if (ex.X_op != O_constant) + as_bad ("%s", emsg); + + *val = (int) ex.X_add_number; + + return idx; +}