asm/error.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * error.c - error message handling routines for the assembler
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include <stdlib.h>
  41
  42 #include "nasmlib.h"
  43 #include "error.h"
  44
  45 /*
  46  * Description of the suppressible warnings for the command line and
  47  * the [warning] directive.
  48  */
  49 const struct warning warnings[ERR_WARN_ALL+1] = {
  50         { "other",              "any warning not specifially mentioned below", true },
  51         { "macro-params",       "macro calls with wrong parameter count", true },
  52         { "macro-selfref",      "cyclic macro references", false },
  53         { "macro-defaults",     "macros with more default than optional parameters", true },
  54         { "orphan-labels",      "labels alone on lines without trailing `:'", true },
  55         { "number-overflow",    "numeric constant does not fit", true },
  56         { "gnu-elf-extensions", "using 8- or 16-bit relocation in ELF32, a GNU extension", false },
  57         { "float-overflow",     "floating point overflow", true },
  58         { "float-denorm",       "floating point denormal", false },
  59         { "float-underflow",    "floating point underflow", false },
  60         { "float-toolong",      "too many digits in floating-point number", true },
  61         { "user",               "%warning directives", true },
  62         { "lock",               "lock prefix on unlockable instructions", true },
  63         { "hle",                "invalid hle prefixes", true },
  64         { "bnd",                "invalid bnd prefixes", true },
  65         { "zext-reloc",         "relocation zero-extended to match output format", true },
  66         { "ptr",                "non-NASM keyword used in other assemblers", true },
  67         { "bad-pragma",         "empty or malformed %pragma", false },
  68         { "unknown-pragma",     "unknown %pragma facility or directive", false },
  69         { "not-my-pragma",      "%pragma not applicable to this compilation", false },
  70         { "unknown-warning",    "unknown warning in -W/-w or warning directive", false },
  71         { "negative-rep",       "regative %rep count", true },
  72         { "phase",              "phase error during stabilization", false },
  73
  74         /* THIS ENTRY MUST COME LAST */
  75         { "all",                "all possible warnings", false }
  76 };
  77
  78 /* Current state and command-line state, for reset */
  79 uint8_t warning_state[ERR_WARN_ALL];
  80 uint8_t warning_state_init[ERR_WARN_ALL];
  81
  82 /* Global error handling function */
  83 vefunc nasm_verror;
  84
  85 void nasm_error(int severity, const char *fmt, ...)
  86 {
  87         va_list ap;
  88
  89         va_start(ap, fmt);
  90         nasm_verror(severity, fmt, ap);
  91         va_end(ap);
  92 }
  93
  94 #define nasm_error_generatorf(__sev, __flags, __fmt)    \
  95         va_list __ap;                                   \
  96         va_start(__ap, __fmt);                          \
  97         nasm_verror(__sev | __flags, __fmt, __ap)
  98
  99 #define nasm_error_generator(__sev, __fmt)              \
 100         nasm_error_generatorf(__sev, 0, __fmt)
 101
 102 void nasm_debug(const char *fmt, ...)
 103 {
 104         nasm_error_generator(ERR_DEBUG, fmt);
 105 }
 106
 107 void nasm_debugf(int flags, const char *fmt, ...)
 108 {
 109         nasm_error_generatorf(ERR_DEBUG, flags, fmt);
 110 }
 111
 112 void nasm_warn(const char *fmt, ...)
 113 {
 114         nasm_error_generator(ERR_WARNING, fmt);
 115 }
 116
 117 void nasm_warnf(int flags, const char *fmt, ...)
 118 {
 119         nasm_error_generatorf(ERR_WARNING, flags, fmt);
 120 }
 121
 122 void nasm_nonfatal(const char *fmt, ...)
 123 {
 124         nasm_error_generator(ERR_NONFATAL, fmt);
 125 }
 126
 127 void nasm_nonfatalf(int flags, const char *fmt, ...)
 128 {
 129         nasm_error_generatorf(ERR_NONFATAL, flags, fmt);
 130 }
 131
 132 fatal_func nasm_fatal(const char *fmt, ...)
 133 {
 134         nasm_error_generator(ERR_FATAL, fmt);
 135         abort();
 136 }
 137
 138 fatal_func nasm_fatalf(int flags, const char *fmt, ...)
 139 {
 140         nasm_error_generatorf(ERR_FATAL, flags, fmt);
 141         abort();
 142 }
 143
 144 fatal_func nasm_panic(const char *fmt, ...)
 145 {
 146         nasm_error_generator(ERR_PANIC, fmt);
 147         abort();
 148 }
 149
 150 fatal_func nasm_panicf(int flags, const char *fmt, ...)
 151 {
 152         nasm_error_generatorf(ERR_PANIC, flags, fmt);
 153         abort();
 154 }
 155
 156 fatal_func nasm_panic_from_macro(const char *file, int line)
 157 {
 158         nasm_panic("internal error at %s:%d\n", file, line);
 159 }
 160
 161 fatal_func nasm_assert_failed(const char *file, int line, const char *msg)
 162 {
 163         nasm_panic("assertion %s failed at %s:%d", msg, file, line);
 164 }
 165
 166 #undef nasm_error_generator
 167 #undef nasm_error_generatorf
 168
 169 /*
 170  * This is called when processing a -w or -W option, or a warning directive.
 171  * Returns true if if the action was successful.
 172  */
 173 bool set_warning_status(const char *value)
 174 {
 175         enum warn_action { WID_OFF, WID_ON, WID_RESET };
 176         enum warn_action action;
 177         bool ok = false;
 178         uint8_t mask;
 179         int i;
 180
 181         value = nasm_skip_spaces(value);
 182         switch (*value) {
 183         case '-':
 184                 action = WID_OFF;
 185                 value++;
 186                 break;
 187         case '+':
 188                 action = WID_ON;
 189                 value++;
 190                 break;
 191         case '*':
 192                 action = WID_RESET;
 193                 value++;
 194                 break;
 195         case 'N':
 196         case 'n':
 197                 if (!nasm_strnicmp(value, "no-", 3)) {
 198                         action = WID_OFF;
 199                         value += 3;
 200                         break;
 201                 } else if (!nasm_stricmp(value, "none")) {
 202                         action = WID_OFF;
 203                         value = NULL;
 204                         break;
 205                 }
 206                 /* else fall through */
 207         default:
 208                 action = WID_ON;
 209                 break;
 210         }
 211
 212         mask = WARN_ST_ENABLED;
 213
 214         if (value && !nasm_strnicmp(value, "error", 5)) {
 215                 switch (value[5]) {
 216                 case '=':
 217                         mask = WARN_ST_ERROR;
 218                         value += 6;
 219                         break;
 220                 case '\0':
 221                         mask = WARN_ST_ERROR;
 222                         value = NULL;
 223                         break;
 224                 default:
 225                         /* Just an accidental prefix? */
 226                         break;
 227                 }
 228         }
 229
 230         if (value && !nasm_stricmp(value, "all"))
 231                 value = NULL;
 232
 233         /* This is inefficient, but it shouldn't matter... */
 234         for (i = 0; i < ERR_WARN_ALL; i++) {
 235                 if (!value || !nasm_stricmp(value, warnings[i].name)) {
 236                         ok = true; /* At least one action taken */
 237                         switch (action) {
 238                         case WID_OFF:
 239                                 warning_state[i] &= ~mask;
 240                                 break;
 241                         case WID_ON:
 242                                 warning_state[i] |= mask;
 243                                 break;
 244                         case WID_RESET:
 245                                 warning_state[i] &= ~mask;
 246                                 warning_state[i] |= warning_state_init[i] & mask;
 247                                 break;
 248                         }
 249                 }
 250         }
 251
 252         return ok;
 253 }