diff --git a/asm/error.c b/asm/error.c index 969bb28f..fa8d2d62 100644 --- a/asm/error.c +++ b/asm/error.c @@ -46,38 +46,44 @@ * Description of the suppressible warnings for the command line and * the [warning] directive. */ -const struct warning warnings[WARN_ALL+1] = { - { "other", "any warning not specifially mentioned below", true }, - { "macro-params", "macro calls with wrong parameter count", true }, - { "macro-selfref", "cyclic macro references", false }, - { "macro-defaults", "macros with more default than optional parameters", true }, - { "orphan-labels", "labels alone on lines without trailing `:'", true }, - { "number-overflow", "numeric constant does not fit", true }, - { "gnu-elf-extensions", "using 8- or 16-bit relocation in ELF32, a GNU extension", false }, - { "float-overflow", "floating point overflow", true }, - { "float-denorm", "floating point denormal", false }, - { "float-underflow", "floating point underflow", false }, - { "float-toolong", "too many digits in floating-point number", true }, - { "user", "%warning directives", true }, - { "lock", "lock prefix on unlockable instructions", true }, - { "hle", "invalid hle prefixes", true }, - { "bnd", "invalid bnd prefixes", true }, - { "zext-reloc", "relocation zero-extended to match output format", true }, - { "ptr", "non-NASM keyword used in other assemblers", true }, - { "bad-pragma", "empty or malformed %pragma", false }, - { "unknown-pragma", "unknown %pragma facility or directive", false }, - { "not-my-pragma", "%pragma not applicable to this compilation", false }, - { "unknown-warning", "unknown warning in -W/-w or warning directive", false }, - { "negative-rep", "regative %rep count", true }, - { "phase", "phase error during stabilization", false }, +#define on (WARN_ST_ENABLED) +#define off 0 +#define err (WARN_ST_ENABLED|WARN_ST_ERROR) - /* THIS ENTRY MUST COME LAST */ - { "all", "all possible warnings", false } +const struct warning warnings[WARN_ALL+1] = { + {NULL, NULL, on}, /* must be on - used for unconditional enable */ + {"macro-params", "macro calls with wrong parameter count", on}, + {"macro-selfref", "cyclic macro references", off}, + {"macro-defaults", "macros with more default than optional parameters", on}, + {"orphan-labels", "labels alone on lines without trailing `:'", on}, + {"number-overflow", "numeric constant does not fit", on}, + {"gnu-elf-extensions", "using 8- or 16-bit relocation in ELF32, a GNU extension", off}, + {"float-overflow", "floating point overflow", on}, + {"float-denorm", "floating point denormal", off}, + {"float-underflow", "floating point underflow", off}, + {"float-toolong", "too many digits in floating-point number", on}, + {"user", "%warning directives", on}, + {"lock", "lock prefix on unlockable instructions", on}, + {"hle", "invalid hle prefixes", on}, + {"bnd", "invalid bnd prefixes", on}, + {"zext-reloc", "relocation zero-extended to match output format", on}, + {"ptr", "non-NASM keyword used in other assemblers", on}, + {"bad-pragma", "empty or malformed %pragma", off}, + {"unknown-pragma", "unknown %pragma facility or directive", off}, + {"not-my-pragma", "%pragma not applicable to this compilation", off}, + {"unknown-warning", "unknown warning in -W/-w or warning directive", off}, + {"negative-rep", "regative %rep count", on}, + {"phase", "phase error during stabilization", off}, + {"label-redef", "label redefined to an identical value", off}, + {"label-redef-late", "label (re)defined during code generation", err}, + + /* THESE ENTRIES SHOULD COME LAST */ + {"other", "any warning not specifially mentioned above", on}, + {"all", "all possible warnings", off} }; -/* Current state and command-line state, for reset */ -uint8_t warning_state[WARN_ALL]; -uint8_t warning_state_init[WARN_ALL]; +uint8_t warning_state[WARN_ALL];/* Current state */ +uint8_t warning_state_init[WARN_ALL]; /* Command-line state, for reset */ /* Global error handling function */ vefunc nasm_verror; @@ -127,7 +133,7 @@ fatal_func nasm_assert_failed(const char *file, int line, const char *msg) /* * This is called when processing a -w or -W option, or a warning directive. - * Returns true if if the action was successful. + * Returns on if if the action was successful. */ bool set_warning_status(const char *value) { diff --git a/asm/labels.c b/asm/labels.c index 8eeb5b71..1152ba76 100644 --- a/asm/labels.c +++ b/asm/labels.c @@ -493,33 +493,41 @@ void define_label(const char *label, int32_t segment, lptr->defn.size != size; global_offset_changed += changed; - if (changed) { - if (lastdef == lpass) { - int32_t saved_line = 0; - const char *saved_fname = NULL; + if (lastdef == lpass) { + int32_t saved_line = 0; + const char *saved_fname = NULL; + int noteflags; - /* - * Defined elsewhere in the program, seen in this pass. - */ - nasm_nonfatal("label `%s' inconsistently redefined", - lptr->defn.label); - - src_get(&saved_line, &saved_fname); - src_set(lptr->defn.def_line, lptr->defn.def_file); - nasm_notef(ERR_HERE, "label `%s' originally defined", lptr->defn.label); - src_set(saved_line, saved_fname); - } else if (pass0 > 1 && lptr->defn.type != LBL_SPECIAL) { - /* - * This probably should be ERR_NONFATAL, but not quite yet. As a - * special case, LBL_SPECIAL symbols are allowed to be changed - * even during the last pass. - */ - nasm_warn("label `%s' %s during code generation", - lptr->defn.label, - created ? "defined" : "changed"); + /* + * Defined elsewhere in the program, seen in this pass. + */ + if (changed) { + nasm_nonfatal("label `%s' inconsistently redefined", lptr->defn.label); + noteflags = ERR_NOTE|ERR_HERE; + } else { + nasm_warnf(WARN_LABEL_REDEF|ERR_PASS2, + "label `%s' redefined to an identical value", lptr->defn.label); + noteflags = ERR_NOTE|ERR_HERE|WARN_LABEL_REDEF|ERR_PASS2; } - } + src_get(&saved_line, &saved_fname); + src_set(lptr->defn.def_line, lptr->defn.def_file); + nasm_error(noteflags, "label `%s' originally defined", + lptr->defn.label); + src_set(saved_line, saved_fname); + } else if (changed && pass0 > 1 && lptr->defn.type != LBL_SPECIAL) { + /* + * WARN_LABEL_LATE defaults to an error, as this should never actually happen. + * Just in case this is a backwards compatibility problem, still make it a + * warning so that the user can suppress or demote it. + * + * As a special case, LBL_SPECIAL symbols are allowed to be changed + * even during the last pass. + */ + nasm_warnf(WARN_LABEL_LATE, + "label `%s' %s during code generation", + lptr->defn.label, created ? "defined" : "changed"); + } lptr->defn.segment = segment; lptr->defn.offset = offset; lptr->defn.size = size; diff --git a/asm/listing.c b/asm/listing.c index 5484bd5d..440cc177 100644 --- a/asm/listing.c +++ b/asm/listing.c @@ -48,7 +48,7 @@ #include "error.h" #include "listing.h" -#define LIST_MAX_LEN 216 /* something sensible */ +#define LIST_MAX_LEN 256 /* something sensible */ #define LIST_INDENT 40 #define LIST_HEXBIT 18 @@ -67,7 +67,11 @@ static char xdigit[] = "0123456789ABCDEF"; static char listline[LIST_MAX_LEN]; static bool listlinep; -static char listerror[LIST_MAX_LEN]; +struct list_error { + struct list_error *next; + char str[1]; +}; +struct list_error *listerr_head, **listerr_tail; static char listdata[2 * LIST_INDENT]; /* we need less than that actually */ static int32_t listoffset; @@ -85,32 +89,32 @@ static FILE *listfp; static void list_emit(void) { int i; + struct list_error *le, *tmp; - if (!listlinep && !listdata[0]) - return; + if (listlinep || *listdata) { + fprintf(listfp, "%6"PRId32" ", listlineno); - fprintf(listfp, "%6"PRId32" ", listlineno); + if (listdata[0]) + fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1, + listdata); + else + fprintf(listfp, "%*s", LIST_HEXBIT + 10, ""); - if (listdata[0]) - fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1, - listdata); - else - fprintf(listfp, "%*s", LIST_HEXBIT + 10, ""); + if (listlevel_e) + fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""), + listlevel_e); + else if (listlinep) + fprintf(listfp, " "); - if (listlevel_e) - fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""), - listlevel_e); - else if (listlinep) - fprintf(listfp, " "); + if (listlinep) + fprintf(listfp, " %s", listline); - if (listlinep) - fprintf(listfp, " %s", listline); + putc('\n', listfp); + listlinep = false; + listdata[0] = '\0'; + } - putc('\n', listfp); - listlinep = false; - listdata[0] = '\0'; - - if (listerror[0]) { + list_for_each_safe(le, tmp, listerr_head) { fprintf(listfp, "%6"PRId32" ", listlineno); for (i = 0; i < LIST_HEXBIT; i++) putc('*', listfp); @@ -121,9 +125,10 @@ static void list_emit(void) else fprintf(listfp, " "); - fprintf(listfp, " %s\n", listerror); - listerror[0] = '\0'; + fprintf(listfp, " %s\n", le->str); + nasm_free(le); } + listerr_tail = &listerr_head; } static void list_init(const char *fname) @@ -141,7 +146,8 @@ static void list_init(const char *fname) *listline = '\0'; listlineno = 0; - *listerror = '\0'; + listerr_head = NULL; + listerr_tail = &listerr_head; listp = true; listlevel = 0; suppress = 0; @@ -326,15 +332,28 @@ static void list_downlevel(int type) static void list_error(int severity, const char *fmt, ...) { + struct list_error *le; va_list ap; + int len; if (!listfp) return; va_start(ap, fmt); - vsnprintf(listerror, sizeof listerror, fmt, ap); + len = vsnprintf(NULL, 0, fmt, ap); va_end(ap); + /* sizeof(*le) already accounts for the final NULL */ + le = nasm_malloc(sizeof(*le) + len); + + va_start(ap, fmt); + vsnprintf(le->str, len+1, fmt, ap); + va_end(ap); + + le->next = NULL; + *listerr_tail = le; + listerr_tail = &le->next; + if ((severity & ERR_MASK) >= ERR_FATAL) list_emit(); } diff --git a/asm/nasm.c b/asm/nasm.c index a8d10783..48217455 100644 --- a/asm/nasm.c +++ b/asm/nasm.c @@ -76,7 +76,6 @@ struct forwrefinfo { /* info held on forward refs. */ static void parse_cmdline(int, char **, int); static void assemble_file(const char *, struct strlist *); -static bool is_suppressed_warning(int severity); static bool skip_this_pass(int severity); static void nasm_verror_asm(int severity, const char *fmt, va_list args); static void usage(void); @@ -1326,11 +1325,12 @@ static void parse_cmdline(int argc, char **argv, int pass) char *envreal, *envcopy = NULL, *p; int i; - /* Initialize all the warnings to their default state */ - for (i = 0; i < WARN_ALL; i++) { - warning_state_init[i] = warning_state[i] = - warnings[i].enabled ? WARN_ST_ENABLED : 0; - } + /* + * Initialize all the warnings to their default state, including + * warning index 0 used for "always on". + */ + for (i = 0; i < WARN_ALL; i++) + warning_state_init[i] = warning_state[i] = warnings[i].state; /* * First, process the NASMENV environment variable. @@ -1385,7 +1385,6 @@ static void parse_cmdline(int argc, char **argv, int pass) if (!inname) nasm_fatalf(ERR_USAGE, "no input file specified"); - else if ((errname && !strcmp(inname, errname)) || (outname && !strcmp(inname, outname)) || (listname && !strcmp(inname, listname)) || @@ -1698,51 +1697,34 @@ static void assemble_file(const char *fname, struct strlist *depend_list) } } -/* - * check to see if this is a suppressable warning - */ -static inline bool is_valid_warning(int severity) -{ - /* Not a warning at all */ - if ((severity & ERR_MASK) != ERR_WARNING) - return false; - - return WARN_IDX(severity) < WARN_ALL; -} - /** - * check for suppressed warning - * checks for suppressed warning or pass one only warning and we're - * not in pass 1 - * - * @param severity the severity of the warning or error - * @return true if we should abort error/warning printing + * get warning index; 0 if this is non-suppressible. */ -static bool is_suppressed_warning(int severity) +static size_t warn_index(int severity) { - /* Might be a warning but suppresed explicitly */ - if (is_valid_warning(severity) && !(severity & ERR_USAGE)) - return !(warning_state[WARN_IDX(severity)] & WARN_ST_ENABLED); - else - return false; -} + size_t index; -static bool warning_is_error(int severity) -{ - if (is_valid_warning(severity)) - return !!(warning_state[WARN_IDX(severity)] & WARN_ST_ERROR); - else - return false; + if ((severity & ERR_MASK) >= ERR_FATAL) + return 0; /* Fatal errors are never suppressible */ + + /* If this is a warning and no index is provided, it is WARN_OTHER */ + if ((severity & (ERR_MASK|WARN_MASK)) == ERR_WARNING) + severity |= WARN_OTHER; + + index = WARN_IDX(severity); + nasm_assert(index < WARN_ALL); + + return index; } static bool skip_this_pass(int severity) { /* * See if it's a pass-specific error or warning which should be skipped. - * We cannot skip errors stronger than ERR_NONFATAL as by definition - * they cannot be resumed from. + * We can never skip fatal errors as by definition they cannot be + * resumed from. */ - if ((severity & ERR_MASK) > ERR_NONFATAL) + if ((severity & ERR_MASK) >= ERR_FATAL) return false; /* @@ -1754,6 +1736,45 @@ static bool skip_this_pass(int severity) ((severity & ERR_PASS2) && pass0 != 2)); } +/** + * 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(int severity) +{ + if ((severity & ERR_MASK) >= ERR_FATAL) + return false; /* Fatal errors can never be suppressed */ + + return !(warning_state[warn_index(severity)] & WARN_ST_ENABLED); +} + +/** + * 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 int true_error_type(int 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_index(severity)]; + if ((state & warn_is_err) == warn_is_err) + type = ERR_NONFATAL; + } + + return type; +} + /** * common error reporting * This is the common back end of the error reporting schemes currently @@ -1770,12 +1791,16 @@ static void nasm_verror_asm(int severity, const char *fmt, va_list args) char warnsuf[64]; char linestr[64]; const char *pfx; - bool warn_is_err = warning_is_error(severity); - bool warn_is_other = WARN_IDX(severity) == WARN_OTHER; + int spec_type = severity & ERR_MASK; /* type originally specified */ + int true_type = true_error_type(severity); const char *currentfile = NULL; int32_t lineno = 0; + static const char * const pfx_table[ERR_MASK+1] = { + "debug: ", "note: ", "warning: ", "error: ", + "", "", "fatal: ", "panic: " + }; - if (is_suppressed_warning(severity)) + if (is_suppressed(severity)) return; if (!(severity & ERR_NOFILE)) { @@ -1789,49 +1814,24 @@ static void nasm_verror_asm(int severity, const char *fmt, va_list args) } } - switch (severity & (ERR_MASK|ERR_NO_SEVERITY)) { - case ERR_NOTE: - pfx = "note: "; - break; - case ERR_WARNING: - if (!warn_is_err) { - pfx = "warning: "; - break; - } - /* fall through */ - case ERR_NONFATAL: - pfx = "error: "; - break; - case ERR_FATAL: - pfx = "fatal: "; - break; - case ERR_PANIC: - pfx = "panic: "; - break; - case ERR_DEBUG: - pfx = "debug: "; - break; - default: - pfx = ""; - break; - } - /* * For a debug/warning/note event, if ERR_HERE is set don't * output anything if there is no current filename available */ - if (!currentfile && (severity & ERR_HERE) && - ((severity & ERR_MASK) < ERR_WARNING || - (is_valid_warning(severity) && !warn_is_err))) + if (!currentfile && (severity & ERR_HERE) && true_type <= ERR_WARNING) return; + if (severity & ERR_NO_SEVERITY) + pfx = ""; + else + pfx = pfx_table[true_type]; vsnprintf(msg, sizeof msg, fmt, args); *warnsuf = 0; - if (is_valid_warning(severity) && (warn_is_err || !warn_is_other)) { + if (spec_type == ERR_WARNING) { snprintf(warnsuf, sizeof warnsuf, " [-w+%s%s]", - warn_is_err ? "error=" : "", - warnings[WARN_IDX(severity)].name); + true_type ? "error=" : "", + warnings[warn_index(severity)].name); } *linestr = 0; @@ -1877,15 +1877,11 @@ static void nasm_verror_asm(int severity, const char *fmt, va_list args) preproc->error_list_macros(severity); - switch (severity & ERR_MASK) { + switch (true_type) { case ERR_NOTE: case ERR_DEBUG: - /* no further action, by definition */ - break; case ERR_WARNING: - /* Treat warnings as errors */ - if (warning_is_error(severity)) - terminate_after_phase = true; + /* no further action, by definition */ break; case ERR_NONFATAL: terminate_after_phase = true; @@ -1993,14 +1989,14 @@ static void help(const char xopt) } } - printf("\nWarnings for the -W/-w options:\n"); + printf("\nWarnings for the -W/-w options: (default in brackets)\n"); - for (i = 0; i <= WARN_ALL; i++) + for (i = 1; i <= WARN_ALL; i++) printf(" %-23s %s%s\n", warnings[i].name, warnings[i].help, i == WARN_ALL ? "\n" : - warnings[i].enabled ? " (default on)" : - " (default off)"); + (warnings[i].state & WARN_ST_ERROR) ? " [error]" : + (warnings[i].state & WARN_ST_ENABLED) ? " [on]" : " [off]"); if (xopt == 'f') { printf("valid output formats for -f are" diff --git a/configure.ac b/configure.ac index 878b3269..a7be0c50 100644 --- a/configure.ac +++ b/configure.ac @@ -284,6 +284,11 @@ PA_ADD_CFLAGS([-Wlong-long],[-Wno-long-long]) dnl This is needed because we intentionally expect strncpy() to fill dnl in a zero-padded (not zero-terminated) buffer in several backends PA_ADD_CFLAGS([-Wstringop-truncation],[-Wno-stringop-truncation]) +dnl This is needed because we assume 2's-completement signed arithmetic; +dnl on compilers with gcc-like command line syntax we pass the -fwrapv +dnl option for exactly that reason. +PA_ADD_CFLAGS([-Wshift-negative-value],[-Wno-shift-negative-value]) + dnl PA_ADD_CFLAGS([-Wwrite-strings]) PA_ARG_ENABLED([werror], [compile with -Werror to error out on any warning], diff --git a/include/error.h b/include/error.h index db3e0785..de07d45e 100644 --- a/include/error.h +++ b/include/error.h @@ -94,53 +94,54 @@ static inline vefunc nasm_set_verror(vefunc ve) /* * These codes define specific types of suppressible warning. + * They are assumed to occupy the most significant bits of the + * severity code. */ -#define WARN_MASK 0xFFFFF000 /* the mask for this feature */ -#define WARN_SHR 12 /* how far to shift right */ +#define WARN_SHR 12 /* how far to shift right */ +#define WARN(x) ((x) << WARN_SHR) +#define WARN_MASK WARN(~0) +#define WARN_IDX(x) ((x) >> WARN_SHR) -#define WARN(x) ((x) << WARN_SHR) -#define WARN_IDX(x) (((x) & WARN_MASK) >> WARN_SHR) - -#define WARN_OTHER WARN( 0) /* any noncategorized warning */ -#define WARN_MNP WARN( 1) /* macro-num-parameters warning */ -#define WARN_MSR WARN( 2) /* macro self-reference */ -#define WARN_MDP WARN( 3) /* macro default parameters check */ -#define WARN_OL WARN( 4) /* orphan label (no colon, and - * alone on line) */ -#define WARN_NOV WARN( 5) /* numeric overflow */ -#define WARN_GNUELF WARN( 6) /* using GNU ELF extensions */ -#define WARN_FL_OVERFLOW WARN( 7) /* FP overflow */ -#define WARN_FL_DENORM WARN( 8) /* FP denormal */ -#define WARN_FL_UNDERFLOW WARN( 9) /* FP underflow */ -#define WARN_FL_TOOLONG WARN(10) /* FP too many digits */ -#define WARN_USER WARN(11) /* %warning directives */ +#define WARN_MNP WARN( 1) /* macro-num-parameters warning */ +#define WARN_MSR WARN( 2) /* macro self-reference */ +#define WARN_MDP WARN( 3) /* macro default parameters check */ +#define WARN_OL WARN( 4) /* orphan label (no colon, and alone on line) */ +#define WARN_NOV WARN( 5) /* numeric overflow */ +#define WARN_GNUELF WARN( 6) /* using GNU ELF extensions */ +#define WARN_FL_OVERFLOW WARN( 7) /* FP overflow */ +#define WARN_FL_DENORM WARN( 8) /* FP denormal */ +#define WARN_FL_UNDERFLOW WARN( 9) /* FP underflow */ +#define WARN_FL_TOOLONG WARN(10) /* FP too many digits */ +#define WARN_USER WARN(11) /* %warning directives */ #define WARN_LOCK WARN(12) /* bad LOCK prefixes */ #define WARN_HLE WARN(13) /* bad HLE prefixes */ #define WARN_BND WARN(14) /* bad BND prefixes */ -#define WARN_ZEXTRELOC WARN(15) /* relocation zero-extended */ +#define WARN_ZEXTRELOC WARN(15) /* relocation zero-extended */ #define WARN_PTR WARN(16) /* not a NASM keyword */ -#define WARN_BAD_PRAGMA WARN(17) /* malformed pragma */ +#define WARN_BAD_PRAGMA WARN(17) /* malformed pragma */ #define WARN_UNKNOWN_PRAGMA WARN(18) /* unknown pragma */ #define WARN_NOTMY_PRAGMA WARN(19) /* pragma inapplicable */ #define WARN_UNK_WARNING WARN(20) /* unknown warning */ -#define WARN_NEG_REP WARN(21) /* negative repeat count */ +#define WARN_NEG_REP WARN(21) /* negative repeat count */ #define WARN_PHASE WARN(22) /* phase error in pass 1 */ +#define WARN_LABEL_REDEF WARN(23) /* label redefined, but consistent */ +#define WARN_LABEL_LATE WARN(24) /* label (re)defined during code generation */ -/* The "all" warning acts as a global switch, it must come last */ -#define WARN_ALL 23 /* Do not use WARN() here */ - -struct warning { - const char *name; - const char *help; - bool enabled; -}; -extern const struct warning warnings[WARN_ALL+1]; +/* These two should come last */ +#define WARN_ALL (24+2) /* Do not use WARN() here */ +#define WARN_OTHER WARN(WARN_ALL-1) /* any noncategorized warning */ /* This is a bitmask */ #define WARN_ST_ENABLED 1 /* Warning is currently enabled */ #define WARN_ST_ERROR 2 /* Treat this warning as an error */ +struct warning { + const char *name; + const char *help; + uint8_t state; /* Default state for this warning */ +}; +extern const struct warning warnings[WARN_ALL+1]; extern uint8_t warning_state[WARN_ALL]; extern uint8_t warning_state_init[WARN_ALL];