From 77f53ba6d4cb90e5a7e09b33357ed7c1fe9f6b9d Mon Sep 17 00:00:00 2001 From: "H. Peter Anvin (Intel)" Date: Wed, 12 Dec 2018 14:38:50 -0800 Subject: 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) --- 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 { -- cgit v1.2.1