From 77f53ba6d4cb90e5a7e09b33357ed7c1fe9f6b9d Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 14:38:50 -0800
Subject: [PATCH 01/11] warnings: rename ERR_WARN_* to WARN_*

The prefix ERR_WARN_ is unnecessarily long and may be a disincentive
to create new warning categories. Change it to WARN_*, it is still
plenty distinctive.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
---
 asm/assemble.c    | 18 ++++++-------
 asm/directiv.c    |  2 +-
 asm/error.c       |  8 +++---
 asm/float.c       | 10 ++++----
 asm/nasm.c        | 18 ++++++-------
 asm/parser.c      |  2 +-
 asm/pragma.c      |  6 ++---
 asm/preproc.c     | 10 ++++----
 asm/stdscan.c     |  2 +-
 include/error.h   | 64 +++++++++++++++++++++++------------------------
 nasmlib/readnum.c |  2 +-
 output/outdbg.c   |  2 +-
 output/outelf.c   |  4 +--
 13 files changed, 74 insertions(+), 74 deletions(-)

diff --git a/asm/assemble.c b/asm/assemble.c
index 30dc047e..2fb2e07e 100644
--- a/asm/assemble.c
+++ b/asm/assemble.c
@@ -294,7 +294,7 @@ static const char *size_name(int size)
 
 static void warn_overflow(int size)
 {
-    nasm_error(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
+    nasm_error(ERR_WARNING | ERR_PASS2 | WARN_NOV,
             "%s data exceeds bounds", size_name(size));
 }
 
@@ -407,7 +407,7 @@ static void out(struct out_data *data)
                     "%u-bit signed relocation unsupported by output format %s",
                        (unsigned int)(asize << 3), ofmt->shortname);
         } else {
-            nasm_error(ERR_WARNING | ERR_WARN_ZEXTRELOC,
+            nasm_error(ERR_WARNING | WARN_ZEXTRELOC,
                        "%u-bit %s relocation zero-extended from %u bits",
                        (unsigned int)(asize << 3),
                        data->type == OUT_SEGMENT ? "segment" : "unsigned",
@@ -548,7 +548,7 @@ static bool jmp_match(int32_t segment, int64_t offset, int bits,
     if (is_byte && c == 0371 && ins->prefixes[PPS_REP] == P_BND) {
         /* jmp short (opcode eb) cannot be used with bnd prefix. */
         ins->prefixes[PPS_REP] = P_none;
-        nasm_error(ERR_WARNING | ERR_WARN_BND | ERR_PASS2 ,
+        nasm_error(ERR_WARNING | WARN_BND | ERR_PASS2 ,
                 "jmp short does not init bnd regs - bnd prefix dropped.");
     }
 
@@ -913,14 +913,14 @@ static void bad_hle_warn(const insn * ins, uint8_t hleok)
 
     case w_lock:
         if (ins->prefixes[PPS_LOCK] != P_LOCK) {
-            nasm_error(ERR_WARNING | ERR_WARN_HLE | ERR_PASS2,
+            nasm_error(ERR_WARNING | WARN_HLE | ERR_PASS2,
                     "%s with this instruction requires lock",
                     prefix_name(rep_pfx));
         }
         break;
 
     case w_inval:
-        nasm_error(ERR_WARNING | ERR_WARN_HLE | ERR_PASS2,
+        nasm_error(ERR_WARNING | WARN_HLE | ERR_PASS2,
                 "%s invalid with this instruction",
                 prefix_name(rep_pfx));
         break;
@@ -1401,7 +1401,7 @@ static int64_t calcsize(int32_t segment, int64_t offset, int bits,
 
     if (has_prefix(ins, PPS_LOCK, P_LOCK) && lockcheck &&
         (!itemp_has(temp,IF_LOCK) || !is_class(MEMORY, ins->oprs[0].type))) {
-        nasm_error(ERR_WARNING | ERR_WARN_LOCK | ERR_PASS2 ,
+        nasm_error(ERR_WARNING | WARN_LOCK | ERR_PASS2 ,
                 "instruction is not lockable");
     }
 
@@ -1686,7 +1686,7 @@ static void gencode(struct out_data *data, insn *ins)
                         "non-absolute expression not permitted as argument %d",
                         c & 7);
             } else if (opy->offset & ~mask) {
-                nasm_error(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
+                nasm_error(ERR_WARNING | ERR_PASS2 | WARN_NOV,
                            "is4 argument exceeds bounds");
             }
             c = opy->offset & mask;
@@ -1709,7 +1709,7 @@ static void gencode(struct out_data *data, insn *ins)
         case4(0254):
             if (absolute_op(opx) &&
                 (int32_t)opx->offset != (int64_t)opx->offset) {
-                nasm_error(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
+                nasm_error(ERR_WARNING | ERR_PASS2 | WARN_NOV,
                         "signed dword immediate exceeds bounds");
             }
             out_imm(data, opx, 4, OUT_SIGNED);
@@ -1779,7 +1779,7 @@ static void gencode(struct out_data *data, insn *ins)
                     /* If this wasn't explicitly byte-sized, warn as though we
                      * had fallen through to the imm16/32/64 case.
                      */
-                    nasm_error(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
+                    nasm_error(ERR_WARNING | ERR_PASS2 | WARN_NOV,
                                "%s value exceeds bounds",
                                (opx->type & BITS8) ? "signed byte" :
                                s == 16 ? "word" :
diff --git a/asm/directiv.c b/asm/directiv.c
index 89750c8c..e6da4606 100644
--- a/asm/directiv.c
+++ b/asm/directiv.c
@@ -443,7 +443,7 @@ bool process_directives(char *directive)
 
     case D_WARNING:         /* [WARNING {+|-|*}warn-name] */
         if (!set_warning_status(value)) {
-            nasm_error(ERR_WARNING|ERR_WARN_UNK_WARNING,
+            nasm_error(ERR_WARNING|WARN_UNK_WARNING,
                        "unknown warning option: %s", value);
         }
         break;
diff --git a/asm/error.c b/asm/error.c
index 73db7443..c61ee390 100644
--- a/asm/error.c
+++ b/asm/error.c
@@ -46,7 +46,7 @@
  * Description of the suppressible warnings for the command line and
  * the [warning] directive.
  */
-const struct warning warnings[ERR_WARN_ALL+1] = {
+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},
@@ -75,8 +75,8 @@ const struct warning warnings[ERR_WARN_ALL+1] = {
     {"all", "all possible warnings", false}
 };
 
-uint8_t warning_state[ERR_WARN_ALL];/* Current state */
-uint8_t warning_state_init[ERR_WARN_ALL]; /* Command-line state, for reset */
+uint8_t warning_state[WARN_ALL];/* Current state */
+uint8_t warning_state_init[WARN_ALL]; /* Command-line state, for reset */
 
 vefunc nasm_verror;    /* Global error handling function */
 
@@ -182,7 +182,7 @@ bool set_warning_status(const char *value)
         value = NULL;
 
     /* This is inefficient, but it shouldn't matter... */
-    for (i = 0; i < ERR_WARN_ALL; i++) {
+    for (i = 0; i < WARN_ALL; i++) {
         if (!value || !nasm_stricmp(value, warnings[i].name)) {
             ok = true;          /* At least one action taken */
             switch (action) {
diff --git a/asm/float.c b/asm/float.c
index 17df6c36..e6c7ee81 100644
--- a/asm/float.c
+++ b/asm/float.c
@@ -234,7 +234,7 @@ static bool ieee_flconvert(const char *string, fp_limb *mant,
                     *p++ = *string - '0';
                 } else {
                     if (!warned) {
-                        nasm_error(ERR_WARNING|ERR_WARN_FL_TOOLONG|ERR_PASS2,
+                        nasm_error(ERR_WARNING|WARN_FL_TOOLONG|ERR_PASS2,
                               "floating-point constant significand contains "
                               "more than %i digits", MANT_DIGITS);
                         warned = true;
@@ -812,7 +812,7 @@ static int to_float(const char *str, int s, uint8_t *result,
                 type = FL_NORMAL;
             } else if (exponent > 0) {
                 if (pass0 == 1)
-                    nasm_error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS2,
+                    nasm_error(ERR_WARNING|WARN_FL_OVERFLOW|ERR_PASS2,
                           "overflow in floating-point constant");
                 type = FL_INFINITY;
             } else {
@@ -847,11 +847,11 @@ static int to_float(const char *str, int s, uint8_t *result,
         } else {
             if (daz || is_zero(mant)) {
                 /* Flush denormals to zero */
-                nasm_error(ERR_WARNING|ERR_WARN_FL_UNDERFLOW|ERR_PASS2,
+                nasm_error(ERR_WARNING|WARN_FL_UNDERFLOW|ERR_PASS2,
                       "underflow in floating-point constant");
                 goto zero;
             } else {
-                nasm_error(ERR_WARNING|ERR_WARN_FL_DENORM|ERR_PASS2,
+                nasm_error(ERR_WARNING|WARN_FL_DENORM|ERR_PASS2,
                       "denormal floating-point constant");
             }
         }
@@ -867,7 +867,7 @@ static int to_float(const char *str, int s, uint8_t *result,
             ieee_shr(mant, 1);
             exponent++;
             if (exponent >= (expmax << 1)-1) {
-                    nasm_error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS2,
+                    nasm_error(ERR_WARNING|WARN_FL_OVERFLOW|ERR_PASS2,
                           "overflow in floating-point constant");
                 type = FL_INFINITY;
                 goto overflow;
diff --git a/asm/nasm.c b/asm/nasm.c
index d1a4fe0d..42d3c6c6 100644
--- a/asm/nasm.c
+++ b/asm/nasm.c
@@ -195,7 +195,7 @@ nasm_set_limit(const char *limit, const char *valstr)
         if (passn == 0)
             errlevel = ERR_WARNING|ERR_NOFILE|ERR_USAGE;
         else
-            errlevel = ERR_WARNING|ERR_PASS1|ERR_WARN_UNKNOWN_PRAGMA;
+            errlevel = ERR_WARNING|ERR_PASS1|WARN_UNKNOWN_PRAGMA;
         nasm_error(errlevel, "unknown limit: `%s'", limit);
         return DIRR_ERROR;
     }
@@ -208,7 +208,7 @@ nasm_set_limit(const char *limit, const char *valstr)
             if (passn == 0)
                 errlevel = ERR_WARNING|ERR_NOFILE|ERR_USAGE;
             else
-                errlevel = ERR_WARNING|ERR_PASS1|ERR_WARN_BAD_PRAGMA;
+                errlevel = ERR_WARNING|ERR_PASS1|WARN_BAD_PRAGMA;
             nasm_error(errlevel, "invalid limit value: `%s'", limit);
             return DIRR_ERROR;
         }
@@ -1050,7 +1050,7 @@ static bool process_arg(char *p, char *q, int pass)
         case 'W':
             if (pass == 2) {
                 if (!set_warning_status(param)) {
-                    nasm_error(ERR_WARNING|ERR_NOFILE|ERR_WARN_UNK_WARNING,
+                    nasm_error(ERR_WARNING|ERR_NOFILE|WARN_UNK_WARNING,
 			       "unknown warning option: %s", param);
                 }
             }
@@ -1344,7 +1344,7 @@ static void parse_cmdline(int argc, char **argv, int pass)
     int i;
 
     /* Initialize all the warnings to their default state */
-    for (i = 0; i < ERR_WARN_ALL; i++) {
+    for (i = 0; i < WARN_ALL; i++) {
         warning_state_init[i] = warning_state[i] =
 	    warnings[i].enabled ? WARN_ST_ENABLED : 0;
     }
@@ -1661,7 +1661,7 @@ static void assemble_file(const char *fname, StrList **depend_ptr)
         if (global_offset_changed && !terminate_after_phase) {
             switch (pass0) {
             case 1:
-                nasm_error(ERR_WARNING|ERR_WARN_PHASE,
+                nasm_error(ERR_WARNING|WARN_PHASE,
                            "phase error during stabilization pass, hoping for the best");
                 break;
 
@@ -1808,7 +1808,7 @@ static inline bool is_valid_warning(int severity)
     if ((severity & ERR_MASK) != ERR_WARNING)
         return false;
 
-    return WARN_IDX(severity) < ERR_WARN_ALL;
+    return WARN_IDX(severity) < WARN_ALL;
 }
 
 /**
@@ -1870,7 +1870,7 @@ static void nasm_verror_common(int severity, const char *fmt, va_list args)
     char msg[1024];
     const char *pfx;
     bool warn_is_err = warning_is_error(severity);
-    bool warn_is_other = WARN_IDX(severity) == ERR_WARN_OTHER;
+    bool warn_is_other = WARN_IDX(severity) == WARN_OTHER;
 
     switch (severity & (ERR_MASK|ERR_NO_SEVERITY)) {
     case ERR_NOTE:
@@ -2046,10 +2046,10 @@ static void help(const char xopt)
 
     printf("\nWarnings for the -W/-w options:\n");
 
-    for (i = 0; i <= ERR_WARN_ALL; i++)
+    for (i = 0; i <= WARN_ALL; i++)
         printf("    %-23s %s%s\n",
                warnings[i].name, warnings[i].help,
-               i == ERR_WARN_ALL ? "\n" :
+               i == WARN_ALL ? "\n" :
                warnings[i].enabled ? " (default on)" :
                " (default off)");
 
diff --git a/asm/parser.c b/asm/parser.c
index 297af262..93eae1b4 100644
--- a/asm/parser.c
+++ b/asm/parser.c
@@ -475,7 +475,7 @@ restart_parse:
         if (i == ':') {         /* skip over the optional colon */
             i = stdscan(NULL, &tokval);
         } else if (i == 0) {
-            nasm_error(ERR_WARNING | ERR_WARN_OL | ERR_PASS1,
+            nasm_error(ERR_WARNING | WARN_OL | ERR_PASS1,
                   "label alone on a line without a colon might be in error");
         }
         if (i != TOKEN_INSN || tokval.t_integer != I_EQU) {
diff --git a/asm/pragma.c b/asm/pragma.c
index a4e76094..85e8c9cd 100644
--- a/asm/pragma.c
+++ b/asm/pragma.c
@@ -146,11 +146,11 @@ found_it:
     case DIRR_UNKNOWN:
         switch (pragma->opcode) {
         case D_none:
-            nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
+            nasm_error(ERR_WARNING|ERR_PASS2|WARN_BAD_PRAGMA,
                        "empty %%pragma %s", pragma->facility_name);
             break;
         default:
-            nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_UNKNOWN_PRAGMA,
+            nasm_error(ERR_WARNING|ERR_PASS2|WARN_UNKNOWN_PRAGMA,
                        "unknown %%pragma %s %s",
                        pragma->facility_name, pragma->opname);
             break;
@@ -185,7 +185,7 @@ void process_pragma(char *str)
 
     pragma.facility_name = nasm_get_word(str, &p);
     if (!pragma.facility_name) {
-	nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
+	nasm_error(ERR_WARNING|ERR_PASS2|WARN_BAD_PRAGMA,
 		   "empty pragma directive");
         return;                 /* Empty pragma */
     }
diff --git a/asm/preproc.c b/asm/preproc.c
index ecf89f1b..3b8de02b 100644
--- a/asm/preproc.c
+++ b/asm/preproc.c
@@ -2193,7 +2193,7 @@ static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive)
 
     if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min &&
         !def->plus)
-        nasm_error(ERR_WARNING|ERR_PASS1|ERR_WARN_MDP,
+        nasm_error(ERR_WARNING|ERR_PASS1|WARN_MDP,
               "too many default macro parameters");
 
     return true;
@@ -2731,7 +2731,7 @@ static int do_directive(Token *tline, char **output)
         severity = ERR_NONFATAL;
         goto issue_error;
     case PP_WARNING:
-        severity = ERR_WARNING|ERR_WARN_USER;
+        severity = ERR_WARNING|WARN_USER;
         goto issue_error;
 
 issue_error:
@@ -3046,7 +3046,7 @@ issue_error:
                            count, nasm_limit[LIMIT_REP]);
                 count = 0;
             } else if (count < 0) {
-                nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_NEG_REP,
+                nasm_error(ERR_WARNING|ERR_PASS2|WARN_NEG_REP,
                            "negative `%%rep' count: %"PRId64, count);
                 count = 0;
             } else {
@@ -4387,7 +4387,7 @@ again:
                                              m->casesense)))
                             m = m->next;
                         if (!m)
-                            nasm_error(ERR_WARNING|ERR_PASS1|ERR_WARN_MNP,
+                            nasm_error(ERR_WARNING|ERR_PASS1|WARN_MNP,
                                   "macro `%s' exists, "
                                   "but not taking %d parameters",
                                   mstart->text, nparam);
@@ -4689,7 +4689,7 @@ static MMacro *is_mmacro(Token * tline, Token *** params_array)
      * After all that, we didn't find one with the right number of
      * parameters. Issue a warning, and fail to expand the macro.
      */
-    nasm_error(ERR_WARNING|ERR_PASS1|ERR_WARN_MNP,
+    nasm_error(ERR_WARNING|ERR_PASS1|WARN_MNP,
           "macro `%s' exists, but not taking %d parameters",
           tline->text, nparam);
     nasm_free(params);
diff --git a/asm/stdscan.c b/asm/stdscan.c
index 8e175905..5f938150 100644
--- a/asm/stdscan.c
+++ b/asm/stdscan.c
@@ -168,7 +168,7 @@ int stdscan(void *private_data, struct tokenval *tv)
         token_type = nasm_token_hash(ourcopy, tv);
 
 	if (unlikely(tv->t_flag & TFLAG_WARN)) {
-	    nasm_error(ERR_WARNING|ERR_PASS1|ERR_WARN_PTR,
+	    nasm_error(ERR_WARNING|ERR_PASS1|WARN_PTR,
 		       "`%s' is not a NASM keyword", tv->t_charptr);
 	}
 
diff --git a/include/error.h b/include/error.h
index f7e38af3..63ec12b6 100644
--- a/include/error.h
+++ b/include/error.h
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------- *
  *
- *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
  *   See the file AUTHORS included with the NASM distribution for
  *   the specific copyright holders.
  *
@@ -85,53 +85,53 @@ static inline vefunc nasm_set_verror(vefunc ve)
  * These codes define specific types of suppressible warning.
  */
 
-#define ERR_WARN_MASK   0xFFFFF000      /* the mask for this feature */
-#define ERR_WARN_SHR    12              /* how far to shift right */
+#define WARN_MASK   0xFFFFF000      /* the mask for this feature */
+#define WARN_SHR    12              /* how far to shift right */
 
-#define WARN(x)         ((x) << ERR_WARN_SHR)
-#define WARN_IDX(x)     (((x) & ERR_WARN_MASK) >> ERR_WARN_SHR)
+#define WARN(x)         ((x) << WARN_SHR)
+#define WARN_IDX(x)     (((x) & WARN_MASK) >> WARN_SHR)
 
-#define ERR_WARN_OTHER          WARN( 0) /* any noncategorized warning */
-#define ERR_WARN_MNP            WARN( 1) /* macro-num-parameters warning */
-#define ERR_WARN_MSR            WARN( 2) /* macro self-reference */
-#define ERR_WARN_MDP            WARN( 3) /* macro default parameters check */
-#define ERR_WARN_OL             WARN( 4) /* orphan label (no colon, and
+#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 ERR_WARN_NOV            WARN( 5) /* numeric overflow */
-#define ERR_WARN_GNUELF         WARN( 6) /* using GNU ELF extensions */
-#define ERR_WARN_FL_OVERFLOW    WARN( 7) /* FP overflow */
-#define ERR_WARN_FL_DENORM      WARN( 8) /* FP denormal */
-#define ERR_WARN_FL_UNDERFLOW   WARN( 9) /* FP underflow */
-#define ERR_WARN_FL_TOOLONG     WARN(10) /* FP too many digits */
-#define ERR_WARN_USER           WARN(11) /* %warning directives */
-#define ERR_WARN_LOCK		WARN(12) /* bad LOCK prefixes */
-#define ERR_WARN_HLE		WARN(13) /* bad HLE prefixes */
-#define ERR_WARN_BND		WARN(14) /* bad BND prefixes */
-#define ERR_WARN_ZEXTRELOC	WARN(15) /* relocation zero-extended */
-#define ERR_WARN_PTR		WARN(16) /* not a NASM keyword */
-#define ERR_WARN_BAD_PRAGMA	WARN(17) /* malformed pragma */
-#define ERR_WARN_UNKNOWN_PRAGMA	WARN(18) /* unknown pragma */
-#define ERR_WARN_NOTMY_PRAGMA	WARN(19) /* pragma inapplicable */
-#define ERR_WARN_UNK_WARNING	WARN(20) /* unknown warning */
-#define ERR_WARN_NEG_REP	WARN(21) /* negative repeat count */
-#define ERR_WARN_PHASE		WARN(22) /* phase error in pass 1 */
+#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_PTR		WARN(16) /* not a NASM keyword */
+#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_PHASE		WARN(22) /* phase error in pass 1 */
 
 /* The "all" warning acts as a global switch, it must come last */
-#define ERR_WARN_ALL            23 /* Do not use WARN() here */
+#define WARN_ALL            23 /* Do not use WARN() here */
 
 struct warning {
     const char *name;
     const char *help;
     bool enabled;
 };
-extern const struct warning warnings[ERR_WARN_ALL+1];
+extern const struct warning warnings[WARN_ALL+1];
 
 /* This is a bitmask */
 #define WARN_ST_ENABLED      1   /* Warning is currently enabled */
 #define WARN_ST_ERROR        2   /* Treat this warning as an error */
 
-extern uint8_t warning_state[ERR_WARN_ALL];
-extern uint8_t warning_state_init[ERR_WARN_ALL];
+extern uint8_t warning_state[WARN_ALL];
+extern uint8_t warning_state_init[WARN_ALL];
 
 /* Process a warning option or directive */
 bool set_warning_status(const char *);
diff --git a/nasmlib/readnum.c b/nasmlib/readnum.c
index 47080884..60d856e1 100644
--- a/nasmlib/readnum.c
+++ b/nasmlib/readnum.c
@@ -164,7 +164,7 @@ int64_t readnum(const char *str, bool *error)
     }
 
     if (warn)
-        nasm_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
+        nasm_error(ERR_WARNING | ERR_PASS1 | WARN_NOV,
 		   "numeric constant %s does not fit in 64 bits",
 		   str);
 
diff --git a/output/outdbg.c b/output/outdbg.c
index debe30f7..fdf35aa2 100644
--- a/output/outdbg.c
+++ b/output/outdbg.c
@@ -380,7 +380,7 @@ dbg_pragma(const struct pragma *pragma)
                 errno = 0;
                 arg = strtoul(pragma->tail, &ep, 0);
                 if (errno || *nasm_skip_spaces(ep)) {
-                    nasm_error(ERR_WARNING | ERR_WARN_BAD_PRAGMA | ERR_PASS2,
+                    nasm_error(ERR_WARNING | WARN_BAD_PRAGMA | ERR_PASS2,
                                "invalid %%pragma dbg maxdump argument");
                     return DIRR_ERROR;
                 } else {
diff --git a/output/outelf.c b/output/outelf.c
index a32e1335..de99d076 100644
--- a/output/outelf.c
+++ b/output/outelf.c
@@ -935,7 +935,7 @@ static void elf32_out(int32_t segto, const void *data,
         }
 
         if (gnu16) {
-            nasm_error(ERR_WARNING | ERR_WARN_GNUELF,
+            nasm_error(ERR_WARNING | WARN_GNUELF,
                   "8- or 16-bit relocations in ELF32 is a GNU extension");
         } else if (asize != 4 && segment != NO_SEG) {
             nasm_error(ERR_NONFATAL, "Unsupported non-32-bit ELF relocation");
@@ -961,7 +961,7 @@ rel12adr:
                   " segment base references");
         } else {
             if (wrt == NO_SEG) {
-                nasm_error(ERR_WARNING | ERR_WARN_GNUELF,
+                nasm_error(ERR_WARNING | WARN_GNUELF,
                       "8- or 16-bit relocations in ELF is a GNU extension");
                 elf_add_reloc(s, segment, 0, reltype);
             } else {

From 64b56eaa3961038302ea3a8cc20d1f39c8d03c01 Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 15:56:28 -0800
Subject: [PATCH 02/11] configure: add -Wno-shift-negative-value

Shifting negative values is undefined in standard C, but we have tons
of dependencies that signed arithmetic is 2's-complement in the code
anyway, and on gcc-like compilers we pass the -fwrapv option to
indicate exactly that. Therefore, this is not a valid warning in our
case and should be suppressed.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
---
 configure.ac | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/configure.ac b/configure.ac
index e707158c..38b3b596 100644
--- a/configure.ac
+++ b/configure.ac
@@ -281,6 +281,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],

From 93367ea97b5984cd3b1b53d4ec9f3e6b7fd05a73 Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 15:58:32 -0800
Subject: [PATCH 03/11] warnings; move WARN_OTHER to the end; allow
 non-warnings to be suppressed

Putting WARN_OTHER at the end of the list creates a number of
advantages and simplifications:

1. It is more user friendly! It is far more of a logical location for
   the default case to be at the end of the printed list.
2. The value 0 can be used in a number of places to indicate a
   non-suppressible event. By having warning_state[0] always contain
   WARN_ST_ENABLED, we can always do the table lookup, even.
3. It means non-warnings (except fatal/panic) can now be conditioned
   on warning states. In those cases, WARN_*, including WARN_OTHER,
   can be added to the mask for any category. This is especially
   useful for notes.

The only downside is that we have to explicitly detect the case where
we have ERR_WARNING but no WARN_ flag. This is a trivial test.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
---
 asm/error.c     |   7 ++-
 asm/nasm.c      | 142 +++++++++++++++++++++++++-----------------------
 include/error.h |  45 +++++++--------
 3 files changed, 102 insertions(+), 92 deletions(-)

diff --git a/asm/error.c b/asm/error.c
index c61ee390..e5e0a1cc 100644
--- a/asm/error.c
+++ b/asm/error.c
@@ -47,7 +47,7 @@
  * the [warning] directive.
  */
 const struct warning warnings[WARN_ALL+1] = {
-    {"other", "any warning not specifially mentioned below", true},
+    {NULL, NULL, true},	/* must be true - used for unconditional enable */
     {"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},
@@ -71,7 +71,8 @@ const struct warning warnings[WARN_ALL+1] = {
     {"negative-rep", "regative %rep count", true},
     {"phase", "phase error during stabilization", false},
 
-    /* THIS ENTRY MUST COME LAST */
+    /* THESE ENTRIES SHOULD COME LAST */
+    {"other", "any warning not specifially mentioned below", true},
     {"all", "all possible warnings", false}
 };
 
@@ -182,7 +183,7 @@ bool set_warning_status(const char *value)
         value = NULL;
 
     /* This is inefficient, but it shouldn't matter... */
-    for (i = 0; i < WARN_ALL; i++) {
+    for (i = 1; i < WARN_ALL; i++) {
         if (!value || !nasm_stricmp(value, warnings[i].name)) {
             ok = true;          /* At least one action taken */
             switch (action) {
diff --git a/asm/nasm.c b/asm/nasm.c
index 42d3c6c6..bf76fb97 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 *, StrList **);
-static bool is_suppressed_warning(int severity);
 static bool skip_this_pass(int severity);
 static void nasm_verror_gnu(int severity, const char *fmt, va_list args);
 static void nasm_verror_vc(int severity, const char *fmt, va_list args);
@@ -1343,7 +1342,10 @@ 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 */
+    /*
+     * 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].enabled ? WARN_ST_ENABLED : 0;
@@ -1722,6 +1724,70 @@ static void assemble_file(const char *fname, StrList **depend_ptr)
     }
 }
 
+/**
+ * get warning index; 0 if this is non-suppressible.
+ */
+static size_t warn_index(int severity)
+{
+    size_t index;
+
+    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 can never skip fatal errors as by definition they cannot be
+     * resumed from.
+     */
+    if ((severity & ERR_MASK) >= ERR_FATAL)
+	return false;
+
+    /*
+     * passn is 1 on the very first pass only.
+     * pass0 is 2 on the code-generation (final) pass only.
+     * These are the passes we care about in this case.
+     */
+    return (((severity & ERR_PASS1) && passn != 1) ||
+	    ((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)
+{
+    return !(warning_state[warn_index(severity)] & WARN_ST_ENABLED);
+}
+
+/**
+ * check if we have a warning that should be promoted to an error
+ *
+ * @param severity the severity of the warning or error
+ * @return true if we should promote to error
+ */
+static bool warning_is_error(int severity)
+{
+    if ((severity & ERR_MASK) != ERR_WARNING)
+        return false;           /* Other message types  */
+
+    return !!(warning_state[warn_index(severity)] & WARN_ST_ERROR);
+}
+
 /**
  * gnu style error reporting
  * This function prints an error message to error_file in the
@@ -1741,7 +1807,7 @@ static void nasm_verror_gnu(int severity, const char *fmt, va_list ap)
     const char *currentfile = NULL;
     int32_t lineno = 0;
 
-    if (is_suppressed_warning(severity))
+    if (is_suppressed(severity))
         return;
 
     if (!(severity & ERR_NOFILE)) {
@@ -1782,7 +1848,7 @@ static void nasm_verror_vc(int severity, const char *fmt, va_list ap)
     const char *currentfile = NULL;
     int32_t lineno = 0;
 
-    if (is_suppressed_warning(severity))
+    if (is_suppressed(severity))
         return;
 
     if (!(severity & ERR_NOFILE))
@@ -1799,62 +1865,6 @@ static void nasm_verror_vc(int severity, const char *fmt, va_list ap)
     nasm_verror_common(severity, fmt, ap);
 }
 
-/*
- * 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
- */
-static bool is_suppressed_warning(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;
-}
-
-static bool warning_is_error(int severity)
-{
-    if (is_valid_warning(severity))
-        return !!(warning_state[WARN_IDX(severity)] & WARN_ST_ERROR);
-    else
-        return false;
-}
-
-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.
-     */
-    if ((severity & ERR_MASK) > ERR_NONFATAL)
-	return false;
-
-    /*
-     * passn is 1 on the very first pass only.
-     * pass0 is 2 on the code-generation (final) pass only.
-     * These are the passes we care about in this case.
-     */
-    return (((severity & ERR_PASS1) && passn != 1) ||
-	    ((severity & ERR_PASS2) && pass0 != 2));
-}
-
 /**
  * common error reporting
  * This is the common back end of the error reporting schemes currently
@@ -1870,7 +1880,6 @@ static void nasm_verror_common(int severity, const char *fmt, va_list args)
     char msg[1024];
     const char *pfx;
     bool warn_is_err = warning_is_error(severity);
-    bool warn_is_other = WARN_IDX(severity) == WARN_OTHER;
 
     switch (severity & (ERR_MASK|ERR_NO_SEVERITY)) {
     case ERR_NOTE:
@@ -1900,11 +1909,11 @@ static void nasm_verror_common(int severity, const char *fmt, va_list args)
     }
 
     vsnprintf(msg, sizeof msg - 64, fmt, args);
-    if (is_valid_warning(severity) && (warn_is_err || !warn_is_other)) {
+    if ((severity & ERR_MASK) == ERR_WARNING && !is_suppressed(severity)) {
         char *p = strchr(msg, '\0');
 	snprintf(p, 64, " [-w+%s%s]",
                  warn_is_err ? "error=" : "",
-                 warnings[WARN_IDX(severity)].name);
+                 warnings[warn_index(severity)].name);
     }
 
     if (!skip_this_pass(severity))
@@ -2044,14 +2053,13 @@ 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].enabled ? " [on]" : " [off]");
 
     if (xopt == 'f') {
         printf("valid output formats for -f are"
diff --git a/include/error.h b/include/error.h
index 63ec12b6..1d904849 100644
--- a/include/error.h
+++ b/include/error.h
@@ -83,41 +83,42 @@ 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
+#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_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 */
 
-/* The "all" warning acts as a global switch, it must come last */
-#define WARN_ALL            23 /* Do not use WARN() here */
+/* These two should come last */
+#define WARN_ALL		(22+2) /* Do not use WARN() here */
+#define WARN_OTHER		WARN(WARN_ALL-1) /* any noncategorized warning */
 
 struct warning {
     const char *name;

From eb48c1191d0464c1a09503269fe09a33f43b8da9 Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 16:11:08 -0800
Subject: [PATCH 04/11] warnings: make it possible for a warning to default to
 an error

This allows us to do soft-migration of warnings to errors; they will
now be nonfatal errors by default, but gives the user the option to
demote them.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
---
 asm/error.c     | 56 ++++++++++++++++++++++++++-----------------------
 asm/nasm.c      |  9 ++++----
 include/error.h | 13 ++++++------
 3 files changed, 40 insertions(+), 38 deletions(-)

diff --git a/asm/error.c b/asm/error.c
index e5e0a1cc..8e5ec7f3 100644
--- a/asm/error.c
+++ b/asm/error.c
@@ -46,34 +46,38 @@
  * Description of the suppressible warnings for the command line and
  * the [warning] directive.
  */
+#define on	(WARN_ST_ENABLED)
+#define off	0
+#define err	(WARN_ST_ENABLED|WARN_ST_ERROR)
+
 const struct warning warnings[WARN_ALL+1] = {
-    {NULL, NULL, true},	/* must be true - used for unconditional enable */
-    {"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},
+    {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},
 
     /* THESE ENTRIES SHOULD COME LAST */
-    {"other", "any warning not specifially mentioned below", true},
-    {"all", "all possible warnings", false}
+    {"other", "any warning not specifially mentioned below", on},
+    {"all", "all possible warnings", off}
 };
 
 uint8_t warning_state[WARN_ALL];/* Current state */
@@ -120,7 +124,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/nasm.c b/asm/nasm.c
index bf76fb97..ac3cd1c2 100644
--- a/asm/nasm.c
+++ b/asm/nasm.c
@@ -1346,10 +1346,8 @@ static void parse_cmdline(int argc, char **argv, int pass)
      * 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].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.
@@ -2059,7 +2057,8 @@ static void help(const char xopt)
         printf("    %-23s %s%s\n",
                warnings[i].name, warnings[i].help,
                i == WARN_ALL ? "\n" :
-               warnings[i].enabled ? " [on]" : " [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/include/error.h b/include/error.h
index 1d904849..cd64a497 100644
--- a/include/error.h
+++ b/include/error.h
@@ -120,17 +120,16 @@ static inline vefunc nasm_set_verror(vefunc ve)
 #define WARN_ALL		(22+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 */
 #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];
 

From bdf017c89c7fc66db78ab49729136423d4ce04fe Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 16:12:36 -0800
Subject: [PATCH 05/11] warnings: WARN_OTHER is now "above", not "below"

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
---
 asm/error.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/asm/error.c b/asm/error.c
index 8e5ec7f3..61c89740 100644
--- a/asm/error.c
+++ b/asm/error.c
@@ -76,7 +76,7 @@ const struct warning warnings[WARN_ALL+1] = {
     {"phase", "phase error during stabilization", off},
 
     /* THESE ENTRIES SHOULD COME LAST */
-    {"other", "any warning not specifially mentioned below", on},
+    {"other", "any warning not specifially mentioned above", on},
     {"all", "all possible warnings", off}
 };
 

From 46016cb3688bf8582f47967e09b06b69ea271e75 Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 16:47:04 -0800
Subject: [PATCH 06/11] listing.c: handle multiple error messages on a single
 line

We may produce an arbitrary number of error messages on a single line;
include all of them in the list file.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
---
 asm/listing.c | 75 +++++++++++++++++++++++++++++++++------------------
 1 file changed, 49 insertions(+), 26 deletions(-)

diff --git a/asm/listing.c b/asm/listing.c
index 6c459e13..fe7c5e92 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)
@@ -142,7 +147,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;
@@ -327,10 +333,27 @@ static void list_downlevel(int type)
 
 static void list_error(int severity, const char *pfx, const char *msg)
 {
+    size_t l1, l2;
+    struct list_error *le;
+    char *p;
+
     if (!listfp)
 	return;
 
-    snprintf(listerror, sizeof listerror, "%s%s", pfx, msg);
+    l1 = strlen(pfx);
+    l2 = strlen(msg);
+
+    /* sizeof(*le) already accounts for the final NULL */
+    le = nasm_malloc(sizeof(*le) + l1 + l2);
+
+    le->next = NULL;
+    p = le->str;
+    p = mempcpy(p, pfx, l1);
+    p = mempcpy(p, msg, l2);
+    *p = '\0';
+
+    *listerr_tail = le;
+    listerr_tail = &le->next;
 
     if ((severity & ERR_MASK) >= ERR_FATAL)
 	list_emit();

From 950dee9edc475ae37d80e88b7048b8ff01d49a5f Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 16:49:07 -0800
Subject: [PATCH 07/11] BR 3392535: warning on redefine, promote
 define-on-pass2 to error

If we redefine consistently, make it a suppressed-by-default warning.
If we end up doing the define on pass 2, promote that to a
default-error warning; using a default-error warning allows the user
to demote it should they so wish.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
Requested-by: C. Masloch <pushbx@38.de>
---
 asm/error.c     |  2 ++
 asm/labels.c    | 52 ++++++++++++++++++++++++++++---------------------
 include/error.h |  7 ++++---
 3 files changed, 36 insertions(+), 25 deletions(-)

diff --git a/asm/error.c b/asm/error.c
index 61c89740..f6098f4c 100644
--- a/asm/error.c
+++ b/asm/error.c
@@ -74,6 +74,8 @@ const struct warning warnings[WARN_ALL+1] = {
     {"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},
diff --git a/asm/labels.c b/asm/labels.c
index a073f798..d0904ad3 100644
--- a/asm/labels.c
+++ b/asm/labels.c
@@ -494,35 +494,43 @@ 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.
-             */
+        /*
+         * Defined elsewhere in the program, seen in this pass.
+         */
+        if (changed) {
             nasm_error(ERR_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_error(ERR_NOTE, "label `%s' originally defined here",
+            noteflags = ERR_NOTE;
+        } else {
+            nasm_error(ERR_WARNING|WARN_LABEL_REDEF|ERR_PASS2,
+                       "label `%s' redefined to an identical value",
                        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_error(ERR_WARNING, "label `%s' %s during code generation",
-                       lptr->defn.label,
-                       created ? "defined" : "changed");
+            noteflags = ERR_NOTE|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 here", 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_error(ERR_WARNING|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/include/error.h b/include/error.h
index cd64a497..3d2b7a1a 100644
--- a/include/error.h
+++ b/include/error.h
@@ -95,8 +95,7 @@ static inline vefunc nasm_set_verror(vefunc ve)
 #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_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 */
@@ -115,9 +114,11 @@ static inline vefunc nasm_set_verror(vefunc ve)
 #define WARN_UNK_WARNING	WARN(20) /* unknown warning */
 #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 */
 
 /* These two should come last */
-#define WARN_ALL		(22+2) /* 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 */
 
 /* This is a bitmask */

From dea7f4733fb5316681db0e22b1143bb40254b330 Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin" <hpa@zytor.com>
Date: Mon, 10 Dec 2018 22:11:24 -0800
Subject: [PATCH 08/11] error: remove unused ERR_TOPFILE

The flag ERR_TOPFILE was not used anywhere, remove it.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>
---
 asm/nasm.c      | 6 ++++--
 include/error.h | 1 -
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/asm/nasm.c b/asm/nasm.c
index ac3cd1c2..939ed204 100644
--- a/asm/nasm.c
+++ b/asm/nasm.c
@@ -1810,8 +1810,10 @@ static void nasm_verror_gnu(int severity, const char *fmt, va_list ap)
 
     if (!(severity & ERR_NOFILE)) {
 	src_get(&lineno, &currentfile);
-        if (!currentfile || (severity & ERR_TOPFILE)) {
-            currentfile = inname[0] ? inname : outname[0] ? outname : NULL;
+        if (!currentfile) {
+            currentfile = inname && inname[0] ?
+		    inname : outname && outname[0] ?
+		    outname : NULL;
             lineno = 0;
         }
     }
diff --git a/include/error.h b/include/error.h
index 3d2b7a1a..d2f04f4c 100644
--- a/include/error.h
+++ b/include/error.h
@@ -72,7 +72,6 @@ static inline vefunc nasm_set_verror(vefunc ve)
                                          * and dump core for reference */
 #define ERR_MASK        0x00000007      /* mask off the above codes */
 #define ERR_NOFILE      0x00000010      /* don't give source file name/line */
-#define ERR_TOPFILE	0x00000020      /* give the top input file name only */
 #define ERR_USAGE       0x00000040      /* print a usage message */
 #define ERR_PASS1       0x00000080      /* only print this error on pass 1 */
 #define ERR_PASS2       0x00000100      /* only print this error on pass 2 */

From c0b32a36503e5dd3e109c8c2b40a8c2081111430 Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin" <hpa@zytor.com>
Date: Mon, 10 Dec 2018 22:29:49 -0800
Subject: [PATCH 09/11] errors: unify nasm_verror_{gnu,vc} and remove some
 ERR_NOFILE

The differences between nasm_verror_{gnu,vc} are a short handful of
strings, so unify them. Remove some additional ERR_NOFILE that are not
necessary.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>
---
 asm/nasm.c | 156 ++++++++++++++++++-----------------------------------
 1 file changed, 51 insertions(+), 105 deletions(-)

diff --git a/asm/nasm.c b/asm/nasm.c
index 939ed204..100e4b9c 100644
--- a/asm/nasm.c
+++ b/asm/nasm.c
@@ -77,12 +77,20 @@ struct forwrefinfo {            /* info held on forward refs. */
 static void parse_cmdline(int, char **, int);
 static void assemble_file(const char *, StrList **);
 static bool skip_this_pass(int severity);
-static void nasm_verror_gnu(int severity, const char *fmt, va_list args);
-static void nasm_verror_vc(int severity, const char *fmt, va_list args);
-static void nasm_verror_common(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 help(char xopt);
 
+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 bool using_debug_info, opt_verbose_info;
 static const char *debug_format;
 
@@ -452,7 +460,7 @@ int main(int argc, char **argv)
 
     pass0 = 0;
     want_usage = terminate_after_phase = false;
-    nasm_set_verror(nasm_verror_gnu);
+    nasm_set_verror(nasm_verror_asm);
 
     error_file = stderr;
 
@@ -489,7 +497,7 @@ int main(int argc, char **argv)
     } else {
         dfmt = dfmt_find(ofmt, debug_format);
         if (!dfmt) {
-            nasm_fatal(ERR_NOFILE | ERR_USAGE,
+            nasm_fatal(ERR_USAGE,
                        "unrecognized debug format `%s' for"
                        " output format `%s'",
                        debug_format, ofmt->shortname);
@@ -556,9 +564,7 @@ int main(int argc, char **argv)
             if (outname) {
                 ofile = nasm_open_write(outname, NF_TEXT);
                 if (!ofile)
-                    nasm_fatal(ERR_NOFILE,
-                                 "unable to open output file `%s'",
-                                 outname);
+                    nasm_fatal(0, "unable to open output file `%s'", outname);
             } else
                 ofile = NULL;
 
@@ -898,9 +904,7 @@ static bool process_arg(char *p, char *q, int pass)
             if (pass == 1) {
                 ofmt = ofmt_find(param, &ofmt_alias);
                 if (!ofmt) {
-                    nasm_fatal(ERR_NOFILE | ERR_USAGE,
-                               "unrecognised output format `%s' - "
-                               "use -hf for a list", param);
+                    nasm_fatal(ERR_USAGE, "unrecognised output format `%s' - use -hf for a list", param);
                 }
             }
             break;
@@ -994,14 +998,12 @@ static bool process_arg(char *p, char *q, int pass)
 
         case 'X':       /* specify error reporting format */
             if (pass == 1) {
-                if (nasm_stricmp("vc", param) == 0)
-                    nasm_set_verror(nasm_verror_vc);
-                else if (nasm_stricmp("gnu", param) == 0)
-                    nasm_set_verror(nasm_verror_gnu);
+                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_fatal(ERR_NOFILE | ERR_USAGE,
-                               "unrecognized error reporting format `%s'",
-                               param);
+                    nasm_fatal(ERR_USAGE, "unrecognized error reporting format `%s'", param);
             }
             break;
 
@@ -1401,8 +1403,7 @@ static void parse_cmdline(int argc, char **argv, int pass)
         return;
 
     if (!inname)
-        nasm_fatal(ERR_NOFILE | ERR_USAGE, "no input file specified");
-
+        nasm_fatal(ERR_USAGE, "no input file specified");
     else if ((errname && !strcmp(inname, errname)) ||
              (outname && !strcmp(inname, outname)) ||
              (listname &&  !strcmp(inname, listname))  ||
@@ -1413,9 +1414,7 @@ static void parse_cmdline(int argc, char **argv, int pass)
         error_file = nasm_open_write(errname, NF_TEXT);
         if (!error_file) {
             error_file = stderr;        /* Revert to default! */
-            nasm_fatal(ERR_NOFILE | ERR_USAGE,
-                       "cannot open file `%s' for error messages",
-                       errname);
+            nasm_fatal(ERR_USAGE, "cannot open file `%s' for error messages", errname);
         }
     }
 }
@@ -1786,85 +1785,6 @@ static bool warning_is_error(int severity)
     return !!(warning_state[warn_index(severity)] & WARN_ST_ERROR);
 }
 
-/**
- * gnu style error reporting
- * This function prints an error message to error_file in the
- * style used by GNU. An example would be:
- * file.asm:50: error: blah blah blah
- * where file.asm is the name of the file, 50 is the line number on
- * which the error occurs (or is detected) and "error:" is one of
- * the possible optional diagnostics -- it can be "error" or "warning"
- * or something else.  Finally the line terminates with the actual
- * error message.
- *
- * @param severity the severity of the warning or error
- * @param fmt the printf style format string
- */
-static void nasm_verror_gnu(int severity, const char *fmt, va_list ap)
-{
-    const char *currentfile = NULL;
-    int32_t lineno = 0;
-
-    if (is_suppressed(severity))
-        return;
-
-    if (!(severity & ERR_NOFILE)) {
-	src_get(&lineno, &currentfile);
-        if (!currentfile) {
-            currentfile = inname && inname[0] ?
-		    inname : outname && outname[0] ?
-		    outname : NULL;
-            lineno = 0;
-        }
-    }
-
-    if (!skip_this_pass(severity)) {
-        if (!lineno)
-            fprintf(error_file, "%s: ", currentfile ? currentfile : "nasm");
-        else
-            fprintf(error_file, "%s:%"PRId32": ", currentfile, lineno);
-    }
-
-    nasm_verror_common(severity, fmt, ap);
-}
-
-/**
- * MS style error reporting
- * This function prints an error message to error_file in the
- * style used by Visual C and some other Microsoft tools. An example
- * would be:
- * file.asm(50) : error: blah blah blah
- * where file.asm is the name of the file, 50 is the line number on
- * which the error occurs (or is detected) and "error:" is one of
- * the possible optional diagnostics -- it can be "error" or "warning"
- * or something else.  Finally the line terminates with the actual
- * error message.
- *
- * @param severity the severity of the warning or error
- * @param fmt the printf style format string
- */
-static void nasm_verror_vc(int severity, const char *fmt, va_list ap)
-{
-    const char *currentfile = NULL;
-    int32_t lineno = 0;
-
-    if (is_suppressed(severity))
-        return;
-
-    if (!(severity & ERR_NOFILE))
-        src_get(&lineno, &currentfile);
-
-    if (!skip_this_pass(severity)) {
-        if (lineno) {
-	    fprintf(error_file, "%s(%"PRId32") : ", currentfile, lineno);
-	} else {
-            fprintf(error_file , "%s : ", currentfile ? currentfile : "nasm");
-	}
-    }
-
-    nasm_verror_common(severity, fmt, ap);
-}
-
 /**
  * common error reporting
  * This is the common back end of the error reporting schemes currently
@@ -1875,11 +1795,29 @@ static void nasm_verror_vc(int severity, const char *fmt, va_list ap)
  * @param severity the severity of the warning or error
  * @param fmt the printf style format string
  */
-static void nasm_verror_common(int severity, const char *fmt, va_list args)
+static void nasm_verror_asm(int severity, const char *fmt, va_list args)
 {
     char msg[1024];
     const char *pfx;
     bool warn_is_err = warning_is_error(severity);
+    const char *currentfile = NULL;
+    int32_t lineno = 0;
+
+    if (is_suppressed(severity))
+        return;
+
+    if (!(severity & ERR_NOFILE)) {
+	src_get(&lineno, &currentfile);
+        if (!currentfile) {
+            currentfile = currentfile ? currentfile :
+                inname && inname[0] ? inname :
+                outname && outname[0] ? outname :
+                NULL;
+            lineno = 0;
+        }
+    }
+    if (!currentfile)
+        currentfile = "nasm";
 
     switch (severity & (ERR_MASK|ERR_NO_SEVERITY)) {
     case ERR_NOTE:
@@ -1916,8 +1854,16 @@ static void nasm_verror_common(int severity, const char *fmt, va_list args)
                  warnings[warn_index(severity)].name);
     }
 
-    if (!skip_this_pass(severity))
-	fprintf(error_file, "%s%s\n", pfx, msg);
+    if (!skip_this_pass(severity)) {
+        if (!lineno) {
+            fprintf(error_file, "%s%s%s%s\n",
+                    currentfile, errfmt->beforemsg, pfx, msg);
+        } else {
+            fprintf(error_file, "%s%s%"PRId32"%s%s%s%s\n",
+                    currentfile, errfmt->beforeline, lineno,
+                    errfmt->afterline, errfmt->beforemsg, pfx, msg);
+        }
+    }
 
     /* Are we recursing from error_list_macros? */
     if (severity & ERR_PP_LISTMACRO)

From e2f5edbb3a24db347e4f52cdf134402ab987b085 Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin" <hpa@zytor.com>
Date: Tue, 11 Dec 2018 00:06:29 -0800
Subject: [PATCH 10/11] error: new flag ERR_HERE

ERR_HERE is used to mark messages of the form "... here" so that we
can emit sane output to the list file with filename and line number,
instead of a nonsensical "here" which could point almost anywhere.

This patch contains some changes from the one in the master branch to
make the code cleaner.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>
---
 asm/labels.c    |   7 +--
 asm/listing.c   |  22 ++++-----
 asm/listing.h   |   2 +-
 asm/nasm.c      | 122 +++++++++++++++++++++++++++---------------------
 asm/preproc.c   |   4 +-
 include/error.h |   1 +
 6 files changed, 87 insertions(+), 71 deletions(-)

diff --git a/asm/labels.c b/asm/labels.c
index d0904ad3..a3ed0066 100644
--- a/asm/labels.c
+++ b/asm/labels.c
@@ -506,17 +506,18 @@ void define_label(const char *label, int32_t segment,
             nasm_error(ERR_NONFATAL,
                        "label `%s' inconsistently redefined",
                        lptr->defn.label);
-            noteflags = ERR_NOTE;
+            noteflags = ERR_NOTE|ERR_HERE;
         } else {
             nasm_error(ERR_WARNING|WARN_LABEL_REDEF|ERR_PASS2,
                        "label `%s' redefined to an identical value",
                        lptr->defn.label);
-            noteflags = ERR_NOTE|WARN_LABEL_REDEF|ERR_PASS2;
+            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 here", lptr->defn.label);
+        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) {
         /*
diff --git a/asm/listing.c b/asm/listing.c
index fe7c5e92..4d753dbd 100644
--- a/asm/listing.c
+++ b/asm/listing.c
@@ -331,27 +331,27 @@ static void list_downlevel(int type)
     }
 }
 
-static void list_error(int severity, const char *pfx, const char *msg)
+static void list_error(int severity, const char *fmt, ...)
 {
-    size_t l1, l2;
     struct list_error *le;
-    char *p;
+    va_list ap;
+    int len;
 
     if (!listfp)
 	return;
 
-    l1 = strlen(pfx);
-    l2 = strlen(msg);
+    va_start(ap, fmt);
+    len = vsnprintf(NULL, 0, fmt, ap);
+    va_end(ap);
 
     /* sizeof(*le) already accounts for the final NULL */
-    le = nasm_malloc(sizeof(*le) + l1 + l2);
+    le = nasm_malloc(sizeof(*le) + len);
+
+    va_start(ap, fmt);
+    vsnprintf(le->str, len+1, fmt, ap);
+    va_end(ap);
 
     le->next = NULL;
-    p = le->str;
-    p = mempcpy(p, pfx, l1);
-    p = mempcpy(p, msg, l2);
-    *p = '\0';
-
     *listerr_tail = le;
     listerr_tail = &le->next;
 
diff --git a/asm/listing.h b/asm/listing.h
index df88e8a8..f3ddb0e0 100644
--- a/asm/listing.h
+++ b/asm/listing.h
@@ -96,7 +96,7 @@ struct lfmt {
     /*
      * Called on a warning or error, with the error message.
      */
-    void (*error)(int severity, const char *pfx, const char *msg);
+    void printf_func(2, 3) (*error)(int severity, const char *fmt, ...);
 
     /*
      * Update the current offset.  Used to give the listing generator
diff --git a/asm/nasm.c b/asm/nasm.c
index 100e4b9c..ddc3404e 100644
--- a/asm/nasm.c
+++ b/asm/nasm.c
@@ -1768,21 +1768,35 @@ static bool skip_this_pass(int severity)
  */
 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);
 }
 
 /**
- * check if we have a warning that should be promoted to an error
+ * 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 promote to error
+ * @return true if we should error out
  */
-static bool warning_is_error(int severity)
+static int true_error_type(int severity)
 {
-    if ((severity & ERR_MASK) != ERR_WARNING)
-        return false;           /* Other message types  */
+    const uint8_t warn_is_err = WARN_ST_ENABLED|WARN_ST_ERROR;
+    int type;
 
-    return !!(warning_state[warn_index(severity)] & WARN_ST_ERROR);
+    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;
 }
 
 /**
@@ -1798,10 +1812,17 @@ static bool warning_is_error(int severity)
 static void nasm_verror_asm(int severity, const char *fmt, va_list args)
 {
     char msg[1024];
+    char warnsuf[64];
+    char linestr[64];
     const char *pfx;
-    bool warn_is_err = warning_is_error(severity);
+    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(severity))
         return;
@@ -1816,53 +1837,38 @@ static void nasm_verror_asm(int severity, const char *fmt, va_list args)
             lineno = 0;
         }
     }
-    if (!currentfile)
-        currentfile = "nasm";
 
-    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:
+    /*
+     * 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) && true_type <= ERR_WARNING)
+        return;
+
+    if (severity & ERR_NO_SEVERITY)
         pfx = "";
-        break;
-    }
+    else
+        pfx = pfx_table[true_type];
 
-    vsnprintf(msg, sizeof msg - 64, fmt, args);
-    if ((severity & ERR_MASK) == ERR_WARNING && !is_suppressed(severity)) {
-        char *p = strchr(msg, '\0');
-	snprintf(p, 64, " [-w+%s%s]",
-                 warn_is_err ? "error=" : "",
+    vsnprintf(msg, sizeof msg, fmt, args);
+    *warnsuf = 0;
+    if (spec_type == ERR_WARNING) {
+	snprintf(warnsuf, sizeof warnsuf, " [-w+%s%s]",
+                 true_type ? "error=" : "",
                  warnings[warn_index(severity)].name);
     }
 
+    *linestr = 0;
+    if (lineno) {
+        snprintf(linestr, sizeof linestr, "%s%"PRId32"%s",
+                 errfmt->beforeline, lineno, errfmt->afterline);
+    }
+
     if (!skip_this_pass(severity)) {
-        if (!lineno) {
-            fprintf(error_file, "%s%s%s%s\n",
-                    currentfile, errfmt->beforemsg, pfx, msg);
-        } else {
-            fprintf(error_file, "%s%s%"PRId32"%s%s%s%s\n",
-                    currentfile, errfmt->beforeline, lineno,
-                    errfmt->afterline, errfmt->beforemsg, pfx, msg);
-        }
+        fprintf(error_file, "%s%s%s%s%s%s%s\n",
+                currentfile ? currentfile : "nasm",
+                linestr, errfmt->beforemsg, pfx, msg,
+                (severity & ERR_HERE) ? " here" : "", warnsuf);
     }
 
     /* Are we recursing from error_list_macros? */
@@ -1873,7 +1879,19 @@ static void nasm_verror_asm(int severity, const char *fmt, va_list args)
      * Don't suppress this with skip_this_pass(), or we don't get
      * pass1 or preprocessor warnings in the list file
      */
-    lfmt->error(severity, pfx, msg);
+    if (severity & ERR_HERE) {
+        if (lineno)
+            lfmt->error(severity, "%s%s at %s:%"PRId32"%s",
+                        pfx, msg, currentfile, lineno, warnsuf);
+        else if (currentfile)
+            lfmt->error(severity, "%s%s in file %s%s",
+                        pfx, msg, currentfile, warnsuf);
+        else
+            lfmt->error(severity, "%s%s in unknown location%s",
+                        pfx, msg, warnsuf);
+    } else {
+        lfmt->error(severity, "%s%s%s", pfx, msg, warnsuf);
+    }
 
     if (skip_this_pass(severity))
         return;
@@ -1883,15 +1901,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;
diff --git a/asm/preproc.c b/asm/preproc.c
index 3b8de02b..b134414a 100644
--- a/asm/preproc.c
+++ b/asm/preproc.c
@@ -5451,7 +5451,7 @@ static void pp_list_one_macro(MMacro *m, int severity)
 
     if (m->name && !m->nolist) {
 	src_set(m->xline + m->lineno, m->fname);
-	nasm_error(severity, "... from macro `%s' defined here", m->name);
+	nasm_error(severity, "... from macro `%s' defined", m->name);
     }
 }
 
@@ -5460,7 +5460,7 @@ static void pp_error_list_macros(int severity)
     int32_t saved_line;
     const char *saved_fname = NULL;
 
-    severity |= ERR_PP_LISTMACRO | ERR_NO_SEVERITY;
+    severity |= ERR_PP_LISTMACRO | ERR_NO_SEVERITY | ERR_HERE;
     src_get(&saved_line, &saved_fname);
 
     if (istk)
diff --git a/include/error.h b/include/error.h
index d2f04f4c..5a676e67 100644
--- a/include/error.h
+++ b/include/error.h
@@ -72,6 +72,7 @@ static inline vefunc nasm_set_verror(vefunc ve)
                                          * and dump core for reference */
 #define ERR_MASK        0x00000007      /* mask off the above codes */
 #define ERR_NOFILE      0x00000010      /* don't give source file name/line */
+#define ERR_HERE	0x00000020      /* point to a specific source location */
 #define ERR_USAGE       0x00000040      /* print a usage message */
 #define ERR_PASS1       0x00000080      /* only print this error on pass 1 */
 #define ERR_PASS2       0x00000100      /* only print this error on pass 2 */

From 51222ab69e7ac1854587321442638620aa4829ba Mon Sep 17 00:00:00 2001
From: "H. Peter Anvin (Intel)" <hpa@zytor.com>
Date: Wed, 12 Dec 2018 17:44:19 -0800
Subject: [PATCH 11/11] NASM 2.14.01rc3

---
 version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/version b/version
index 191b125d..388149de 100644
--- a/version
+++ b/version
@@ -1 +1 @@
-2.14.01rc2
+2.14.01rc3