/* SPDX-License-Identifier: BSD-2-Clause */ /* Copyright 1996-2025 The NASM Authors - All Rights Reserved */ /* * The Netwide Assembler main program module */ #include "compiler.h" #include "nasm.h" #include "nasmlib.h" #include "nctype.h" #include "error.h" #include "saa.h" #include "raa.h" #include "floats.h" #include "stdscan.h" #include "insns.h" #include "preproc.h" #include "parser.h" #include "eval.h" #include "assemble.h" #include "labels.h" #include "outform.h" #include "listing.h" #include "iflag.h" #include "quote.h" #include "ver.h" /* * This is the maximum number of optimization passes to do. If we ever * find a case where the optimizer doesn't naturally converge, we might * have to drop this value so the assembler doesn't appear to just hang. */ #define MAX_OPTIMIZE (INT_MAX >> 1) struct forwrefinfo { /* info held on forward refs. */ int lineno; int operand; }; const char *_progname; static void open_and_process_respfile(char *, int); static void parse_cmdline(int, char **, int); static void assemble_file(const char *, struct strlist *); static bool skip_this_pass(errflags severity); static void usage(void); static void help(FILE *out, const char *what); struct error_format { const char *beforeline; /* Before line number, if present */ const char *afterline; /* After line number, if present */ const char *beforemsg; /* Before actual message */ }; static const struct error_format errfmt_gnu = { ":", "", ": " }; static const struct error_format errfmt_msvc = { "(", ")", " : " }; static const struct error_format *errfmt = &errfmt_gnu; static struct strlist *warn_list; static struct nasm_errhold *errhold_stack; static bool using_debug_info; static const char *debug_format; #ifndef ABORT_ON_PANIC # define ABORT_ON_PANIC 0 #endif static bool abort_on_panic = ABORT_ON_PANIC; static bool keep_all; bool tasm_compatible_mode = false; enum pass_type _pass_type; const char * const _pass_types[] = { "init", "preproc-only", "first", "optimize", "stabilize", "final" }; int64_t _passn; struct compile_time official_compile_time; const char *inname; const char *outname; static const char *listname; static const char *errname; static int64_t globallineno; /* for forward-reference tracking */ const struct ofmt *ofmt = &OF_DEFAULT; const struct ofmt_alias *ofmt_alias = NULL; const struct dfmt *dfmt; static FILE *error_file; /* Where to write error messages */ errflags errflags_never = 0; /* Error flags to unconditionally suppress */ FILE *ofile = NULL; enum optimization optimizing = OPTIM_DEFAULT; static int cmd_sb = 16; /* by default */ iflag_t cpu, cmd_cpu; struct location location; bool in_absolute; /* Flag we are in ABSOLUTE seg */ struct location absolute; /* Segment/offset inside ABSOLUTE */ static struct RAA *offsets; static struct SAA *forwrefs; /* keep track of forward references */ static const struct forwrefinfo *forwref; static struct strlist *include_path; static enum preproc_opt ppopt; #define OP_NORMAL (1U << 0) #define OP_PREPROCESS (1U << 1) #define OP_DEPEND (1U << 2) static unsigned int operating_mode; /* Dependency flags */ static bool depend_emit_phony = false; static bool depend_missing_ok = false; static const char *depend_target = NULL; static const char *depend_file = NULL; struct strlist *depend_list; static bool want_usage; static bool terminate_after_phase; static char *quote_for_pmake(const char *str); static char *quote_for_wmake(const char *str); static char *(*quote_for_make)(const char *) = quote_for_pmake; /* * Execution limits that can be set via a command-line option or %pragma */ /* * This is really unlimited; it would take far longer than the * current age of the universe for this limit to be reached even on * much faster CPUs than currently exist. */ #define LIMIT_MAX_VAL (INT64_MAX >> 1) int64_t nasm_limit[LIMIT_MAX+1]; struct limit_info { const char *name; const char *help; int64_t default_val; }; /* The order here must match enum nasm_limit in nasm.h */ static const struct limit_info limit_info[LIMIT_MAX+1] = { { "passes", "total number of passes", LIMIT_MAX_VAL }, { "stalled-passes", "number of passes without forward progress", 1000 }, { "macro-levels", "levels of macro expansion", 10000 }, { "macro-tokens", "tokens processed during single-line macro expansion", 10000000 }, { "mmacros", "multi-line macros before final return", 100000 }, { "rep", "%rep count", 1000000 }, { "eval", "expression evaluation descent", 8192 }, { "lines", "total source lines processed", 2000000000 } }; static void set_default_limits(void) { int i; size_t rl; int64_t new_limit; for (i = 0; i <= LIMIT_MAX; i++) nasm_limit[i] = limit_info[i].default_val; /* * Try to set a sensible default value for the eval depth based * on the limit of the stack size, if knowable... */ rl = nasm_get_stack_size_limit(); new_limit = rl / (128 * sizeof(void *)); /* Sensible heuristic */ if (new_limit < nasm_limit[LIMIT_EVAL]) nasm_limit[LIMIT_EVAL] = new_limit; } enum directive_result nasm_set_limit(const char *limit, const char *valstr) { int i; int64_t val; bool rn_error; int errlevel; if (!limit) limit = ""; if (!valstr) valstr = ""; for (i = 0; i <= LIMIT_MAX; i++) { if (!nasm_stricmp(limit, limit_info[i].name)) break; } if (i > LIMIT_MAX) { if (not_started()) errlevel = ERR_WARNING|WARN_OTHER|ERR_USAGE; else errlevel = ERR_WARNING|WARN_PRAGMA_UNKNOWN; nasm_error(errlevel, "unknown limit: `%s'", limit); return DIRR_ERROR; } if (!nasm_stricmp(valstr, "unlimited")) { val = LIMIT_MAX_VAL; } else { val = readnum(valstr, &rn_error); if (rn_error || val < 0) { if (not_started()) errlevel = ERR_WARNING|WARN_OTHER|ERR_USAGE; else errlevel = ERR_WARNING|WARN_PRAGMA_BAD; nasm_error(errlevel, "invalid limit value: `%s'", valstr); return DIRR_ERROR; } if (val > LIMIT_MAX_VAL) val = LIMIT_MAX_VAL; } nasm_limit[i] = val; return DIRR_OK; } int64_t switch_segment(int32_t segment) { location.segment = segment; if (segment == NO_SEG) { location.offset = absolute.offset; in_absolute = true; } else { location.offset = raa_read(offsets, segment); in_absolute = false; } return location.offset; } static int64_t set_curr_offs(int64_t l_off) { location.offset = l_off; if (in_absolute) { absolute.offset = l_off; } else { offsets = raa_write(offsets, location.segment, l_off); } return l_off; } int64_t increment_offset(int64_t delta) { int64_t newoffs = location.offset + delta; if (unlikely(!delta)) return newoffs; return set_curr_offs(newoffs); } /* * Define system-defined macros that are not part of * macros/standard.mac. */ static void define_macros(void) { const struct compile_time * const oct = &official_compile_time; char temp[128]; if (oct->have_local) { strftime(temp, sizeof temp, "__?DATE?__=\"%Y-%m-%d\"", &oct->local); pp_pre_define(temp); strftime(temp, sizeof temp, "__?DATE_NUM?__=%Y%m%d", &oct->local); pp_pre_define(temp); strftime(temp, sizeof temp, "__?TIME?__=\"%H:%M:%S\"", &oct->local); pp_pre_define(temp); strftime(temp, sizeof temp, "__?TIME_NUM?__=%H%M%S", &oct->local); pp_pre_define(temp); } if (oct->have_gm) { strftime(temp, sizeof temp, "__?UTC_DATE?__=\"%Y-%m-%d\"", &oct->gm); pp_pre_define(temp); strftime(temp, sizeof temp, "__?UTC_DATE_NUM?__=%Y%m%d", &oct->gm); pp_pre_define(temp); strftime(temp, sizeof temp, "__?UTC_TIME?__=\"%H:%M:%S\"", &oct->gm); pp_pre_define(temp); strftime(temp, sizeof temp, "__?UTC_TIME_NUM?__=%H%M%S", &oct->gm); pp_pre_define(temp); } if (oct->have_posix) { snprintf(temp, sizeof temp, "__?POSIX_TIME?__=%"PRId64, oct->posix); pp_pre_define(temp); } /* * In case if output format is defined by alias * we have to put shortname of the alias itself here * otherwise ABI backward compatibility gets broken. */ snprintf(temp, sizeof(temp), "__?OUTPUT_FORMAT?__=%s", ofmt_alias ? ofmt_alias->shortname : ofmt->shortname); pp_pre_define(temp); /* * Debug format, if any */ if (dfmt != &null_debug_form) { snprintf(temp, sizeof(temp), "__?DEBUG_FORMAT?__=%s", dfmt->shortname); pp_pre_define(temp); } } /* * Initialize the preprocessor, set up the include path, and define * the system-included macros. This is called between passes 1 and 2 * of parsing the command options; ofmt and dfmt are defined at this * point. * * Command-line specified preprocessor directives (-p, -d, -u, * --pragma, --before) are processed after this function. */ static void preproc_init(struct strlist *ipath) { pp_init(ppopt); define_macros(); pp_include_path(ipath); } static void emit_dependencies(struct strlist *list) { FILE *deps; int linepos, len; bool wmake = (quote_for_make == quote_for_wmake); const char *wrapstr, *nulltarget; const struct strlist_entry *l; if (!list) return; wrapstr = wmake ? " &\n " : " \\\n "; nulltarget = wmake ? "\t%null\n" : ""; if (depend_file && strcmp(depend_file, "-")) { deps = nasm_open_write(depend_file, NF_TEXT); if (!deps) { nasm_nonfatal("unable to write dependency file `%s'", depend_file); return; } } else { deps = stdout; } linepos = fprintf(deps, "%s :", depend_target); strlist_for_each(l, list) { char *file = quote_for_make(l->str); len = strlen(file); if (linepos + len > 62 && linepos > 1) { fputs(wrapstr, deps); linepos = 1; } fprintf(deps, " %s", file); linepos += len+1; nasm_free(file); } fputs("\n\n", deps); strlist_for_each(l, list) { if (depend_emit_phony) { char *file = quote_for_make(l->str); fprintf(deps, "%s :\n%s\n", file, nulltarget); nasm_free(file); } } strlist_free(&list); if (deps != stdout) fclose(deps); } /* Convert a struct tm to a POSIX-style time constant */ static int64_t make_posix_time(const struct tm *tm) { int64_t t; int64_t y = tm->tm_year; /* See IEEE 1003.1:2004, section 4.14 */ t = (y-70)*365 + (y-69)/4 - (y-1)/100 + (y+299)/400; t += tm->tm_yday; t *= 24; t += tm->tm_hour; t *= 60; t += tm->tm_min; t *= 60; t += tm->tm_sec; return t; } /* * Quote a filename string if and only if it is necessary. * It is considered necessary if any one of these is true: * 1. The filename contains control characters; * 2. The filename starts or ends with a space or quote mark; * 3. The filename contains more than one space in a row; * 4. The filename is empty. * * The filename is returned in a newly allocated buffer. */ static char *nasm_quote_filename(const char *fn) { const unsigned char *p = (const unsigned char *)fn; size_t len; if (!p || !*p) return nasm_strdup("\"\""); if (*p <= ' ' || nasm_isquote(*p)) { goto quote; } else { unsigned char cutoff = ' '; while (*p) { if (*p < cutoff) goto quote; cutoff = ' ' + (*p == ' '); p++; } if (p[-1] <= ' ' || nasm_isquote(p[-1])) goto quote; } /* Quoting not necessary */ return nasm_strdup(fn); quote: len = strlen(fn); return nasm_quote(fn, &len); } static void timestamp(void) { struct compile_time * const oct = &official_compile_time; #if 1 // Chromium patch: Builds should be deterministic and not embed timestamps. memset(oct, 0, sizeof(official_compile_time)); #else const struct tm *tp, *best_gm; time(&oct->t); best_gm = NULL; tp = localtime(&oct->t); if (tp) { oct->local = *tp; best_gm = &oct->local; oct->have_local = true; } tp = gmtime(&oct->t); if (tp) { oct->gm = *tp; best_gm = &oct->gm; oct->have_gm = true; if (!oct->have_local) oct->local = oct->gm; } else { oct->gm = oct->local; } if (best_gm) { oct->posix = make_posix_time(best_gm); oct->have_posix = true; } #endif } int main(int argc, char **argv) { /* Do these as early as possible */ error_file = stderr; _progname = argv[0]; if (!_progname || !_progname[0]) _progname = "nasm"; timestamp(); set_cpu(NULL); cmd_cpu = cpu; set_default_limits(); include_path = strlist_alloc(true); _pass_type = PASS_INIT; _passn = 0; want_usage = terminate_after_phase = false; nasm_ctype_init(); src_init(); /* * We must call init_labels() before the command line parsing, * because we may be setting prefixes/suffixes from the command * line. */ init_labels(); offsets = raa_init(); forwrefs = saa_init((int32_t)sizeof(struct forwrefinfo)); operating_mode = OP_NORMAL; parse_cmdline(argc, argv, 1); if (terminate_after_phase) { if (want_usage) usage(); return 1; } /* At this point we have ofmt and the name of the desired debug format */ if (!using_debug_info) { /* No debug info, redirect to the null backend (empty stubs) */ dfmt = &null_debug_form; } else if (!debug_format) { /* Default debug format for this backend */ dfmt = ofmt->default_dfmt; } else { dfmt = dfmt_find(ofmt, debug_format); if (!dfmt) { nasm_fatalf(ERR_USAGE, "unrecognized debug format `%s' for output format `%s'", debug_format, ofmt->shortname); } } /* Have we enabled TASM mode? */ if (tasm_compatible_mode) { ppopt |= PP_TASM; nasm_ctype_tasm_mode(); } preproc_init(include_path); parse_cmdline(argc, argv, 2); if (terminate_after_phase) { if (want_usage) usage(); return 1; } /* Save away the default state of warnings */ init_warnings(); /* Dependency filename if we are also doing other things */ if (!depend_file && (operating_mode & ~OP_DEPEND)) { if (outname) depend_file = nasm_strcat(outname, ".d"); else depend_file = filename_set_extension(inname, ".d"); } /* * If no output file name provided and this * is preprocess mode, we're perfectly * fine to output into stdout. */ if (!outname && !(operating_mode & OP_PREPROCESS)) { outname = filename_set_extension(inname, ofmt->extension); if (!strcmp(outname, inname)) { outname = "nasm.out"; nasm_warn(WARN_OTHER, "default output file same as input, using `%s' for output\n", outname); } } depend_list = (operating_mode & OP_DEPEND) ? strlist_alloc(true) : NULL; if (!depend_target) depend_target = quote_for_make(outname); if (!(operating_mode & (OP_PREPROCESS|OP_NORMAL))) { char *line; if (depend_missing_ok) pp_include_path(NULL); /* "assume generated" */ pp_reset(inname, PP_DEPS, depend_list); ofile = NULL; while ((line = pp_getline())) nasm_free(line); pp_cleanup_pass(); reset_warnings(); } else if (operating_mode & OP_PREPROCESS) { char *line; const char *file_name = NULL; char *quoted_file_name = nasm_quote_filename(file_name); int32_t linnum = 0; int32_t lineinc = 0; FILE *out; if (outname) { ofile = nasm_open_write(outname, NF_TEXT); if (!ofile) nasm_fatal("unable to open output file `%s'", outname); out = ofile; } else { ofile = NULL; out = stdout; } location.known = false; _pass_type = PASS_PREPROC; pp_reset(inname, PP_PREPROC, depend_list); while ((line = pp_getline())) { /* * We generate %line directives if needed for later programs */ struct src_location where = src_where(); if (file_name != where.filename) { file_name = where.filename; linnum = -1; /* Force a new %line statement */ lineinc = file_name ? 1 : 0; nasm_free(quoted_file_name); quoted_file_name = nasm_quote_filename(file_name); } else if (lineinc) { if (linnum + lineinc == where.lineno) { /* Add one blank line to account for increment */ fputc('\n', out); linnum += lineinc; } else if (linnum - lineinc == where.lineno) { /* * Standing still, probably a macro. Set increment * to zero. */ lineinc = 0; } } else { /* lineinc == 0 */ if (linnum + 1 == where.lineno) lineinc = 1; } /* Skip blank lines if we will need a %line anyway */ if (linnum == -1 && !line[0]) continue; if (linnum != where.lineno) { fprintf(out, "%%line %"PRId32"%+"PRId32" %s\n", where.lineno, lineinc, quoted_file_name); } linnum = where.lineno + lineinc; fputs(line, out); fputc('\n', out); } nasm_free(quoted_file_name); pp_cleanup_pass(); reset_warnings(); if (ofile) fclose(ofile); if (ofile && terminate_after_phase && !keep_all) remove(outname); ofile = NULL; } if (operating_mode & OP_NORMAL) { ofile = nasm_open_write(outname, (ofmt->flags & OFMT_TEXT) ? NF_TEXT : NF_BINARY); if (!ofile) nasm_fatal("unable to open output file `%s'", outname); ofmt->init(); dfmt->init(); assemble_file(inname, depend_list); if (!terminate_after_phase) { ofmt->cleanup(); cleanup_labels(); fflush(ofile); if (ferror(ofile)) nasm_nonfatal("write error on output file `%s'", outname); } if (ofile) { fclose(ofile); if (terminate_after_phase && !keep_all) remove(outname); ofile = NULL; } } pp_cleanup_session(); if (depend_list && !terminate_after_phase) emit_dependencies(depend_list); if (want_usage) usage(); raa_free(offsets); saa_free(forwrefs); eval_cleanup(); stdscan_cleanup(); src_free(); strlist_free(&include_path); return terminate_after_phase; } /* * Get a parameter for a command line option. * First arg must be in the form of e.g. -f... * * get_param() errors on a missing argument; get_opt_param() does not. */ static char *get_opt_param(char *p, char *q, bool *advance) { *advance = false; if (p[2]) /* the parameter's in the option */ return nasm_skip_spaces(p + 2); if (q && q[0]) { *advance = true; return q; } return NULL; } static char *get_param(char *p, char *q, bool *advance) { char *r = get_opt_param(p, q, advance); if (!r) nasm_nonfatalf(ERR_USAGE, "option `-%c' requires an argument", p[1]); return r; } /* * Copy a filename */ static void copy_filename(const char **dst, const char *src, const char *what) { if (*dst) nasm_fatal("more than one %s file specified: %s\n", what, src); *dst = nasm_strdup(src); } /* * Convert a string to a POSIX make-safe form */ static char *quote_for_pmake(const char *str) { const char *p; char *os, *q; size_t n = 1; /* Terminating zero */ size_t nbs = 0; if (!str) return NULL; for (p = str; *p; p++) { switch (*p) { case ' ': case '\t': /* Convert N backslashes + ws -> 2N+1 backslashes + ws */ n += nbs + 2; nbs = 0; break; case '$': case '#': nbs = 0; n += 2; break; case '\\': nbs++; n++; break; default: nbs = 0; n++; break; } } /* Convert N backslashes at the end of filename to 2N backslashes */ n += nbs; os = q = nasm_malloc(n); nbs = 0; for (p = str; *p; p++) { switch (*p) { case ' ': case '\t': q = mempset(q, '\\', nbs); *q++ = '\\'; *q++ = *p; nbs = 0; break; case '$': *q++ = *p; *q++ = *p; nbs = 0; break; case '#': *q++ = '\\'; *q++ = *p; nbs = 0; break; case '\\': *q++ = *p; nbs++; break; default: *q++ = *p; nbs = 0; break; } } q = mempset(q, '\\', nbs); *q = '\0'; return os; } /* * Convert a string to a Watcom make-safe form */ static char *quote_for_wmake(const char *str) { const char *p; char *os, *q; bool quote = false; size_t n = 1; /* Terminating zero */ if (!str) return NULL; for (p = str; *p; p++) { switch (*p) { case ' ': case '\t': case '&': quote = true; n++; break; case '\"': quote = true; n += 2; break; case '$': case '#': n += 2; break; default: n++; break; } } if (quote) n += 2; os = q = nasm_malloc(n); if (quote) *q++ = '\"'; for (p = str; *p; p++) { switch (*p) { case '$': case '#': *q++ = '$'; *q++ = *p; break; case '\"': *q++ = *p; *q++ = *p; break; default: *q++ = *p; break; } } if (quote) *q++ = '\"'; *q = '\0'; return os; } enum text_options { OPT_BOGUS, OPT_VERSION, OPT_HELP, OPT_ABORT_ON_PANIC, OPT_MANGLE, OPT_INCLUDE, OPT_PRAGMA, OPT_BEFORE, OPT_LIMIT, OPT_KEEP_ALL, OPT_NO_LINE, OPT_DEBUG, OPT_INFO, OPT_REPRODUCIBLE, OPT_BITS }; enum need_arg { ARG_NO, ARG_YES, ARG_MAYBE }; struct textargs { const char *label; enum text_options opt; enum need_arg need_arg; int pvt; }; static const struct textargs textopts[] = { {"v", OPT_VERSION, ARG_NO, 0}, {"version", OPT_VERSION, ARG_NO, 0}, {"help", OPT_HELP, ARG_MAYBE, 0}, {"abort-on-panic", OPT_ABORT_ON_PANIC, ARG_NO, 0}, {"prefix", OPT_MANGLE, ARG_YES, D_PREFIX}, {"postfix", OPT_MANGLE, ARG_YES, D_POSTFIX}, {"suffix", OPT_MANGLE, ARG_YES, D_SUFFIX}, {"gprefix", OPT_MANGLE, ARG_YES, D_GPREFIX}, {"gpostfix", OPT_MANGLE, ARG_YES, D_GPOSTFIX}, {"gsuffix", OPT_MANGLE, ARG_YES, D_GSUFFIX}, {"lprefix", OPT_MANGLE, ARG_YES, D_LPREFIX}, {"lpostfix", OPT_MANGLE, ARG_YES, D_LPOSTFIX}, {"lsuffix", OPT_MANGLE, ARG_YES, D_LSUFFIX}, {"include", OPT_INCLUDE, ARG_YES, 0}, {"pragma", OPT_PRAGMA, ARG_YES, 0}, {"before", OPT_BEFORE, ARG_YES, 0}, {"limit-", OPT_LIMIT, ARG_YES, 0}, {"keep-all", OPT_KEEP_ALL, ARG_NO, 0}, {"no-line", OPT_NO_LINE, ARG_NO, 0}, {"info", OPT_INFO , ARG_MAYBE, 0}, {"verbose", OPT_INFO , ARG_MAYBE, 0}, {"debug", OPT_DEBUG, ARG_MAYBE, 0}, {"reproducible", OPT_REPRODUCIBLE, ARG_NO, 0}, {"bits", OPT_BITS, ARG_YES, 0}, {NULL, OPT_BOGUS, ARG_NO, 0} }; static void show_version(void) { printf("NASM version %s%s\n", nasm_version, nasm_compile_options); exit(0); } static bool stopoptions = false; static bool process_arg(char *p, char *q, int pass) { char *param; bool advance = false; if (!p || !p[0]) return false; if (p[0] == '-' && !stopoptions) { if (strchr("oOfpPdDiIlLFXuUZwW@", p[1])) { /* These parameters take values */ if (!(param = get_param(p, q, &advance))) return advance; } switch (p[1]) { case '@': open_and_process_respfile(param, pass); break; case 's': if (pass == 1) error_file = stdout; break; case 'o': /* output file */ if (pass == 2) copy_filename(&outname, param, "output"); break; case 'f': /* output format */ if (pass == 1) { ofmt = ofmt_find(param, &ofmt_alias); if (!ofmt) { nasm_fatalf(ERR_USAGE, "unrecognised output format `%s' - use -hf for a list", param); } } break; case 'O': /* Optimization level */ if (pass == 1) { int opt; if (!*param) { /* Naked -O == -Ox */ optimizing = OPTIM_ALL_ENABLED; } else { while (*param) { switch (*param) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': opt = strtoul(param, ¶m, 10); switch (opt) { case 0: optimizing = OPTIM_LEVEL_0; break; case 1: optimizing = OPTIM_LEVEL_1; break; default: optimizing = OPTIM_ALL_ENABLED; break; } break; case 'v': case '+': param++; opt_verbose_info++; break; case 'x': param++; optimizing = OPTIM_ALL_ENABLED; break; default: nasm_fatal("unknown optimization option -O%c\n", *param); break; } } } } break; case 'p': /* pre-include */ case 'P': if (pass == 2) pp_pre_include(param); break; case 'd': /* pre-define */ case 'D': if (pass == 2) pp_pre_define(param); break; case 'u': /* un-define */ case 'U': if (pass == 2) pp_pre_undefine(param); break; case 'i': /* include search path */ case 'I': if (pass == 1) strlist_add(include_path, param); break; case 'l': /* listing file */ if (pass == 2) copy_filename(&listname, param, "listing"); break; case 'L': /* listing options */ if (pass == 2) { while (*param) list_options |= list_option_mask(*param++); } break; case 'Z': /* error messages file */ if (pass == 1) copy_filename(&errname, param, "error"); break; case 'F': /* specify debug format */ if (pass == 1) { using_debug_info = true; debug_format = param; } break; case 'X': /* specify error reporting format */ if (pass == 1) { if (!nasm_stricmp("vc", param) || !nasm_stricmp("msvc", param) || !nasm_stricmp("ms", param)) errfmt = &errfmt_msvc; else if (!nasm_stricmp("gnu", param) || !nasm_stricmp("gcc", param)) errfmt = &errfmt_gnu; else nasm_fatalf(ERR_USAGE, "unrecognized error reporting format `%s'", param); } break; case 'g': if (pass == 1) { using_debug_info = true; if (p[2]) debug_format = nasm_skip_spaces(p + 2); } break; case 'h': case '?': help(stdout, get_opt_param(p, q, &advance)); exit(0); /* never need usage message here */ break; case 'y': /* legacy option */ help(stdout, "-F"); exit(0); break; case 't': if (pass == 1) tasm_compatible_mode = true; break; case 'v': show_version(); break; case 'e': /* preprocess only */ case 'E': if (pass == 1) operating_mode = OP_PREPROCESS; break; case 'a': /* assemble only - don't preprocess */ if (pass == 1) ppopt |= PP_TRIVIAL; break; case 'w': case 'W': if (pass == 2) set_warning_status(param); break; case 'M': if (pass == 1) { switch (p[2]) { case 'W': quote_for_make = quote_for_wmake; break; case 'D': case 'F': case 'T': case 'Q': advance = true; break; default: break; } } else { switch (p[2]) { case 0: operating_mode = OP_DEPEND; break; case 'G': operating_mode = OP_DEPEND; depend_missing_ok = true; break; case 'P': depend_emit_phony = true; break; case 'D': operating_mode |= OP_DEPEND; if (q && (q[0] != '-' || q[1] == '\0')) { depend_file = q; advance = true; } break; case 'F': depend_file = q; advance = true; break; case 'T': depend_target = q; advance = true; break; case 'Q': depend_target = quote_for_make(q); advance = true; break; case 'W': /* handled in pass 1 */ break; default: nasm_nonfatalf(ERR_USAGE, "unknown dependency option `-M%c'", p[2]); break; } } if (advance && (!q || !q[0])) { nasm_nonfatalf(ERR_USAGE, "option `-M%c' requires a parameter", p[2]); break; } break; case '-': { const struct textargs *tx; size_t olen, plen; char *eqsave; enum text_options opt; p += 2; if (!*p) { /* -- => stop processing options */ stopoptions = true; break; } olen = 0; /* Placate gcc at lower optimization levels */ plen = strlen(p); for (tx = textopts; tx->label; tx++) { olen = strlen(tx->label); if (olen > plen) continue; if (nasm_memicmp(p, tx->label, olen)) continue; if (tx->label[olen-1] == '-') break; /* Incomplete option */ if (!p[olen] || p[olen] == '=') break; /* Complete option */ } if (!tx->label) { nasm_nonfatalf(ERR_USAGE, "unrecognized option `--%s'", p); } opt = tx->opt; eqsave = param = strchr(p+olen, '='); if (param) *param++ = '\0'; switch (tx->need_arg) { case ARG_YES: /* Argument required, and may be standalone */ if (!param) { param = q; advance = true; } /* Note: a null string is a valid parameter */ if (!param) { nasm_nonfatalf(ERR_USAGE, "option `--%s' requires an argument", p); opt = OPT_BOGUS; } break; case ARG_NO: /* Argument prohibited */ if (param) { nasm_nonfatalf(ERR_USAGE, "option `--%s' does not take an argument", p); opt = OPT_BOGUS; } break; case ARG_MAYBE: /* Argument permitted, but must be attached with = */ break; } switch (opt) { case OPT_BOGUS: break; /* We have already errored out */ case OPT_VERSION: show_version(); break; case OPT_ABORT_ON_PANIC: abort_on_panic = true; break; case OPT_MANGLE: if (pass == 2) set_label_mangle(tx->pvt, param); break; case OPT_INCLUDE: if (pass == 2) pp_pre_include(q); break; case OPT_PRAGMA: if (pass == 2) pp_pre_command("%pragma", param); break; case OPT_BITS: if (pass == 2) pp_pre_command("BITS", param); break; case OPT_BEFORE: if (pass == 2) pp_pre_command(NULL, param); break; case OPT_LIMIT: if (pass == 1) nasm_set_limit(p+olen, param); break; case OPT_KEEP_ALL: keep_all = true; break; case OPT_NO_LINE: ppopt |= PP_NOLINE; break; case OPT_DEBUG: if (pass == 1) debug_nasm = param ? strtoul(param, NULL, 10) : debug_nasm+1; break; case OPT_INFO: if (pass == 1) opt_verbose_info = param ? strtoul(param, NULL, 10) : opt_verbose_info+1; break; case OPT_REPRODUCIBLE: reproducible = true; break; case OPT_HELP: /* Allow --help topic without *requiring* topic */ if (!param) param = q; help(stdout, param); exit(0); default: panic(); } if (eqsave) *eqsave = '='; /* Restore = argument separator */ break; } default: nasm_nonfatalf(ERR_USAGE, "unrecognised option `-%c'", p[1]); break; } } else if (pass == 2) { /* In theory we could allow multiple input files... */ copy_filename(&inname, p, "input"); } return advance; } #define ARG_BUF_DELTA 128 static void process_respfile(FILE * rfile, int pass) { char *buffer, *p, *q, *prevarg; int bufsize, prevargsize; bufsize = prevargsize = ARG_BUF_DELTA; buffer = nasm_malloc(ARG_BUF_DELTA); prevarg = nasm_malloc(ARG_BUF_DELTA); prevarg[0] = '\0'; while (1) { /* Loop to handle all lines in file */ p = buffer; while (1) { /* Loop to handle long lines */ q = fgets(p, bufsize - (p - buffer), rfile); if (!q) break; p += strlen(p); if (p > buffer && p[-1] == '\n') break; if (p - buffer > bufsize - 10) { int offset; offset = p - buffer; bufsize += ARG_BUF_DELTA; buffer = nasm_realloc(buffer, bufsize); p = buffer + offset; } } if (!q && p == buffer) { if (prevarg[0]) process_arg(prevarg, NULL, pass); nasm_free(buffer); nasm_free(prevarg); return; } /* * Play safe: remove CRs, LFs and any spurious ^Zs, if any of * them are present at the end of the line. */ *(p = &buffer[strcspn(buffer, "\r\n\032")]) = '\0'; while (p > buffer && nasm_isspace(p[-1])) *--p = '\0'; p = nasm_skip_spaces(buffer); if (process_arg(prevarg, p, pass)) *p = '\0'; if ((int) strlen(p) > prevargsize - 10) { prevargsize += ARG_BUF_DELTA; prevarg = nasm_realloc(prevarg, prevargsize); } strncpy(prevarg, p, prevargsize); } } /* Function to process args from a string of args, rather than the * argv array. Used by the environment variable and response file * processing. */ static void process_args(char *args, int pass) { char *p, *q, *arg, *prevarg; char separator = ' '; p = args; if (*p && *p != '-') separator = *p++; arg = NULL; while (*p) { q = p; while (*p && *p != separator) p++; while (*p == separator) *p++ = '\0'; prevarg = arg; arg = q; if (process_arg(prevarg, arg, pass)) arg = NULL; } if (arg) process_arg(arg, NULL, pass); } static void process_response_file(const char *file, int pass) { char str[2048]; FILE *f = nasm_open_read(file, NF_TEXT); if (!f) { perror(file); exit(-1); } while (fgets(str, sizeof str, f)) { process_args(str, pass); } fclose(f); } static void open_and_process_respfile(char *respfile, int pass) { FILE *rfile; rfile = nasm_open_read(respfile, NF_TEXT); if (rfile) { process_respfile(rfile, pass); fclose(rfile); } else { nasm_nonfatalf(ERR_USAGE, "unable to open response file `%s'", respfile); } } static void parse_cmdline(int argc, char **argv, int pass) { char *envreal, *envcopy = NULL; /* * Initialize all the warnings to their default state, including * warning index 0 used for "always on". */ memcpy(warning_state, warning_default, sizeof warning_state); /* * First, process the NASMENV environment variable. */ envreal = getenv("NASMENV"); if (envreal) { envcopy = nasm_strdup(envreal); process_args(envcopy, pass); nasm_free(envcopy); } /* * Now process the actual command line. */ while (--argc) { bool advance; argv++; if (argv[0][0] == '@') { /* * We have a response file, so process this as a set of * arguments like the environment variable. This allows us * to have multiple arguments on a single line, which is * different to the -@resp file processing below for regular * NASM. */ process_response_file(argv[0]+1, pass); argc--; argv++; } advance = process_arg(argv[0], argc > 1 ? argv[1] : NULL, pass); argv += advance, argc -= advance; } /* * Look for basic command line typos. This definitely doesn't * catch all errors, but it might help cases of fumbled fingers. */ if (pass != 2) return; if (!inname) nasm_fatalf(ERR_USAGE, "no input file specified"); else if ((errname && !strcmp(inname, errname)) || (outname && !strcmp(inname, outname)) || (listname && !strcmp(inname, listname)) || (depend_file && !strcmp(inname, depend_file))) nasm_fatalf(ERR_USAGE, "will not overwrite input file"); if (errname) { error_file = nasm_open_write(errname, NF_TEXT); if (!error_file) { error_file = stderr; /* Revert to default! */ nasm_fatalf(ERR_USAGE, "cannot open file `%s' for error messages", errname); } } } static void forward_refs(insn *instruction) { int i; struct forwrefinfo *fwinf; /* Don't bother for -O1 */ if (instruction->opt & OPTIM_DISABLE_FWREF) return; if (!forwref) return; if (forwref->lineno != globallineno) return; do { instruction->oprs[forwref->operand].opflags |= OPFLAG_FORWARD; forwref = saa_rstruct(forwrefs); } while (forwref && forwref->lineno == globallineno); if (!pass_first()) return; for (i = 0; i < instruction->operands; i++) { if (instruction->oprs[i].opflags & OPFLAG_FORWARD) { fwinf = saa_wstruct(forwrefs); fwinf->lineno = globallineno; fwinf->operand = i; } } } static void assemble_file(const char *fname, struct strlist *depend_list) { char *line; insn output_ins; uint64_t prev_offset_changed; int64_t stall_count = 0; /* Make sure we make forward progress... */ switch (cmd_sb) { case 16: break; case 32: if (!iflag_cpu_level_ok(&cmd_cpu, IF_386)) nasm_fatal("command line: 32-bit segment size requires a higher cpu"); break; case 64: if (!iflag_cpu_level_ok(&cmd_cpu, IF_X86_64)) nasm_fatal("command line: 64-bit segment size requires a higher cpu"); break; default: panic(); break; } prev_offset_changed = INT64_MAX; if (listname && !keep_all) { /* Remove the list file in case we die before the output pass */ remove(listname); } while (!terminate_after_phase && !pass_final()) { _passn++; switch (pass_type()) { case PASS_INIT: _pass_type = PASS_FIRST; break; case PASS_OPT: if (global_offset_changed) break; /* One more optimization pass */ /* fall through */ default: _pass_type++; break; } global_offset_changed = 0; /* * Create a warning buffer list unless we are in * pass 2 (everything will be emitted immediately in pass 2.) */ if (warn_list) { if (warn_list->nstr || pass_final()) strlist_free(&warn_list); } if (!pass_final() && !warn_list) warn_list = strlist_alloc(false); /* Suppress ERR_PASS2 unless we are actually in the final pass */ errflags_never = 0; if (!pass_final()) errflags_never |= ERR_PASS2; globl.bits = cmd_sb; /* set 'bits' to command line default */ globl.bnd = false; globl.rel = 0; globl.reldef = EAF_FS|EAF_GS; /* For now, don't warn on fs:/gs: absolute */ globl.dollarhex = true; cpu = cmd_cpu; if (listname) { if (list_on_this_pass()) { /* * Generating a list file on this pass. */ lfmt->init(listname); } else if (list_active()) { /* * Looks like we used the list engine on a previous pass, * but now it is turned off, presumably via %pragma -p */ lfmt->cleanup(); if (!keep_all) remove(listname); } } in_absolute = false; if (!pass_first()) { saa_rewind(forwrefs); forwref = saa_rstruct(forwrefs); raa_free(offsets); offsets = raa_init(); } location.segment = NO_SEG; location.offset = 0; if (pass_first()) location.known = true; ofmt->reset(); switch_segment(ofmt->section(NULL, &globl.bits)); pp_reset(fname, PP_NORMAL, depend_list); globallineno = 0; while ((line = pp_getline())) { if (++globallineno > nasm_limit[LIMIT_LINES]) nasm_fatal("overall line count exceeds the maximum %"PRId64"\n", nasm_limit[LIMIT_LINES]); /* * Here we parse our directives; this is not handled by the * main parser. */ if (process_directives(line)) goto end_of_line; /* Just do final cleanup */ /* Not a directive, or even something that starts with [ */ parse_line(line, &output_ins, globl.bits); forward_refs(&output_ins); process_insn(&output_ins); cleanup_insn(&output_ins); end_of_line: nasm_free(line); } /* end while (line = pp_getline... */ pp_cleanup_pass(); /* We better not be having an error hold still... */ nasm_assert(!errhold_stack); if (global_offset_changed) { switch (pass_type()) { case PASS_OPT: /* * This is the only pass type that can be executed more * than once, and therefore has the ability to stall. */ if (global_offset_changed < prev_offset_changed) { prev_offset_changed = global_offset_changed; stall_count = 0; } else { stall_count++; } if (stall_count > nasm_limit[LIMIT_STALLED] || pass_count() >= nasm_limit[LIMIT_PASSES]) { /* No convergence, almost certainly dead */ nasm_nonfatalf(ERR_UNDEAD, "unable to find valid values for all labels " "after %"PRId64" passes; " "stalled for %"PRId64", giving up.", pass_count(), stall_count); nasm_nonfatalf(ERR_UNDEAD, "Possible causes: recursive EQUs, macro abuse."); } break; case PASS_STAB: nasm_warn(WARN_PHASE|ERR_UNDEAD, "phase error during stabilization " "pass, hoping for the best"); break; case PASS_FINAL: nasm_nonfatalf(ERR_UNDEAD, "phase error during code generation pass"); break; default: /* This is normal, we'll keep going... */ break; } } reset_warnings(); } if (pass_final()) { /* -On and -Ov switches */ nasm_info(1, "assembly required 1+%"PRId64"+2 passes\n", pass_count()-3); } lfmt->cleanup(); strlist_free(&warn_list); } static bool skip_this_pass(errflags severity) { errflags type = severity & ERR_MASK; /* * See if it's a pass-specific error or warning which should be skipped. * We can never skip fatal errors as by definition they cannot be * resumed from. */ if (type >= ERR_FATAL) return false; /* * ERR_LISTMSG and ERR_NOTE messages are always skipped; the list * file receives them anyway as this function is not consulted for * sending to the list file. */ if (type <= ERR_NOTE) return true; /* * This message is not applicable unless it is the last pass we * are going to execute; this can be either the final * code-generation pass or the single pass executed in * preproc-only mode. */ return (severity & ERR_PASS2) && !pass_final_or_preproc(); } /** * check for suppressed message (usually warnings or notes) * * @param severity the severity of the warning or error * @return true if we should abort error/warning printing */ static bool is_suppressed(errflags flags) { const errflags severity = flags & ERR_MASK; const errflags level = WARN_IDX(flags); if (severity >= ERR_FATAL) { /* Fatal errors or higher can never be suppressed */ return false; } if (flags & errflags_never) return true; switch (severity) { case ERR_WARNING: if (!(warning_state[level] & WARN_ST_ENABLED)) return true; break; case ERR_INFO: if (!info_level(level)) return true; break; case ERR_DEBUG: if (!debug_level(level)) return true; break; default: break; } /* Suppressed by the preprocessor? */ if (!(flags & ERR_PP_LISTMACRO)) return pp_suppress_error(flags); return false; } /** * Return the true error type (the ERR_MASK part) of the given * severity, accounting for warnings that may need to be promoted to * error. * * @param severity the severity of the warning or error * @return true if we should error out */ static errflags pure_func true_error_type(errflags severity) { const uint8_t warn_is_err = WARN_ST_ENABLED|WARN_ST_ERROR; int type; type = severity & ERR_MASK; /* Promote warning to error? */ if (type == ERR_WARNING) { uint8_t state = warning_state[WARN_IDX(severity)]; if ((state & warn_is_err) == warn_is_err) type = ERR_NONFATAL; } return type; } static const char no_file_name[] = "nasm"; /* What to print if no file name */ /* * For fatal/critical/panic errors, kill this process. */ static_fatal_func die_hard(errflags true_type, errflags severity) { fflush(NULL); if (true_type == ERR_PANIC && abort_on_panic) abort(); if (ofile) { fclose(ofile); if (!keep_all) remove(outname); ofile = NULL; } if (severity & ERR_USAGE) usage(); /* Terminate immediately */ exit(true_type - ERR_FATAL + 1); } /* * Returns the struct src_location appropriate for use, after some * potential filename mangling. */ static struct src_location error_where(errflags severity) { struct src_location where; if (severity & ERR_NOFILE) { where.filename = NULL; where.lineno = 0; } else { where = src_where_error(); if (!where.filename) { where.filename = inname && inname[0] ? inname : outname && outname[0] ? outname : NULL; where.lineno = 0; } } return where; } /* * error reporting for critical and panic errors: minimize * the amount of system dependencies for getting a message out, * and in particular try to avoid memory allocations. */ fatal_func nasm_verror_critical(errflags severity, const char *fmt, va_list args) { struct src_location where; errflags true_type = severity & ERR_MASK; static bool been_here = false; if (unlikely(been_here)) abort(); /* Recursive error... just die */ been_here = true; where = error_where(severity); if (!where.filename) where.filename = no_file_name; fputs(error_pfx(severity), error_file); fputs(where.filename, error_file); if (where.lineno) { fprintf(error_file, "%s%"PRId32"%s", errfmt->beforeline, where.lineno, errfmt->afterline); } fputs(errfmt->beforemsg, error_file); vfprintf(error_file, fmt, args); fputc('\n', error_file); die_hard(true_type, severity); } /** * Stack of tentative error hold lists. */ struct nasm_errtext { struct nasm_errtext *next; char *msg; /* Owned by this structure */ struct src_location where; /* Owned by the srcfile system */ errflags severity; errflags true_type; }; struct nasm_errhold { struct nasm_errhold *up; struct nasm_errtext *head, **tail; }; static void nasm_free_error(struct nasm_errtext *et) { nasm_free(et->msg); nasm_free(et); } static void nasm_issue_error(struct nasm_errtext *et); struct nasm_errhold *nasm_error_hold_push(void) { struct nasm_errhold *eh; nasm_new(eh); eh->up = errhold_stack; eh->tail = &eh->head; errhold_stack = eh; return eh; } /* Pop an error hold. Returns the highest severity issued or dropped. */ errflags nasm_error_hold_pop(struct nasm_errhold *eh, bool issue) { struct nasm_errtext *et, *etmp; errflags worst = 0; /* * Allow calling with a null argument saying no hold in the first place. */ if (!eh) return worst; /* This *must* be the current top of the errhold stack */ nasm_assert(eh == errhold_stack); if (eh->head) { if (issue) { if (eh->up) { /* Commit the current hold list to the previous level */ *eh->up->tail = eh->head; eh->up->tail = eh->tail; } else { /* Issue errors */ list_for_each_safe(et, etmp, eh->head) { if (et->true_type > worst) worst = et->true_type; nasm_issue_error(et); } } } else { /* Free the list, drop errors */ list_for_each_safe(et, etmp, eh->head) { if (et->true_type > worst) worst = et->true_type; nasm_free_error(et); } } } errhold_stack = eh->up; nasm_free(eh); return worst; } /** * common error reporting * This is the common back end of the error reporting schemes currently * implemented. It prints the nature of the warning and then the * specific error message to error_file and may or may not return. It * doesn't return if the error severity is a "panic" or "debug" type. * * @param severity the severity of the warning or error * @param fmt the printf style format string */ void nasm_verror(errflags severity, const char *fmt, va_list args) { struct nasm_errtext *et; errflags true_type = true_error_type(severity); if (true_type >= ERR_CRITICAL) { nasm_verror_critical(severity, fmt, args); abort(); } if (is_suppressed(severity)) return; nasm_new(et); et->severity = severity; et->true_type = true_type; et->msg = nasm_vasprintf(fmt, args); et->where = error_where(severity); if (errhold_stack && true_type <= ERR_NONFATAL) { /* It is a tentative error */ *errhold_stack->tail = et; errhold_stack->tail = &et->next; } else { nasm_issue_error(et); } /* * Don't do this before then, if we do, we lose messages in the list * file, as the list file is only generated in the last pass. */ if (skip_this_pass(severity)) return; if (!(severity & (ERR_HERE|ERR_PP_LISTMACRO))) pp_error_list_macros(severity); } /* * Actually print, list and take action on an error */ static void nasm_issue_error(struct nasm_errtext *et) { const char *pfx; char warnsuf[64]; /* Warning suffix */ char linestr[64]; /* Formatted line number if applicable */ const errflags severity = et->severity; const errflags true_type = et->true_type; const struct src_location where = et->where; if (severity & ERR_NO_SEVERITY) pfx = ""; else pfx = error_pfx(true_type); *warnsuf = 0; if (!(severity & (ERR_HERE|ERR_PP_LISTMACRO))) { const unsigned int level = WARN_IDX(severity); switch (severity & ERR_MASK) { case ERR_WARNING: snprintf(warnsuf, sizeof warnsuf, " [-w+%s%s]", (true_type >= ERR_NONFATAL) ? "error=" : "", warning_name[level]); break; case ERR_DEBUG: snprintf(warnsuf, sizeof warnsuf, " [--debug=%u]", debug_nasm); break; case ERR_INFO: snprintf(warnsuf, sizeof warnsuf, " [--info=%u]", opt_verbose_info); break; default: /* Not WARNING, DEBUG or INFO, not suppressible */ break; } } *linestr = 0; if (where.lineno) { snprintf(linestr, sizeof linestr, "%s%"PRId32"%s", errfmt->beforeline, where.lineno, errfmt->afterline); } if (!skip_this_pass(severity)) { const char *file = where.filename ? where.filename : no_file_name; const char *here = ""; if (severity & ERR_HERE) { here = where.filename ? " here" : " in an unknown location"; } if (warn_list && true_type < ERR_NONFATAL) { /* * Buffer up warnings until we either get an error * or we are on the code-generation pass. */ strlist_printf(warn_list, "%s%s%s%s%s%s%s", file, linestr, errfmt->beforemsg, pfx, et->msg, here, warnsuf); } else { /* * Actually output an error. If we have buffered * warnings, and this is a non-warning, output them now. */ if (true_type >= ERR_NONFATAL && warn_list) { strlist_write(warn_list, "\n", error_file); strlist_free(&warn_list); } fprintf(error_file, "%s%s%s%s%s%s%s\n", file, linestr, errfmt->beforemsg, pfx, et->msg, here, warnsuf); } } /* Are we recursing from error_list_macros? */ if (severity & ERR_PP_LISTMACRO) goto done; /* * Don't suppress this with skip_this_pass(), or we don't get * pass1 or preprocessor warnings in the list file */ if (severity & ERR_HERE) { if (where.lineno) lfmt->error(severity, "%s%s at %s:%"PRId32"%s", pfx, et->msg, where.filename, where.lineno, warnsuf); else if (where.filename) lfmt->error(severity, "%s%s in file %s%s", pfx, et->msg, where.filename, warnsuf); else lfmt->error(severity, "%s%s in an unknown location%s", pfx, et->msg, warnsuf); } else { lfmt->error(severity, "%s%s%s", pfx, et->msg, warnsuf); } if (skip_this_pass(severity)) goto done; if (true_type >= ERR_FATAL) die_hard(true_type, severity); else if (true_type >= ERR_NONFATAL) { terminate_after_phase = true; errflags_never |= ERR_UNDEAD; } done: nasm_free_error(et); } static void usage(void) { fprintf(error_file, "Usage: %s [-@ response_file] [options...] [--] filename\n" " For additional help:\n" " %s -h [run|topics|all|-option]\n", _progname, _progname); } enum help_with { HW_ALL = 0, HW_OPT = 1, HW_ERR = 2, HW_LIMIT = 3 }; static inline bool help_is(int with, int h) { return with == HW_ALL || with == h; } static inline bool help_opt(int with) { return help_is(with, HW_OPT); } static inline bool help_optor(int with, int h) { return help_opt(with) || with == h; } static void help(FILE *out, const char *what) { int i; int with; #define SEE(x) (with == HW_OPT ? " (see -h " x ")" : "") with = HW_ERR; if (!what || !*what || !strcmp(what, "-") || !strcmp(what, "--") || !nasm_stricmp(what, "opt") || !nasm_stricmp(what, "run") || !nasm_stricmp(what, "cmd")) { with = HW_OPT; } else if (!nasm_stricmp(what, "all")) { with = HW_ALL; } else if (!nasm_strnicmp(what, "--limit", 7) || !nasm_strnicmp(what, "limit", 5)) { with = HW_LIMIT; } else if (!nasm_stricmp(what, "--help") || !nasm_stricmp(what, "help") || !nasm_stricmp(what, "list") || !nasm_stricmp(what, "topics") || !nasm_stricmp(what, "index")) { with = 'h'; } else if ((what[0] == '-' && what[1] && !what[2]) || (what[0] && !what[1])) { with = what[0] == '-' ? what[1] : what[0]; switch (with) { case 'h': case 'X': case 'L': case 'f': case 'F': case 'O': case 'w': case 'M': break; case 'g': with = 'F'; break; case 'W': with = 'w'; break; case '?': with = 'h'; break; case '*': with = HW_ALL; break; default: with = HW_ERR; break; } } if (with == HW_ERR) { fprintf(out, "Sorry, no help available for `%s'\n", what); return; } if (help_opt(with)) { fprintf(out, "Usage: %s [-@ response_file] [options...] [--] filename\n" " Options:\n" " -v (or --v) print the NASM version number and exit\n" " -@ file response file; one command line option per line\n", _progname); } if (help_optor(with, 'h')) { fputs( " -h list command line options and exit (also --help)\n" , out); if (with == HW_OPT) { fputs( " -h -opt show additional help for option \"-opt\"\n" , out); } fputs( " -h all show all available command line help\n" " -h topics show list of help topics (also -h list)\n" , out); } if (help_is(with, 'h')) { fputs( " -h -X show list of error message formats\n" " -h -M show list of dependency generation options\n" " -h -f show list of object code output formats\n" " -h -F show list of debug information formats\n" " -h -L show list of list file option flags\n" " -h -O show list of optimization flags\n" " -h -w show list of warning classes and defaults\n" " -h --limit show list of resource limits and defaults\n" , out); } if (help_opt(with)) { fputs( " -o outfile write output to outfile\n" " --keep-all output files will not be removed even if an error happens\n" , out); } if (help_optor(with, 'X')) { fprintf(out, " -Xformat specify error reporting format%s\n", SEE("-X")); } if (help_is(with, 'X')) { fputs( " -Xgnu report errors in GNU format (default)\n" " -Xgcc alias for -Xgnu\n" " -Xvc report errors in Visual Studio format\n" " -Xmsvc alias for -Xvc\n" " -Xms alias for -Xvc\n" , out); } if (help_opt(with)) { fputs( " -s redirect messages to stdout\n" " -Zfile redirect messages to file\n" " --info[=lvl] display optional informational messages\n" " --debug[=lvl] display NASM internal debugging messages\n" , out); } if (help_optor(with, 'M')) { fprintf(out, " -M... generate Makefile dependencies%s\n", with == HW_OPT ? " (see -h -M)" : " (multiple options permitted):"); } if (help_is(with, 'M')) { fputs( " -M generate Makefile dependencies on stdout\n" " -MG d:o, missing files assumed generated\n" " -MF file set Makefile dependency file\n" " -MD file assemble and generate dependencies\n" " -MT file dependency target name\n" " -MQ file dependency target name (quoted)\n" " -MP emit phony targets\n" " -MW generate output in Watcom wmake syntax\n" , out); } if (help_optor(with, 'f')) { fprintf(out, " -f format select output file format%s\n", SEE("-f")); } if (help_is(with, 'f')) { ofmt_list(ofmt, out); } if (help_optor(with, 'F')) { fprintf(out, " -g generate debugging information\n" " -F format select a debugging format%s\n" " -gformat same as -g -F format\n", SEE("-F")); } if (help_is(with, 'F')) { dfmt_list(out); } if (help_optor(with, 'L')) { fprintf(out, " -l listfile write listing to a list file\n" " -Lflags... add information to the list file%s\n", SEE("-L")); } if (help_is(with, 'L')) { fputs( " -Lb show builtin macro packages (standard and %use)\n" " -Ld show byte and repeat counts in decimal, not hex\n" " -Le show the preprocessed output\n" " -Lf ignore .nolist (force output)\n" " -LF ignore [LIST -] directives (force output)\n" " -Lm show multi-line macro calls with expanded parameters\n" " -Lp output a list file every pass, in case of errors\n" " -Ls show all single-line macro definitions\n" " -Lw flush the output after every line (very slow!)\n" " -L+ enable all listing options except -Lw (very verbose!)\n" , out); } if (help_optor(with, 'O')) { fprintf(out, " -Oflags... select optimization%s\n", SEE("-O")); } if (help_is(with, 'O')) { fputs( " -O0 no optimization\n" " -O1 minimal optimization\n" " -Ox multipass optimization (default, recommended)\n" " -Ov display the number of passes executed at the end\n" , out); } if (help_opt(with)) { fputs( " -t assemble in limited SciTech TASM compatible mode\n" " -E (or -e) preprocess only (writes output to stdout by default)\n" " -a don't preprocess (assemble only)\n" " -Ipath add a pathname to the include file path\n" " -Pfile pre-include a file (also --include)\n" " -Dmacro[=str] pre-define a macro\n" " -Umacro undefine a macro\n" , out); } if (help_optor(with, 'w')) { fprintf(out, " -w+x enable warning x %s(also -Wx)\n" " -w-x disable warning x (also -Wno-x)\n" " -w[+-]error promote all warnings to errors (also -Werror)\n" " -w[+-]error=x promote warning x to errors (also -Werror=x)\n", SEE("-w")); } if (help_is(with, 'w')) { fputs(" Defaults in brackets:\n", out); fprintf(out, " %-20s %s\n", warning_name[WARN_IDX_ALL], warning_help[WARN_IDX_ALL]); for (i = 1; i < WARN_IDX_ALL; i++) { static const char nl_indent[] = "\n "; const char *me = warning_name[i]; const char *prev = warning_name[i-1]; const char *next = warning_name[i+1]; if (prev) { int prev_len = strlen(prev); const char *dash = me; while ((dash = strchr(dash+1, '-'))) { int prefix_len = dash - me; /* Not including final dash */ if (strncmp(next, me, prefix_len+1)) { /* Only one or last option with this prefix */ break; } if (prefix_len >= prev_len || strncmp(prev, me, prefix_len) || (prev[prefix_len] != '-' && prev[prefix_len] != '\0')) { /* This prefix is different from the previous option */ fprintf(out, " %-20.*s%sall warnings prefixed with \"%.*s\"\n", prefix_len, me, prefix_len > 19 ? nl_indent : " ", prefix_len+1, me); } } } fprintf(out, " %-20s%s%s%s\n", warning_name[i], strlen(warning_name[i]) > 19 ? nl_indent : " ", warning_help[i], (warning_default[i] & WARN_ST_ERROR) ? " [error]" : (warning_default[i] & WARN_ST_ENABLED) ? " [on]" : " [off]"); } } if (help_opt(with)) { fputs( " --pragma str pre-executes a specific %pragma\n" " --before str add line (usually a preprocessor statement) before the input\n" " --bits nn set bits to nn (equivalent to --before \"BITS nn\")\n" " --no-line ignore %line directives in input\n" " --gprefix str prepend the given string to the names of all extern,\n" " common and global symbols (also --prefix)\n" " --gpostfix str append the given string to the names of all extern,\n" " common and global symbols (also --postfix)\n" " --lprefix str prepend the given string to local symbols\n" " --lpostfix str append the given string to local symbols\n" " --reproducible attempt to produce run-to-run identical output\n" , out); } if (help_optor(with, HW_LIMIT)) { fprintf(out, " --limit-X val set execution limit X%s\n", SEE("--limit")); } if (help_is(with, HW_LIMIT)) { fputs(" Defaults in brackets:\n", out); for (i = 0; i <= LIMIT_MAX; i++) { fprintf(out, " %-20s %s [", limit_info[i].name, limit_info[i].help); if (nasm_limit[i] < LIMIT_MAX_VAL) { fprintf(out, "%"PRId64"]\n", nasm_limit[i]); } else { fputs("unlimited]\n", out); } } } #undef SEE }