aniani/nasm
0
0
Fork 1
mirror of https://github.com/netwide-assembler/nasm.git synced 2025-09-22 10:43:39 -04:00
Code Activity

Merge remote-tracking branch 'origin/nasm-2.14.xx'

Browse Source 
Resolved Conflicts:
	asm/assemble.c
	asm/directiv.c
	asm/error.c
	asm/float.c
	asm/labels.c
	asm/listing.c
	asm/nasm.c
	asm/parser.c
	asm/preproc.c
	asm/stdscan.c
	include/error.h
	output/outelf.c
	version

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
This commit is contained in:
H. Peter Anvin (Intel)
2018-12-12 18:05:52 -08:00
parent df4d342599 51222ab69e
commit 8e08fb6da7
6 changed files with 232 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
asm/error.c
View File

@@ -46,38 +46,44 @@
* Description of the suppressible warnings for the command line and * Description of the suppressible warnings for the command line and
* the [warning] directive. * the [warning] directive.
*/ */
const struct warning warnings[WARN_ALL+1] = { #define on (WARN_ST_ENABLED)
{ "other", "any warning not specifially mentioned below", true }, #define off 0
{ "macro-params", "macro calls with wrong parameter count", true }, #define err (WARN_ST_ENABLED|WARN_ST_ERROR)
{ "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 },
/* THIS ENTRY MUST COME LAST */ const struct warning warnings[WARN_ALL+1] = {
{ "all", "all possible warnings", false } {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];/* Current state */
uint8_t warning_state[WARN_ALL]; uint8_t warning_state_init[WARN_ALL]; /* Command-line state, for reset */
uint8_t warning_state_init[WARN_ALL];
/* Global error handling function */ /* Global error handling function */
vefunc nasm_verror; 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. * 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) bool set_warning_status(const char *value)
{ {

56
asm/labels.c
View File

@@ -493,33 +493,41 @@ void define_label(const char *label, int32_t segment,
lptr->defn.size != size; lptr->defn.size != size;
global_offset_changed += changed; global_offset_changed += changed;
if (changed) { if (lastdef == lpass) {
if (lastdef == lpass) { int32_t saved_line = 0;
int32_t saved_line = 0; const char *saved_fname = NULL;
const char *saved_fname = NULL; int noteflags;
/* /*
* Defined elsewhere in the program, seen in this pass. * Defined elsewhere in the program, seen in this pass.
*/ */
nasm_nonfatal("label `%s' inconsistently redefined", if (changed) {
lptr->defn.label); nasm_nonfatal("label `%s' inconsistently redefined", lptr->defn.label);
noteflags = ERR_NOTE|ERR_HERE;
src_get(&saved_line, &saved_fname); } else {
src_set(lptr->defn.def_line, lptr->defn.def_file); nasm_warnf(WARN_LABEL_REDEF|ERR_PASS2,
nasm_notef(ERR_HERE, "label `%s' originally defined", lptr->defn.label); "label `%s' redefined to an identical value", lptr->defn.label);
src_set(saved_line, saved_fname); noteflags = ERR_NOTE|ERR_HERE|WARN_LABEL_REDEF|ERR_PASS2;
} 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");
} }
}
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.segment = segment;
lptr->defn.offset = offset; lptr->defn.offset = offset;
lptr->defn.size = size; lptr->defn.size = size;

71
asm/listing.c
View File

@@ -48,7 +48,7 @@
#include "error.h" #include "error.h"
#include "listing.h" #include "listing.h"
#define LIST_MAX_LEN 216 /* something sensible */ #define LIST_MAX_LEN 256 /* something sensible */
#define LIST_INDENT 40 #define LIST_INDENT 40
#define LIST_HEXBIT 18 #define LIST_HEXBIT 18
@@ -67,7 +67,11 @@ static char xdigit[] = "0123456789ABCDEF";
static char listline[LIST_MAX_LEN]; static char listline[LIST_MAX_LEN];
static bool listlinep; 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 char listdata[2 * LIST_INDENT]; /* we need less than that actually */
static int32_t listoffset; static int32_t listoffset;
@@ -85,32 +89,32 @@ static FILE *listfp;
static void list_emit(void) static void list_emit(void)
{ {
int i; int i;
struct list_error *le, *tmp;
if (!listlinep && !listdata[0]) if (listlinep || *listdata) {
return; 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]) if (listlevel_e)
fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1, fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""),
listdata); listlevel_e);
else else if (listlinep)
fprintf(listfp, "%*s", LIST_HEXBIT + 10, ""); fprintf(listfp, " ");
if (listlevel_e) if (listlinep)
fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""), fprintf(listfp, " %s", listline);
listlevel_e);
else if (listlinep)
fprintf(listfp, " ");
if (listlinep) putc('\n', listfp);
fprintf(listfp, " %s", listline); listlinep = false;
listdata[0] = '\0';
}
putc('\n', listfp); list_for_each_safe(le, tmp, listerr_head) {
listlinep = false;
listdata[0] = '\0';
if (listerror[0]) {
fprintf(listfp, "%6"PRId32" ", listlineno); fprintf(listfp, "%6"PRId32" ", listlineno);
for (i = 0; i < LIST_HEXBIT; i++) for (i = 0; i < LIST_HEXBIT; i++)
putc('*', listfp); putc('*', listfp);
@@ -121,9 +125,10 @@ static void list_emit(void)
else else
fprintf(listfp, " "); fprintf(listfp, " ");
fprintf(listfp, " %s\n", listerror); fprintf(listfp, " %s\n", le->str);
listerror[0] = '\0'; nasm_free(le);
} }
listerr_tail = &listerr_head;
} }
static void list_init(const char *fname) static void list_init(const char *fname)
@@ -141,7 +146,8 @@ static void list_init(const char *fname)
*listline = '\0'; *listline = '\0';
listlineno = 0; listlineno = 0;
*listerror = '\0'; listerr_head = NULL;
listerr_tail = &listerr_head;
listp = true; listp = true;
listlevel = 0; listlevel = 0;
suppress = 0; suppress = 0;
@@ -326,15 +332,28 @@ static void list_downlevel(int type)
static void list_error(int severity, const char *fmt, ...) static void list_error(int severity, const char *fmt, ...)
{ {
struct list_error *le;
va_list ap; va_list ap;
int len;
if (!listfp) if (!listfp)
return; return;
va_start(ap, fmt); va_start(ap, fmt);
vsnprintf(listerror, sizeof listerror, fmt, ap); len = vsnprintf(NULL, 0, fmt, ap);
va_end(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) if ((severity & ERR_MASK) >= ERR_FATAL)
list_emit(); list_emit();
} }

170
asm/nasm.c
View File

@@ -76,7 +76,6 @@ struct forwrefinfo { /* info held on forward refs. */
static void parse_cmdline(int, char **, int); static void parse_cmdline(int, char **, int);
static void assemble_file(const char *, struct strlist *); static void assemble_file(const char *, struct strlist *);
static bool is_suppressed_warning(int severity);
static bool skip_this_pass(int severity); static bool skip_this_pass(int severity);
static void nasm_verror_asm(int severity, const char *fmt, va_list args); static void nasm_verror_asm(int severity, const char *fmt, va_list args);
static void usage(void); static void usage(void);
@@ -1326,11 +1325,12 @@ static void parse_cmdline(int argc, char **argv, int pass)
char *envreal, *envcopy = NULL, *p; char *envreal, *envcopy = NULL, *p;
int i; int i;
/* Initialize all the warnings to their default state */ /*
for (i = 0; i < WARN_ALL; i++) { * Initialize all the warnings to their default state, including
warning_state_init[i] = warning_state[i] = * warning index 0 used for "always on".
warnings[i].enabled ? WARN_ST_ENABLED : 0; */
} for (i = 0; i < WARN_ALL; i++)
warning_state_init[i] = warning_state[i] = warnings[i].state;
/* /*
* First, process the NASMENV environment variable. * First, process the NASMENV environment variable.
@@ -1385,7 +1385,6 @@ static void parse_cmdline(int argc, char **argv, int pass)
if (!inname) if (!inname)
nasm_fatalf(ERR_USAGE, "no input file specified"); nasm_fatalf(ERR_USAGE, "no input file specified");
else if ((errname && !strcmp(inname, errname)) || else if ((errname && !strcmp(inname, errname)) ||
(outname && !strcmp(inname, outname)) || (outname && !strcmp(inname, outname)) ||
(listname && !strcmp(inname, listname)) || (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 * get warning index; 0 if this is non-suppressible.
* 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
*/ */
static bool is_suppressed_warning(int severity) static size_t warn_index(int severity)
{ {
/* Might be a warning but suppresed explicitly */ size_t index;
if (is_valid_warning(severity) && !(severity & ERR_USAGE))
return !(warning_state[WARN_IDX(severity)] & WARN_ST_ENABLED);
else
return false;
}
static bool warning_is_error(int severity) if ((severity & ERR_MASK) >= ERR_FATAL)
{ return 0; /* Fatal errors are never suppressible */
if (is_valid_warning(severity))
return !!(warning_state[WARN_IDX(severity)] & WARN_ST_ERROR); /* If this is a warning and no index is provided, it is WARN_OTHER */
else if ((severity & (ERR_MASK|WARN_MASK)) == ERR_WARNING)
return false; severity |= WARN_OTHER;
index = WARN_IDX(severity);
nasm_assert(index < WARN_ALL);
return index;
} }
static bool skip_this_pass(int severity) static bool skip_this_pass(int severity)
{ {
/* /*
* See if it's a pass-specific error or warning which should be skipped. * 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 * We can never skip fatal errors as by definition they cannot be
* they cannot be resumed from. * resumed from.
*/ */
if ((severity & ERR_MASK) > ERR_NONFATAL) if ((severity & ERR_MASK) >= ERR_FATAL)
return false; return false;
/* /*
@@ -1754,6 +1736,45 @@ static bool skip_this_pass(int severity)
((severity & ERR_PASS2) && pass0 != 2)); ((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 * common error reporting
* This is the common back end of the error reporting schemes currently * 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 warnsuf[64];
char linestr[64]; char linestr[64];
const char *pfx; const char *pfx;
bool warn_is_err = warning_is_error(severity); int spec_type = severity & ERR_MASK; /* type originally specified */
bool warn_is_other = WARN_IDX(severity) == WARN_OTHER; int true_type = true_error_type(severity);
const char *currentfile = NULL; const char *currentfile = NULL;
int32_t lineno = 0; 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; return;
if (!(severity & ERR_NOFILE)) { 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 * For a debug/warning/note event, if ERR_HERE is set don't
* output anything if there is no current filename available * output anything if there is no current filename available
*/ */
if (!currentfile && (severity & ERR_HERE) && if (!currentfile && (severity & ERR_HERE) && true_type <= ERR_WARNING)
((severity & ERR_MASK) < ERR_WARNING ||
(is_valid_warning(severity) && !warn_is_err)))
return; return;
if (severity & ERR_NO_SEVERITY)
pfx = "";
else
pfx = pfx_table[true_type];
vsnprintf(msg, sizeof msg, fmt, args); vsnprintf(msg, sizeof msg, fmt, args);
*warnsuf = 0; *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]", snprintf(warnsuf, sizeof warnsuf, " [-w+%s%s]",
warn_is_err ? "error=" : "", true_type ? "error=" : "",
warnings[WARN_IDX(severity)].name); warnings[warn_index(severity)].name);
} }
*linestr = 0; *linestr = 0;
@@ -1877,15 +1877,11 @@ static void nasm_verror_asm(int severity, const char *fmt, va_list args)
preproc->error_list_macros(severity); preproc->error_list_macros(severity);
switch (severity & ERR_MASK) { switch (true_type) {
case ERR_NOTE: case ERR_NOTE:
case ERR_DEBUG: case ERR_DEBUG:
/* no further action, by definition */
break;
case ERR_WARNING: case ERR_WARNING:
/* Treat warnings as errors */ /* no further action, by definition */
if (warning_is_error(severity))
terminate_after_phase = true;
break; break;
case ERR_NONFATAL: case ERR_NONFATAL:
terminate_after_phase = true; 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", printf(" %-23s %s%s\n",
warnings[i].name, warnings[i].help, warnings[i].name, warnings[i].help,
i == WARN_ALL ? "\n" : i == WARN_ALL ? "\n" :
warnings[i].enabled ? " (default on)" : (warnings[i].state & WARN_ST_ERROR) ? " [error]" :
" (default off)"); (warnings[i].state & WARN_ST_ENABLED) ? " [on]" : " [off]");
if (xopt == 'f') { if (xopt == 'f') {
printf("valid output formats for -f are" printf("valid output formats for -f are"

5
configure.ac
View File

@@ -284,6 +284,11 @@ PA_ADD_CFLAGS([-Wlong-long],[-Wno-long-long])
dnl This is needed because we intentionally expect strncpy() to fill dnl This is needed because we intentionally expect strncpy() to fill
dnl in a zero-padded (not zero-terminated) buffer in several backends dnl in a zero-padded (not zero-terminated) buffer in several backends
PA_ADD_CFLAGS([-Wstringop-truncation],[-Wno-stringop-truncation]) 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]) dnl PA_ADD_CFLAGS([-Wwrite-strings])
PA_ARG_ENABLED([werror], PA_ARG_ENABLED([werror],
[compile with -Werror to error out on any warning], [compile with -Werror to error out on any warning],

61
include/error.h
View File

@@ -94,53 +94,54 @@ static inline vefunc nasm_set_verror(vefunc ve)
/* /*
* These codes define specific types of suppressible warning. * 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_MNP WARN( 1) /* macro-num-parameters warning */
#define WARN_IDX(x) (((x) & WARN_MASK) >> WARN_SHR) #define WARN_MSR WARN( 2) /* macro self-reference */
#define WARN_MDP WARN( 3) /* macro default parameters check */
#define WARN_OTHER WARN( 0) /* any noncategorized warning */ #define WARN_OL WARN( 4) /* orphan label (no colon, and alone on line) */
#define WARN_MNP WARN( 1) /* macro-num-parameters warning */ #define WARN_NOV WARN( 5) /* numeric overflow */
#define WARN_MSR WARN( 2) /* macro self-reference */ #define WARN_GNUELF WARN( 6) /* using GNU ELF extensions */
#define WARN_MDP WARN( 3) /* macro default parameters check */ #define WARN_FL_OVERFLOW WARN( 7) /* FP overflow */
#define WARN_OL WARN( 4) /* orphan label (no colon, and #define WARN_FL_DENORM WARN( 8) /* FP denormal */
* alone on line) */ #define WARN_FL_UNDERFLOW WARN( 9) /* FP underflow */
#define WARN_NOV WARN( 5) /* numeric overflow */ #define WARN_FL_TOOLONG WARN(10) /* FP too many digits */
#define WARN_GNUELF WARN( 6) /* using GNU ELF extensions */ #define WARN_USER WARN(11) /* %warning directives */
#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_LOCK WARN(12) /* bad LOCK prefixes */
#define WARN_HLE WARN(13) /* bad HLE prefixes */ #define WARN_HLE WARN(13) /* bad HLE prefixes */
#define WARN_BND WARN(14) /* bad BND 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_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_UNKNOWN_PRAGMA WARN(18) /* unknown pragma */
#define WARN_NOTMY_PRAGMA WARN(19) /* pragma inapplicable */ #define WARN_NOTMY_PRAGMA WARN(19) /* pragma inapplicable */
#define WARN_UNK_WARNING WARN(20) /* unknown warning */ #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_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 */ /* These two should come last */
#define WARN_ALL 23 /* Do not use WARN() here */ #define WARN_ALL (24+2) /* Do not use WARN() here */
#define WARN_OTHER WARN(WARN_ALL-1) /* any noncategorized warning */
struct warning {
const char *name;
const char *help;
bool enabled;
};
extern const struct warning warnings[WARN_ALL+1];
/* This is a bitmask */ /* This is a bitmask */
#define WARN_ST_ENABLED 1 /* Warning is currently enabled */ #define WARN_ST_ENABLED 1 /* Warning is currently enabled */
#define WARN_ST_ERROR 2 /* Treat this warning as an error */ #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[WARN_ALL];
extern uint8_t warning_state_init[WARN_ALL]; extern uint8_t warning_state_init[WARN_ALL];