static unsigned int force_strict = 0;
static int generate_make_dependencies = 0;
static int warning_error = 0; /* warnings being treated as errors */
+static FILE *errfile;
+/*@null@*/ /*@only@*/ static char *error_filename = NULL;
static enum {
EWSTYLE_GNU = 0,
EWSTYLE_VC
static int opt_machine_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_strict_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_warning_handler(char *cmd, /*@null@*/ char *param, int extra);
+static int opt_error_file(char *cmd, /*@null@*/ char *param, int extra);
+static int opt_error_stdout(char *cmd, /*@null@*/ char *param, int extra);
static int preproc_only_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_include_option(char *cmd, /*@null@*/ char *param, int extra);
static int opt_preproc_option(char *cmd, /*@null@*/ char *param, int extra);
N_("enables/disables warning"), NULL },
{ 'M', NULL, 0, opt_makedep_handler, 0,
N_("generate Makefile dependencies on stdout"), NULL },
+ { 'E', NULL, 1, opt_error_file, 0,
+ N_("redirect error messages to file"), N_("file") },
+ { 's', NULL, 0, opt_error_stdout, 0,
+ N_("redirect error messages to stdout"), NULL },
{ 'e', "preproc-only", 0, preproc_only_handler, 0,
N_("preprocess only (writes output to stdout by default)"), NULL },
{ 'i', NULL, 1, opt_include_option, 0,
/*@null@*/ FILE *in = NULL;
size_t i;
+ errfile = stderr;
+
#if defined(HAVE_SETLOCALE) && defined(HAVE_LC_MESSAGES)
setlocale(LC_MESSAGES, "");
#endif
return EXIT_SUCCESS;
}
+ /* Open error file if specified. */
+ if (error_filename) {
+ errfile = open_file(error_filename, "wt");
+ if (!errfile)
+ return EXIT_FAILURE;
+ }
+
/* Initialize BitVector (needed for intnum/floatnum). */
if (BitVector_Boot() != ErrCode_Ok) {
print_error(_("%s: could not initialize BitVector"), _("FATAL"));
if (objfmt_keyword)
yasm_xfree(objfmt_keyword);
}
+
+ if (errfile != stderr && errfile != stdout)
+ fclose(errfile);
}
/*
action(YASM_WARN_ORPHAN_LABEL);
else if (strcmp(cmd, "uninit-contents") == 0)
action(YASM_WARN_UNINIT_CONTENTS);
+ else if (strcmp(cmd, "size-override") == 0)
+ action(YASM_WARN_SIZE_OVERRIDE);
else
return 1;
return 0;
}
+static int
+opt_error_file(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra)
+{
+ if (error_filename) {
+ print_error(
+ _("warning: can output to only one error file, last specified used"));
+ yasm_xfree(error_filename);
+ }
+
+ assert(param != NULL);
+ error_filename = yasm__xstrdup(param);
+
+ return 0;
+}
+
+static int
+opt_error_stdout(/*@unused@*/ char *cmd, /*@unused@*/ char *param,
+ /*@unused@*/ int extra)
+{
+ /* Clear any specified error filename */
+ if (error_filename) {
+ yasm_xfree(error_filename);
+ error_filename = NULL;
+ }
+ errfile = stdout;
+ return 0;
+}
+
static int
preproc_only_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param,
/*@unused@*/ int extra)
print_error(const char *fmt, ...)
{
va_list va;
- fprintf(stderr, "yasm: ");
+ fprintf(errfile, "yasm: ");
va_start(va, fmt);
- vfprintf(stderr, fmt, va);
+ vfprintf(errfile, fmt, va);
va_end(va);
- fputc('\n', stderr);
+ fputc('\n', errfile);
}
static /*@exits@*/ void
static /*@exits@*/ void
handle_yasm_fatal(const char *fmt, va_list va)
{
- fprintf(stderr, "yasm: %s: ", _("FATAL"));
- vfprintf(stderr, gettext(fmt), va);
- fputc('\n', stderr);
+ fprintf(errfile, "yasm: %s: ", _("FATAL"));
+ vfprintf(errfile, gettext(fmt), va);
+ fputc('\n', errfile);
exit(EXIT_FAILURE);
}
const char *xref_msg)
{
if (line)
- fprintf(stderr, fmt[ewmsg_style], filename, line, "", msg);
+ fprintf(errfile, fmt[ewmsg_style], filename, line, "", msg);
else
- fprintf(stderr, fmt_noline[ewmsg_style], filename, "", msg);
+ fprintf(errfile, fmt_noline[ewmsg_style], filename, "", msg);
if (xref_fn && xref_msg) {
if (xref_line)
- fprintf(stderr, fmt[ewmsg_style], xref_fn, xref_line, "", xref_msg);
+ fprintf(errfile, fmt[ewmsg_style], xref_fn, xref_line, "",
+ xref_msg);
else
- fprintf(stderr, fmt_noline[ewmsg_style], xref_fn, "", xref_msg);
+ fprintf(errfile, fmt_noline[ewmsg_style], xref_fn, "", xref_msg);
}
}
print_yasm_warning(const char *filename, unsigned long line, const char *msg)
{
if (line)
- fprintf(stderr, fmt[ewmsg_style], filename, line, _("warning: "), msg);
+ fprintf(errfile, fmt[ewmsg_style], filename, line, _("warning: "),
+ msg);
else
- fprintf(stderr, fmt_noline[ewmsg_style], filename, _("warning: "), msg);
+ fprintf(errfile, fmt_noline[ewmsg_style], filename, _("warning: "),
+ msg);
}
uintptr_t targetmod; /**< Arch target modifier, 0 if none. */
- /** Specified size of the operand, in bytes. 0 if not user-specified. */
+ /** Specified size of the operand, in bits. 0 if not user-specified. */
unsigned int size:8;
/** Nonzero if dereference. Used for "*foo" in GAS.
YASM_WARN_UNREC_CHAR, /**< Unrecognized characters (while tokenizing) */
YASM_WARN_PREPROC, /**< Preprocessor warnings */
YASM_WARN_ORPHAN_LABEL, /**< Label alone on a line without a colon */
- YASM_WARN_UNINIT_CONTENTS /**< Uninitialized space in code/data section */
+ YASM_WARN_UNINIT_CONTENTS, /**< Uninitialized space in code/data section */
+ YASM_WARN_SIZE_OVERRIDE /**< Double size override */
} yasm_warn_class;
/** Error classes. Bitmask-based to support limited subclassing. */
typedef struct HAMTNode {
unsigned long BitMapKey; /* 32 bits, bitmap or hash key */
- void *BaseValue; /* Base of HAMTNode list or value */
+ uintptr_t BaseValue; /* Base of HAMTNode list or value */
} HAMTNode;
struct HAMT {
* 4 or 2-byte aligned (as it uses the LSB of the pointer variable to store
* the subtrie flag!
*/
-#define IsSubTrie(n) ((uintptr_t)((n)->BaseValue) & 1)
+#define IsSubTrie(n) ((n)->BaseValue & 1)
#define SetSubTrie(h, n, v) do { \
- if ((uintptr_t)(v) & 1) \
+ if ((uintptr_t)(v) & 1) \
h->error_func(__FILE__, __LINE__, \
N_("Subtrie is seen as subtrie before flag is set (misaligned?)")); \
- (n)->BaseValue = (void *)((uintptr_t)(v) | 1); \
+ (n)->BaseValue = (uintptr_t)(v) | 1; \
} while (0)
-#define GetSubTrie(n) (HAMTNode *)((uintptr_t)((n)->BaseValue)&~1UL)
+#define SetValue(h, n, v) do { \
+ if ((uintptr_t)(v) & 1) \
+ h->error_func(__FILE__, __LINE__, \
+ N_("Value is seen as subtrie (misaligned?)")); \
+ (n)->BaseValue = (uintptr_t)(v); \
+ } while (0)
+#define GetSubTrie(n) (HAMTNode *)(((n)->BaseValue | 1) ^ 1)
static unsigned long
HashKey(const char *key)
for (i=0; i<32; i++) {
hamt->root[i].BitMapKey = 0;
- hamt->root[i].BaseValue = NULL;
+ hamt->root[i].BaseValue = 0;
}
hamt->error_func = error_func;
entry->str = str;
entry->data = data;
STAILQ_INSERT_TAIL(&hamt->entries, entry, next);
- node->BaseValue = entry;
+ SetValue(hamt, node, entry);
if (IsSubTrie(node))
hamt->error_func(__FILE__, __LINE__,
N_("Data is seen as subtrie (misaligned?)"));
if (keypart2 < keypart) {
newnodes[0] = *node; /* structure copy */
newnodes[1].BitMapKey = key;
- newnodes[1].BaseValue = entry;
+ SetValue(hamt, &newnodes[1], entry);
} else {
newnodes[0].BitMapKey = key;
- newnodes[0].BaseValue = entry;
+ SetValue(hamt, &newnodes[0], entry);
newnodes[1] = *node; /* structure copy */
}
entry->str = str;
entry->data = data;
STAILQ_INSERT_TAIL(&hamt->entries, entry, next);
- newnodes[Map].BaseValue = entry;
+ SetValue(hamt, &newnodes[Map], entry);
SetSubTrie(hamt, node, newnodes);
*replace = 1;
{
yasm_symrec *sym = d;
yasm_xfree(sym->name);
- if (sym->type == SYM_EQU)
+ if (sym->type == SYM_EQU && (sym->status & YASM_SYM_VALUED))
yasm_expr_destroy(sym->value.expn);
yasm__assoc_data_destroy(sym->assoc_data);
yasm_xfree(sym);
unsigned long line)
{
yasm_symrec *rec = symtab_define(symtab, name, SYM_EQU, 1, line);
+ if (yasm_error_occurred())
+ return rec;
rec->value.expn = e;
rec->status |= YASM_SYM_VALUED;
return rec;
yasm_bytecode *precbc, int in_table,
unsigned long line)
{
- yasm_symrec *rec;
- rec = symtab_define(symtab, name, SYM_LABEL, in_table, line);
+ yasm_symrec *rec = symtab_define(symtab, name, SYM_LABEL, in_table, line);
+ if (yasm_error_occurred())
+ return rec;
rec->value.precbc = precbc;
if (in_table && precbc)
yasm_bc__add_symrec(precbc, rec);
yasm_symtab_define_curpos(yasm_symtab *symtab, const char *name,
yasm_bytecode *precbc, unsigned long line)
{
- yasm_symrec *rec;
- rec = symtab_define(symtab, name, SYM_CURPOS, 0, line);
+ yasm_symrec *rec = symtab_define(symtab, name, SYM_CURPOS, 0, line);
+ if (yasm_error_occurred())
+ return rec;
rec->value.precbc = precbc;
return rec;
}
yasm_sym_vis vis)
{
yasm_symrec *rec = symtab_define(symtab, name, SYM_SPECIAL, 1, 0);
+ if (yasm_error_occurred())
+ return rec;
rec->status |= YASM_SYM_VALUED;
rec->visibility = vis;
return rec;
YASM_EXPR_ADD,
yasm_expr_copy(yasm_section_get_start(sect)),
sym->line);
+ sym->status |= YASM_SYM_VALUED;
}
return 0;
const yasm_expr *
yasm_symrec_get_equ(const yasm_symrec *sym)
{
- if (sym->type == SYM_EQU)
+ if (sym->type == SYM_EQU && (sym->status & YASM_SYM_VALUED))
return sym->value.expn;
return (const yasm_expr *)NULL;
}
case SYM_EQU:
fprintf(f, "%*s_EQU_\n", indent_level, "");
fprintf(f, "%*sExpn=", indent_level, "");
- yasm_expr_print(sym->value.expn, f);
+ if (sym->status & YASM_SYM_VALUED)
+ yasm_expr_print(sym->value.expn, f);
+ else
+ fprintf(f, "***UNVALUED***");
fprintf(f, "\n");
break;
case SYM_LABEL:
00
00
26
-66
67
+66
f7
3d
05
0f
be
01
-66
67
+66
0f
b7
18
-66
67
+66
0f
b6
0b
f2
ad
-f2
66
+f2
ad
f3
aa
66
26
a5
-f3
66
-a5
f3
+a5
66
+f3
64
a5
-f3
66
+f3
64
a5
a5
00
66
a5
-f3
66
+f3
a5
a5
f3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
7f
02
c3
-66
67
+66
8b
54
24
04
-66
67
+66
8b
44
24
x86_common_tobytes(const x86_common *common, unsigned char **bufp,
unsigned int segreg)
{
- if (common->lockrep_pre != 0)
- YASM_WRITE_8(*bufp, common->lockrep_pre);
if (segreg != 0)
YASM_WRITE_8(*bufp, (unsigned char)segreg);
+ if (common->addrsize != 0 && common->addrsize != common->mode_bits)
+ YASM_WRITE_8(*bufp, 0x67);
if (common->opersize != 0 &&
((common->mode_bits != 64 && common->opersize != common->mode_bits) ||
(common->mode_bits == 64 && common->opersize == 16)))
YASM_WRITE_8(*bufp, 0x66);
- if (common->addrsize != 0 && common->addrsize != common->mode_bits)
- YASM_WRITE_8(*bufp, 0x67);
+ if (common->lockrep_pre != 0)
+ YASM_WRITE_8(*bufp, common->lockrep_pre);
}
static void
/* Pull new type from val */
vp = yasm_vps_next(vp);
- if (vp->val) {
+ if (vp && vp->val) {
if (yasm__strcasecmp(vp->val, "function") == 0)
elf_sym_set_type(entry, STT_FUNC);
else if (yasm__strcasecmp(vp->val, "object") == 0)
/* Pull new size from either param (expr) or val */
vp = yasm_vps_next(vp);
- if (vp->param) {
+ if (vp && vp->param) {
elf_sym_set_size(entry, vp->param);
vp->param = NULL;
- } else if (vp->val)
+ } else if (vp && vp->val)
elf_sym_set_size(entry, yasm_expr_create_ident(yasm_expr_sym(
yasm_symtab_use(objfmt_elf->symtab, vp->val, line)), line));
else
localbuf = info->buf;
- fwrite(msd->sectname, 16, 1, info->f);
- fwrite(msd->segname, 16, 1, info->f);
+ memset(localbuf, 0, 16);
+ strncpy((char *)localbuf, msd->sectname, 16);
+ localbuf += 16;
+ memset(localbuf, 0, 16);
+ strncpy((char *)localbuf, msd->segname, 16);
+ localbuf += 16;
/* section address, size depend on 32/64 bit mode */
YASM_WRITE_32_L(localbuf, msd->vmoff); /* address in memory */
if (info->is_64)
YASM_WRITE_32_L(localbuf, 0); /* reserved 2 */
if (info->is_64)
- fwrite(info->buf, MACHO_SECTCMD64_SIZE - 32, 1, info->f); /* 2*16 byte strings already written */
+ fwrite(info->buf, MACHO_SECTCMD64_SIZE, 1, info->f);
else
- fwrite(info->buf, MACHO_SECTCMD_SIZE - 32, 1, info->f); /* 2*16 byte strings already written */
+ fwrite(info->buf, MACHO_SECTCMD_SIZE, 1, info->f);
return 0;
}
78
74
00
-2e
-63
-6f
-6e
-73
-74
00
-5f
-5f
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
54
58
54
00
-5f
-5f
-74
-65
-78
-74
00
-2e
-63
+00
+00
+00
+00
+00
+00
+00
+00
00
00
00
74
61
00
-2e
-73
-74
-61
-74
-69
-63
-5f
-64
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
41
00
00
73
73
00
-2e
-6f
-62
-6a
-63
-5f
-63
-6c
-61
-73
+00
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
81
00
00
78
74
00
-2e
-63
-6f
-6e
-73
-74
00
-5f
-5f
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
54
58
54
00
-5f
-5f
-74
-65
-78
-74
00
-2e
-63
+00
+00
+00
+00
+00
+00
+00
+00
00
00
00
74
61
00
-2e
-73
-74
-61
-74
-69
-63
-5f
-64
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
5d
00
00
78
74
00
-2e
-63
-6f
-6e
-73
-74
00
-5f
-5f
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
54
58
54
00
-5f
-5f
-74
-65
-78
-74
00
-2e
-63
+00
+00
+00
+00
+00
+00
+00
+00
00
00
00
74
61
00
-2e
-73
-74
-61
-74
-69
-63
-5f
-64
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
28
00
00
78
74
00
-2e
-63
-6f
-6e
-73
-74
00
-5f
-5f
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
54
58
54
00
-5f
-5f
-74
-65
-78
-74
00
-2e
-63
+00
+00
+00
+00
+00
+00
+00
+00
00
00
00
74
61
00
-2e
-73
-74
-61
-74
-69
-63
-5f
-64
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
47
00
00
73
73
00
-2e
-6f
-62
-6a
-63
-5f
-63
-6c
-61
-73
+00
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
87
00
00
78
74
00
-2e
-63
-6f
-6e
-73
-74
00
-5f
-5f
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
54
58
54
00
-5f
-5f
-74
-65
-78
-74
00
-2e
-63
+00
+00
+00
+00
+00
+00
+00
+00
00
00
00
74
61
00
-2e
-73
-74
-61
-74
-69
-63
-5f
-64
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
7a
00
00
73
73
00
-2e
-6f
-62
-6a
-63
-5f
-63
-6c
-61
-73
+00
+00
+00
+00
+00
+00
+00
+00
+00
+00
5f
5f
44
54
41
00
-5f
-5f
-6d
-6f
-64
-5f
-69
-6e
-69
+00
+00
+00
+00
+00
+00
+00
+00
+00
c6
00
00
if (curtok == '(') {
int havereg = 0;
- uintptr_t reg;
+ uintptr_t reg = 0;
yasm_intnum *scale = NULL;
get_next_token(); /* '(' */
static void
strbuf_append(size_t count, YYCTYPE *cursor, yasm_scanner *s, int ch)
{
- if (cursor == s->eof)
- yasm_error_set(YASM_ERROR_SYNTAX,
- N_("unexpected end of file in string"));
-
if (count >= strbuf_size) {
strbuf = yasm_xrealloc(strbuf, strbuf_size + STRBUF_ALLOC_SIZE);
strbuf_size += STRBUF_ALLOC_SIZE;
/*!re2c
/* Handle escaped double-quote by copying and continuing */
"\\\"" {
+ if (cursor == s->eof) {
+ yasm_error_set(YASM_ERROR_SYNTAX,
+ N_("unexpected end of file in string"));
+ lvalp->str.contents = (char *)strbuf;
+ lvalp->str.len = count;
+ RETURN(STRING);
+ }
strbuf_append(count++, cursor, s, '"');
goto stringconst_scan;
}
}
any {
+ if (cursor == s->eof) {
+ yasm_error_set(YASM_ERROR_SYNTAX,
+ N_("unexpected end of file in string"));
+ lvalp->str.contents = (char *)strbuf;
+ lvalp->str.len = count;
+ RETURN(STRING);
+ }
strbuf_append(count++, cursor, s, s->tok[0]);
goto stringconst_scan;
}
yasm_arch_get_reg_size(parser_nasm->arch, op->data.reg) != size)
yasm_error_set(YASM_ERROR_TYPE,
N_("cannot override register size"));
- else
+ else {
+ /* Silently override others unless a warning is turned on.
+ * This is to allow overrides such as:
+ * %define arg1 dword [bp+4]
+ * cmp word arg1, 2
+ * Which expands to:
+ * cmp word dword [bp+4], 2
+ */
+ if (op->size != 0) {
+ if (op->size != size)
+ yasm_warn_set(YASM_WARN_SIZE_OVERRIDE,
+ N_("overriding operand size from %u-bit to %u-bit"),
+ op->size, size);
+ else
+ yasm_warn_set(YASM_WARN_SIZE_OVERRIDE,
+ N_("double operand size override"));
+ }
op->size = size;
+ }
return op;
}
case TARGETMOD: