parser.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2013 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  * parser.c   source line parser for the Netwide Assembler
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <stddef.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45 #include <inttypes.h>
  46
  47 #include "nasm.h"
  48 #include "insns.h"
  49 #include "nasmlib.h"
  50 #include "stdscan.h"
  51 #include "eval.h"
  52 #include "parser.h"
  53 #include "float.h"
  54 #include "tables.h"
  55
  56 extern int in_abs_seg;          /* ABSOLUTE segment flag */
  57 extern int32_t abs_seg;         /* ABSOLUTE segment */
  58 extern int32_t abs_offset;      /* ABSOLUTE segment offset */
  59
  60 static int is_comma_next(void);
  61
  62 static int i;
  63 static struct tokenval tokval;
  64 static struct location *location;       /* Pointer to current line's segment,offset */
  65
  66 void parser_global_info(struct location * locp)
  67 {
  68     location = locp;
  69 }
  70
  71 static int prefix_slot(int prefix)
  72 {
  73     switch (prefix) {
  74     case P_WAIT:
  75         return PPS_WAIT;
  76     case R_CS:
  77     case R_DS:
  78     case R_SS:
  79     case R_ES:
  80     case R_FS:
  81     case R_GS:
  82         return PPS_SEG;
  83     case P_LOCK:
  84         return PPS_LOCK;
  85     case P_REP:
  86     case P_REPE:
  87     case P_REPZ:
  88     case P_REPNE:
  89     case P_REPNZ:
  90     case P_XACQUIRE:
  91     case P_XRELEASE:
  92         return PPS_REP;
  93     case P_O16:
  94     case P_O32:
  95     case P_O64:
  96     case P_OSP:
  97         return PPS_OSIZE;
  98     case P_A16:
  99     case P_A32:
 100     case P_A64:
 101     case P_ASP:
 102         return PPS_ASIZE;
 103     default:
 104         nasm_error(ERR_PANIC, "Invalid value %d passed to prefix_slot()", prefix);
 105         return -1;
 106     }
 107 }
 108
 109 static void process_size_override(insn *result, int operand)
 110 {
 111     if (tasm_compatible_mode) {
 112         switch ((int)tokval.t_integer) {
 113             /* For TASM compatibility a size override inside the
 114              * brackets changes the size of the operand, not the
 115              * address type of the operand as it does in standard
 116              * NASM syntax. Hence:
 117              *
 118              *  mov     eax,[DWORD val]
 119              *
 120              * is valid syntax in TASM compatibility mode. Note that
 121              * you lose the ability to override the default address
 122              * type for the instruction, but we never use anything
 123              * but 32-bit flat model addressing in our code.
 124              */
 125         case S_BYTE:
 126             result->oprs[operand].type |= BITS8;
 127             break;
 128         case S_WORD:
 129             result->oprs[operand].type |= BITS16;
 130             break;
 131         case S_DWORD:
 132         case S_LONG:
 133             result->oprs[operand].type |= BITS32;
 134             break;
 135         case S_QWORD:
 136             result->oprs[operand].type |= BITS64;
 137             break;
 138         case S_TWORD:
 139             result->oprs[operand].type |= BITS80;
 140             break;
 141         case S_OWORD:
 142             result->oprs[operand].type |= BITS128;
 143             break;
 144         default:
 145             nasm_error(ERR_NONFATAL,
 146                        "invalid operand size specification");
 147             break;
 148         }
 149     } else {
 150         /* Standard NASM compatible syntax */
 151         switch ((int)tokval.t_integer) {
 152         case S_NOSPLIT:
 153             result->oprs[operand].eaflags |= EAF_TIMESTWO;
 154             break;
 155         case S_REL:
 156             result->oprs[operand].eaflags |= EAF_REL;
 157             break;
 158         case S_ABS:
 159             result->oprs[operand].eaflags |= EAF_ABS;
 160             break;
 161         case S_BYTE:
 162             result->oprs[operand].disp_size = 8;
 163             result->oprs[operand].eaflags |= EAF_BYTEOFFS;
 164             break;
 165         case P_A16:
 166         case P_A32:
 167         case P_A64:
 168             if (result->prefixes[PPS_ASIZE] &&
 169                 result->prefixes[PPS_ASIZE] != tokval.t_integer)
 170                 nasm_error(ERR_NONFATAL,
 171                            "conflicting address size specifications");
 172             else
 173                 result->prefixes[PPS_ASIZE] = tokval.t_integer;
 174             break;
 175         case S_WORD:
 176             result->oprs[operand].disp_size = 16;
 177             result->oprs[operand].eaflags |= EAF_WORDOFFS;
 178             break;
 179         case S_DWORD:
 180         case S_LONG:
 181             result->oprs[operand].disp_size = 32;
 182             result->oprs[operand].eaflags |= EAF_WORDOFFS;
 183             break;
 184         case S_QWORD:
 185             result->oprs[operand].disp_size = 64;
 186             result->oprs[operand].eaflags |= EAF_WORDOFFS;
 187             break;
 188         default:
 189             nasm_error(ERR_NONFATAL, "invalid size specification in"
 190                        " effective address");
 191             break;
 192         }
 193     }
 194 }
 195
 196 /*
 197  * when two or more decorators follow a register operand,
 198  * consecutive decorators are parsed here.
 199  * opmask and zeroing decorators can be placed in any order.
 200  * e.g. zmm1 {k2}{z} or zmm2 {z,k3}
 201  * decorator(s) are placed at the end of an operand.
 202  */
 203 static bool parse_braces(decoflags_t *decoflags)
 204 {
 205     int i;
 206     bool recover = false;
 207
 208     i = tokval.t_type;
 209     do {
 210         if (i == TOKEN_OPMASK) {
 211             if (*decoflags & OPMASK_MASK) {
 212                 nasm_error(ERR_NONFATAL, "opmask k%lu is already set",
 213                            *decoflags & OPMASK_MASK);
 214                 *decoflags &= ~OPMASK_MASK;
 215             }
 216             *decoflags |= VAL_OPMASK(nasm_regvals[tokval.t_integer]);
 217         } else if (i == TOKEN_DECORATOR) {
 218             switch (tokval.t_integer) {
 219             case BRC_Z:
 220                 /*
 221                  * according to AVX512 spec, only zeroing/merging decorator
 222                  * is supported with opmask
 223                  */
 224                 *decoflags |= GEN_Z(0);
 225                 break;
 226             default:
 227                 nasm_error(ERR_NONFATAL, "{%s} is not an expected decorator",
 228                                          tokval.t_charptr);
 229                 break;
 230             }
 231         } else if (i == ',' || i == TOKEN_EOS){
 232             break;
 233         } else {
 234             nasm_error(ERR_NONFATAL, "only a series of valid decorators"
 235                                      " expected");
 236             recover = true;
 237             break;
 238         }
 239         i = stdscan(NULL, &tokval);
 240     } while(1);
 241
 242     return recover;
 243 }
 244
 245 insn *parse_line(int pass, char *buffer, insn *result, ldfunc ldef)
 246 {
 247     bool insn_is_label = false;
 248     struct eval_hints hints;
 249     int operand;
 250     int critical;
 251     bool first;
 252     bool recover;
 253
 254 restart_parse:
 255     first               = true;
 256     result->forw_ref    = false;
 257
 258     stdscan_reset();
 259     stdscan_set(buffer);
 260     i = stdscan(NULL, &tokval);
 261
 262     result->label       = NULL; /* Assume no label */
 263     result->eops        = NULL; /* must do this, whatever happens */
 264     result->operands    = 0;    /* must initialize this */
 265     result->evex_rm     = 0;    /* Ensure EVEX rounding mode is reset */
 266     result->evex_brerop = -1;   /* Reset EVEX broadcasting/ER op position */
 267
 268     /* Ignore blank lines */
 269     if (i == TOKEN_EOS) {
 270         result->opcode = I_none;
 271         return result;
 272     }
 273
 274     if (i != TOKEN_ID       &&
 275         i != TOKEN_INSN     &&
 276         i != TOKEN_PREFIX   &&
 277         (i != TOKEN_REG || !IS_SREG(tokval.t_integer))) {
 278         nasm_error(ERR_NONFATAL,
 279                    "label or instruction expected at start of line");
 280         result->opcode = I_none;
 281         return result;
 282     }
 283
 284     if (i == TOKEN_ID || (insn_is_label && i == TOKEN_INSN)) {
 285         /* there's a label here */
 286         first = false;
 287         result->label = tokval.t_charptr;
 288         i = stdscan(NULL, &tokval);
 289         if (i == ':') {         /* skip over the optional colon */
 290             i = stdscan(NULL, &tokval);
 291         } else if (i == 0) {
 292             nasm_error(ERR_WARNING | ERR_WARN_OL | ERR_PASS1,
 293                   "label alone on a line without a colon might be in error");
 294         }
 295         if (i != TOKEN_INSN || tokval.t_integer != I_EQU) {
 296             /*
 297              * FIXME: location->segment could be NO_SEG, in which case
 298              * it is possible we should be passing 'abs_seg'. Look into this.
 299              * Work out whether that is *really* what we should be doing.
 300              * Generally fix things. I think this is right as it is, but
 301              * am still not certain.
 302              */
 303             ldef(result->label, in_abs_seg ? abs_seg : location->segment,
 304                  location->offset, NULL, true, false);
 305         }
 306     }
 307
 308     /* Just a label here */
 309     if (i == TOKEN_EOS) {
 310         result->opcode = I_none;
 311         return result;
 312     }
 313
 314     nasm_build_assert(P_none != 0);
 315     memset(result->prefixes, P_none, sizeof(result->prefixes));
 316     result->times = 1L;
 317
 318     while (i == TOKEN_PREFIX ||
 319            (i == TOKEN_REG && IS_SREG(tokval.t_integer))) {
 320         first = false;
 321
 322         /*
 323          * Handle special case: the TIMES prefix.
 324          */
 325         if (i == TOKEN_PREFIX && tokval.t_integer == P_TIMES) {
 326             expr *value;
 327
 328             i = stdscan(NULL, &tokval);
 329             value = evaluate(stdscan, NULL, &tokval, NULL, pass0, nasm_error, NULL);
 330             i = tokval.t_type;
 331             if (!value) {       /* but, error in evaluator */
 332                 result->opcode = I_none;    /* unrecoverable parse error: */
 333                 return result;  /* ignore this instruction */
 334             }
 335             if (!is_simple(value)) {
 336                 nasm_error(ERR_NONFATAL,
 337                       "non-constant argument supplied to TIMES");
 338                 result->times = 1L;
 339             } else {
 340                 result->times = value->value;
 341                 if (value->value < 0 && pass0 == 2) {
 342                     nasm_error(ERR_NONFATAL, "TIMES value %"PRId64" is negative",
 343                           value->value);
 344                     result->times = 0;
 345                 }
 346             }
 347         } else {
 348             int slot = prefix_slot(tokval.t_integer);
 349             if (result->prefixes[slot]) {
 350                if (result->prefixes[slot] == tokval.t_integer)
 351                     nasm_error(ERR_WARNING | ERR_PASS1,
 352                                "instruction has redundant prefixes");
 353                else
 354                     nasm_error(ERR_NONFATAL,
 355                                "instruction has conflicting prefixes");
 356             }
 357             result->prefixes[slot] = tokval.t_integer;
 358             i = stdscan(NULL, &tokval);
 359         }
 360     }
 361
 362     if (i != TOKEN_INSN) {
 363         int j;
 364         enum prefixes pfx;
 365
 366         for (j = 0; j < MAXPREFIX; j++) {
 367             if ((pfx = result->prefixes[j]) != P_none)
 368                 break;
 369         }
 370
 371         if (i == 0 && pfx != P_none) {
 372             /*
 373              * Instruction prefixes are present, but no actual
 374              * instruction. This is allowed: at this point we
 375              * invent a notional instruction of RESB 0.
 376              */
 377             result->opcode          = I_RESB;
 378             result->operands        = 1;
 379             result->oprs[0].type    = IMMEDIATE;
 380             result->oprs[0].offset  = 0L;
 381             result->oprs[0].segment = result->oprs[0].wrt = NO_SEG;
 382             return result;
 383         } else {
 384             nasm_error(ERR_NONFATAL, "parser: instruction expected");
 385             result->opcode = I_none;
 386             return result;
 387         }
 388     }
 389
 390     result->opcode = tokval.t_integer;
 391     result->condition = tokval.t_inttwo;
 392
 393     /*
 394      * INCBIN cannot be satisfied with incorrectly
 395      * evaluated operands, since the correct values _must_ be known
 396      * on the first pass. Hence, even in pass one, we set the
 397      * `critical' flag on calling evaluate(), so that it will bomb
 398      * out on undefined symbols.
 399      */
 400     if (result->opcode == I_INCBIN) {
 401         critical = (pass0 < 2 ? 1 : 2);
 402
 403     } else
 404         critical = (pass == 2 ? 2 : 0);
 405
 406     if (result->opcode == I_DB || result->opcode == I_DW ||
 407         result->opcode == I_DD || result->opcode == I_DQ ||
 408         result->opcode == I_DT || result->opcode == I_DO ||
 409         result->opcode == I_DY || result->opcode == I_DZ ||
 410         result->opcode == I_INCBIN) {
 411         extop *eop, **tail = &result->eops, **fixptr;
 412         int oper_num = 0;
 413         int32_t sign;
 414
 415         result->eops_float = false;
 416
 417         /*
 418          * Begin to read the DB/DW/DD/DQ/DT/DO/DY/DZ/INCBIN operands.
 419          */
 420         while (1) {
 421             i = stdscan(NULL, &tokval);
 422             if (i == TOKEN_EOS)
 423                 break;
 424             else if (first && i == ':') {
 425                 insn_is_label = true;
 426                 goto restart_parse;
 427             }
 428             first = false;
 429             fixptr = tail;
 430             eop = *tail = nasm_malloc(sizeof(extop));
 431             tail = &eop->next;
 432             eop->next = NULL;
 433             eop->type = EOT_NOTHING;
 434             oper_num++;
 435             sign = +1;
 436
 437             /*
 438              * is_comma_next() here is to distinguish this from
 439              * a string used as part of an expression...
 440              */
 441             if (i == TOKEN_STR && is_comma_next()) {
 442                 eop->type       = EOT_DB_STRING;
 443                 eop->stringval  = tokval.t_charptr;
 444                 eop->stringlen  = tokval.t_inttwo;
 445                 i = stdscan(NULL, &tokval);     /* eat the comma */
 446             } else if (i == TOKEN_STRFUNC) {
 447                 bool parens = false;
 448                 const char *funcname = tokval.t_charptr;
 449                 enum strfunc func = tokval.t_integer;
 450                 i = stdscan(NULL, &tokval);
 451                 if (i == '(') {
 452                     parens = true;
 453                     i = stdscan(NULL, &tokval);
 454                 }
 455                 if (i != TOKEN_STR) {
 456                     nasm_error(ERR_NONFATAL,
 457                                "%s must be followed by a string constant",
 458                                funcname);
 459                         eop->type = EOT_NOTHING;
 460                 } else {
 461                     eop->type = EOT_DB_STRING_FREE;
 462                     eop->stringlen =
 463                         string_transform(tokval.t_charptr, tokval.t_inttwo,
 464                                          &eop->stringval, func);
 465                     if (eop->stringlen == (size_t)-1) {
 466                         nasm_error(ERR_NONFATAL, "invalid string for transform");
 467                         eop->type = EOT_NOTHING;
 468                     }
 469                 }
 470                 if (parens && i && i != ')') {
 471                     i = stdscan(NULL, &tokval);
 472                     if (i != ')') {
 473                         nasm_error(ERR_NONFATAL, "unterminated %s function",
 474                                    funcname);
 475                     }
 476                 }
 477                 if (i && i != ',')
 478                     i = stdscan(NULL, &tokval);
 479             } else if (i == '-' || i == '+') {
 480                 char *save = stdscan_get();
 481                 int token = i;
 482                 sign = (i == '-') ? -1 : 1;
 483                 i = stdscan(NULL, &tokval);
 484                 if (i != TOKEN_FLOAT) {
 485                     stdscan_set(save);
 486                     i = tokval.t_type = token;
 487                     goto is_expression;
 488                 } else {
 489                     goto is_float;
 490                 }
 491             } else if (i == TOKEN_FLOAT) {
 492 is_float:
 493                 eop->type = EOT_DB_STRING;
 494                 result->eops_float = true;
 495
 496                 eop->stringlen = idata_bytes(result->opcode);
 497                 if (eop->stringlen > 16) {
 498                     nasm_error(ERR_NONFATAL, "floating-point constant"
 499                                " encountered in DY or DZ instruction");
 500                     eop->stringlen = 0;
 501                 } else if (eop->stringlen < 1) {
 502                     nasm_error(ERR_NONFATAL, "floating-point constant"
 503                                " encountered in unknown instruction");
 504                     /*
 505                      * fix suggested by Pedro Gimeno... original line was:
 506                      * eop->type = EOT_NOTHING;
 507                      */
 508                     eop->stringlen = 0;
 509                 }
 510
 511                 eop = nasm_realloc(eop, sizeof(extop) + eop->stringlen);
 512                 tail = &eop->next;
 513                 *fixptr = eop;
 514                 eop->stringval = (char *)eop + sizeof(extop);
 515                 if (!eop->stringlen ||
 516                     !float_const(tokval.t_charptr, sign,
 517                                  (uint8_t *)eop->stringval,
 518                                  eop->stringlen, nasm_error))
 519                     eop->type = EOT_NOTHING;
 520                 i = stdscan(NULL, &tokval); /* eat the comma */
 521             } else {
 522                 /* anything else, assume it is an expression */
 523                 expr *value;
 524
 525 is_expression:
 526                 value = evaluate(stdscan, NULL, &tokval, NULL,
 527                                  critical, nasm_error, NULL);
 528                 i = tokval.t_type;
 529                 if (!value) {   /* error in evaluator */
 530                     result->opcode = I_none;        /* unrecoverable parse error: */
 531                     return result;      /* ignore this instruction */
 532                 }
 533                 if (is_unknown(value)) {
 534                     eop->type = EOT_DB_NUMBER;
 535                     eop->offset = 0;    /* doesn't matter what we put */
 536                     eop->segment = eop->wrt = NO_SEG;   /* likewise */
 537                 } else if (is_reloc(value)) {
 538                     eop->type = EOT_DB_NUMBER;
 539                     eop->offset = reloc_value(value);
 540                     eop->segment = reloc_seg(value);
 541                     eop->wrt = reloc_wrt(value);
 542                 } else {
 543                     nasm_error(ERR_NONFATAL,
 544                           "operand %d: expression is not simple"
 545                           " or relocatable", oper_num);
 546                 }
 547             }
 548
 549             /*
 550              * We're about to call stdscan(), which will eat the
 551              * comma that we're currently sitting on between
 552              * arguments. However, we'd better check first that it
 553              * _is_ a comma.
 554              */
 555             if (i == TOKEN_EOS) /* also could be EOL */
 556                 break;
 557             if (i != ',') {
 558                 nasm_error(ERR_NONFATAL, "comma expected after operand %d",
 559                            oper_num);
 560                 result->opcode = I_none;/* unrecoverable parse error: */
 561                 return result;          /* ignore this instruction */
 562             }
 563         }
 564
 565         if (result->opcode == I_INCBIN) {
 566             /*
 567              * Correct syntax for INCBIN is that there should be
 568              * one string operand, followed by one or two numeric
 569              * operands.
 570              */
 571             if (!result->eops || result->eops->type != EOT_DB_STRING)
 572                 nasm_error(ERR_NONFATAL, "`incbin' expects a file name");
 573             else if (result->eops->next &&
 574                      result->eops->next->type != EOT_DB_NUMBER)
 575                 nasm_error(ERR_NONFATAL, "`incbin': second parameter is"
 576                            " non-numeric");
 577             else if (result->eops->next && result->eops->next->next &&
 578                      result->eops->next->next->type != EOT_DB_NUMBER)
 579                 nasm_error(ERR_NONFATAL, "`incbin': third parameter is"
 580                            " non-numeric");
 581             else if (result->eops->next && result->eops->next->next &&
 582                      result->eops->next->next->next)
 583                 nasm_error(ERR_NONFATAL,
 584                            "`incbin': more than three parameters");
 585             else
 586                 return result;
 587             /*
 588              * If we reach here, one of the above errors happened.
 589              * Throw the instruction away.
 590              */
 591             result->opcode = I_none;
 592             return result;
 593         } else /* DB ... */ if (oper_num == 0)
 594             nasm_error(ERR_WARNING | ERR_PASS1,
 595                   "no operand for data declaration");
 596         else
 597             result->operands = oper_num;
 598
 599         return result;
 600     }
 601
 602     /*
 603      * Now we begin to parse the operands. There may be up to four
 604      * of these, separated by commas, and terminated by a zero token.
 605      */
 606
 607     for (operand = 0; operand < MAX_OPERANDS; operand++) {
 608         expr *value;            /* used most of the time */
 609         int mref;               /* is this going to be a memory ref? */
 610         int bracket;            /* is it a [] mref, or a & mref? */
 611         int setsize = 0;
 612         decoflags_t brace_flags = 0;    /* flags for decorators in braces */
 613
 614         result->oprs[operand].disp_size = 0;    /* have to zero this whatever */
 615         result->oprs[operand].eaflags   = 0;    /* and this */
 616         result->oprs[operand].opflags   = 0;
 617         result->oprs[operand].decoflags = 0;
 618
 619         i = stdscan(NULL, &tokval);
 620         if (i == TOKEN_EOS)
 621             break;              /* end of operands: get out of here */
 622         else if (first && i == ':') {
 623             insn_is_label = true;
 624             goto restart_parse;
 625         }
 626         first = false;
 627         result->oprs[operand].type = 0; /* so far, no override */
 628         while (i == TOKEN_SPECIAL) {    /* size specifiers */
 629             switch ((int)tokval.t_integer) {
 630             case S_BYTE:
 631                 if (!setsize)   /* we want to use only the first */
 632                     result->oprs[operand].type |= BITS8;
 633                 setsize = 1;
 634                 break;
 635             case S_WORD:
 636                 if (!setsize)
 637                     result->oprs[operand].type |= BITS16;
 638                 setsize = 1;
 639                 break;
 640             case S_DWORD:
 641             case S_LONG:
 642                 if (!setsize)
 643                     result->oprs[operand].type |= BITS32;
 644                 setsize = 1;
 645                 break;
 646             case S_QWORD:
 647                 if (!setsize)
 648                     result->oprs[operand].type |= BITS64;
 649                 setsize = 1;
 650                 break;
 651             case S_TWORD:
 652                 if (!setsize)
 653                     result->oprs[operand].type |= BITS80;
 654                 setsize = 1;
 655                 break;
 656             case S_OWORD:
 657                 if (!setsize)
 658                     result->oprs[operand].type |= BITS128;
 659                 setsize = 1;
 660                 break;
 661             case S_YWORD:
 662                 if (!setsize)
 663                     result->oprs[operand].type |= BITS256;
 664                 setsize = 1;
 665                 break;
 666             case S_ZWORD:
 667                 if (!setsize)
 668                     result->oprs[operand].type |= BITS512;
 669                 setsize = 1;
 670                 break;
 671             case S_TO:
 672                 result->oprs[operand].type |= TO;
 673                 break;
 674             case S_STRICT:
 675                 result->oprs[operand].type |= STRICT;
 676                 break;
 677             case S_FAR:
 678                 result->oprs[operand].type |= FAR;
 679                 break;
 680             case S_NEAR:
 681                 result->oprs[operand].type |= NEAR;
 682                 break;
 683             case S_SHORT:
 684                 result->oprs[operand].type |= SHORT;
 685                 break;
 686             default:
 687                 nasm_error(ERR_NONFATAL, "invalid operand size specification");
 688             }
 689             i = stdscan(NULL, &tokval);
 690         }
 691
 692         if (i == '[' || i == '&') {     /* memory reference */
 693             mref = true;
 694             bracket = (i == '[');
 695             i = stdscan(NULL, &tokval); /* then skip the colon */
 696             while (i == TOKEN_SPECIAL || i == TOKEN_PREFIX) {
 697                 process_size_override(result, operand);
 698                 i = stdscan(NULL, &tokval);
 699             }
 700         } else {                /* immediate operand, or register */
 701             mref = false;
 702             bracket = false;    /* placate optimisers */
 703         }
 704
 705         if ((result->oprs[operand].type & FAR) && !mref &&
 706             result->opcode != I_JMP && result->opcode != I_CALL) {
 707             nasm_error(ERR_NONFATAL, "invalid use of FAR operand specifier");
 708         }
 709
 710         value = evaluate(stdscan, NULL, &tokval,
 711                          &result->oprs[operand].opflags,
 712                          critical, nasm_error, &hints);
 713         i = tokval.t_type;
 714         if (result->oprs[operand].opflags & OPFLAG_FORWARD) {
 715             result->forw_ref = true;
 716         }
 717         if (!value) {           /* nasm_error in evaluator */
 718             result->opcode = I_none;        /* unrecoverable parse error: */
 719             return result;      /* ignore this instruction */
 720         }
 721         if (i == ':' && mref) { /* it was seg:offset */
 722             /*
 723              * Process the segment override.
 724              */
 725             if (value[1].type   != 0    ||
 726                 value->value    != 1    ||
 727                 !IS_SREG(value->type))
 728                 nasm_error(ERR_NONFATAL, "invalid segment override");
 729             else if (result->prefixes[PPS_SEG])
 730                 nasm_error(ERR_NONFATAL,
 731                       "instruction has conflicting segment overrides");
 732             else {
 733                 result->prefixes[PPS_SEG] = value->type;
 734                 if (IS_FSGS(value->type))
 735                     result->oprs[operand].eaflags |= EAF_FSGS;
 736             }
 737
 738             i = stdscan(NULL, &tokval); /* then skip the colon */
 739             while (i == TOKEN_SPECIAL || i == TOKEN_PREFIX) {
 740                 process_size_override(result, operand);
 741                 i = stdscan(NULL, &tokval);
 742             }
 743             value = evaluate(stdscan, NULL, &tokval,
 744                              &result->oprs[operand].opflags,
 745                              critical, nasm_error, &hints);
 746             i = tokval.t_type;
 747             if (result->oprs[operand].opflags & OPFLAG_FORWARD) {
 748                 result->forw_ref = true;
 749             }
 750             /* and get the offset */
 751             if (!value) {       /* but, error in evaluator */
 752                 result->opcode = I_none;    /* unrecoverable parse error: */
 753                 return result;  /* ignore this instruction */
 754             }
 755         }
 756
 757         recover = false;
 758         if (mref && bracket) {  /* find ] at the end */
 759             if (i != ']') {
 760                 nasm_error(ERR_NONFATAL, "parser: expecting ]");
 761                 recover = true;
 762             } else {            /* we got the required ] */
 763                 i = stdscan(NULL, &tokval);
 764                 if ((i == TOKEN_DECORATOR) || (i == TOKEN_OPMASK)) {
 765                     /*
 766                      * according to AVX512 spec, broacast or opmask decorator
 767                      * is expected for memory reference operands
 768                      */
 769                     if (tokval.t_flag & TFLAG_BRDCAST) {
 770                         brace_flags |= GEN_BRDCAST(0);
 771                         i = stdscan(NULL, &tokval);
 772                     } else if (i == TOKEN_OPMASK) {
 773                         brace_flags |= VAL_OPMASK(nasm_regvals[tokval.t_integer]);
 774                         i = stdscan(NULL, &tokval);
 775                     } else {
 776                         nasm_error(ERR_NONFATAL, "broadcast or opmask "
 777                                    "decorator expected inside braces");
 778                         recover = true;
 779                     }
 780                 }
 781
 782                 if (i != 0 && i != ',') {
 783                     nasm_error(ERR_NONFATAL, "comma or end of line expected");
 784                     recover = true;
 785                 }
 786             }
 787         } else {                /* immediate operand */
 788             if (i != 0 && i != ',' && i != ':' &&
 789                 i != TOKEN_DECORATOR && i != TOKEN_OPMASK) {
 790                 nasm_error(ERR_NONFATAL, "comma, colon, decorator or end of "
 791                                          "line expected after operand");
 792                 recover = true;
 793             } else if (i == ':') {
 794                 result->oprs[operand].type |= COLON;
 795             } else if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) {
 796                 /* parse opmask (and zeroing) after an operand */
 797                 recover = parse_braces(&brace_flags);
 798             }
 799         }
 800         if (recover) {
 801             do {                /* error recovery */
 802                 i = stdscan(NULL, &tokval);
 803             } while (i != 0 && i != ',');
 804         }
 805
 806         /*
 807          * now convert the exprs returned from evaluate()
 808          * into operand descriptions...
 809          */
 810
 811         if (mref) {             /* it's a memory reference */
 812             expr *e = value;
 813             int b, i, s;        /* basereg, indexreg, scale */
 814             int64_t o;          /* offset */
 815
 816             b = i = -1, o = s = 0;
 817             result->oprs[operand].hintbase = hints.base;
 818             result->oprs[operand].hinttype = hints.type;
 819
 820             if (e->type && e->type <= EXPR_REG_END) {   /* this bit's a register */
 821                 bool is_gpr = is_class(REG_GPR,nasm_reg_flags[e->type]);
 822
 823                 if (is_gpr && e->value == 1)
 824                     b = e->type;        /* It can be basereg */
 825                 else                    /* No, it has to be indexreg */
 826                     i = e->type, s = e->value;
 827                 e++;
 828             }
 829             if (e->type && e->type <= EXPR_REG_END) {   /* it's a 2nd register */
 830                 bool is_gpr = is_class(REG_GPR,nasm_reg_flags[e->type]);
 831
 832                 if (b != -1)    /* If the first was the base, ... */
 833                     i = e->type, s = e->value;  /* second has to be indexreg */
 834
 835                 else if (!is_gpr || e->value != 1) {
 836                     /* If both want to be index */
 837                     nasm_error(ERR_NONFATAL,
 838                                "invalid effective address: two index registers");
 839                     result->opcode = I_none;
 840                     return result;
 841                 } else
 842                     b = e->type;
 843                 e++;
 844             }
 845             if (e->type != 0) { /* is there an offset? */
 846                 if (e->type <= EXPR_REG_END) {  /* in fact, is there an error? */
 847                     nasm_error(ERR_NONFATAL,
 848                           "beroset-p-603-invalid effective address");
 849                     result->opcode = I_none;
 850                     return result;
 851                 } else {
 852                     if (e->type == EXPR_UNKNOWN) {
 853                         result->oprs[operand].opflags |= OPFLAG_UNKNOWN;
 854                         o = 0;  /* doesn't matter what */
 855                         result->oprs[operand].wrt = NO_SEG;     /* nor this */
 856                         result->oprs[operand].segment = NO_SEG; /* or this */
 857                         while (e->type)
 858                             e++;        /* go to the end of the line */
 859                     } else {
 860                         if (e->type == EXPR_SIMPLE) {
 861                             o = e->value;
 862                             e++;
 863                         }
 864                         if (e->type == EXPR_WRT) {
 865                             result->oprs[operand].wrt = e->value;
 866                             e++;
 867                         } else
 868                             result->oprs[operand].wrt = NO_SEG;
 869                         /*
 870                          * Look for a segment base type.
 871                          */
 872                         if (e->type && e->type < EXPR_SEGBASE) {
 873                             nasm_error(ERR_NONFATAL,
 874                                   "beroset-p-630-invalid effective address");
 875                             result->opcode = I_none;
 876                             return result;
 877                         }
 878                         while (e->type && e->value == 0)
 879                             e++;
 880                         if (e->type && e->value != 1) {
 881                             nasm_error(ERR_NONFATAL,
 882                                   "beroset-p-637-invalid effective address");
 883                             result->opcode = I_none;
 884                             return result;
 885                         }
 886                         if (e->type) {
 887                             result->oprs[operand].segment =
 888                                 e->type - EXPR_SEGBASE;
 889                             e++;
 890                         } else
 891                             result->oprs[operand].segment = NO_SEG;
 892                         while (e->type && e->value == 0)
 893                             e++;
 894                         if (e->type) {
 895                             nasm_error(ERR_NONFATAL,
 896                                   "beroset-p-650-invalid effective address");
 897                             result->opcode = I_none;
 898                             return result;
 899                         }
 900                     }
 901                 }
 902             } else {
 903                 o = 0;
 904                 result->oprs[operand].wrt = NO_SEG;
 905                 result->oprs[operand].segment = NO_SEG;
 906             }
 907
 908             if (e->type != 0) { /* there'd better be nothing left! */
 909                 nasm_error(ERR_NONFATAL,
 910                       "beroset-p-663-invalid effective address");
 911                 result->opcode = I_none;
 912                 return result;
 913             }
 914
 915             /* It is memory, but it can match any r/m operand */
 916             result->oprs[operand].type |= MEMORY_ANY;
 917
 918             if (b == -1 && (i == -1 || s == 0)) {
 919                 int is_rel = globalbits == 64 &&
 920                     !(result->oprs[operand].eaflags & EAF_ABS) &&
 921                     ((globalrel &&
 922                       !(result->oprs[operand].eaflags & EAF_FSGS)) ||
 923                      (result->oprs[operand].eaflags & EAF_REL));
 924
 925                 result->oprs[operand].type |= is_rel ? IP_REL : MEM_OFFS;
 926             }
 927
 928             if (i != -1) {
 929                 opflags_t iclass = nasm_reg_flags[i];
 930
 931                 if (is_class(XMMREG,iclass))
 932                     result->oprs[operand].type |= XMEM;
 933                 else if (is_class(YMMREG,iclass))
 934                     result->oprs[operand].type |= YMEM;
 935                 else if (is_class(ZMMREG,iclass))
 936                     result->oprs[operand].type |= ZMEM;
 937             }
 938
 939             result->oprs[operand].basereg = b;
 940             result->oprs[operand].indexreg = i;
 941             result->oprs[operand].scale = s;
 942             result->oprs[operand].offset = o;
 943             result->oprs[operand].decoflags |= brace_flags;
 944         } else {                /* it's not a memory reference */
 945             if (is_just_unknown(value)) {       /* it's immediate but unknown */
 946                 result->oprs[operand].type      |= IMMEDIATE;
 947                 result->oprs[operand].opflags   |= OPFLAG_UNKNOWN;
 948                 result->oprs[operand].offset    = 0;        /* don't care */
 949                 result->oprs[operand].segment   = NO_SEG;   /* don't care again */
 950                 result->oprs[operand].wrt       = NO_SEG;   /* still don't care */
 951
 952                 if(optimizing >= 0 && !(result->oprs[operand].type & STRICT)) {
 953                     /* Be optimistic */
 954                     result->oprs[operand].type |=
 955                         UNITY | SBYTEWORD | SBYTEDWORD | UDWORD | SDWORD;
 956                 }
 957             } else if (is_reloc(value)) {       /* it's immediate */
 958                 result->oprs[operand].type      |= IMMEDIATE;
 959                 result->oprs[operand].offset    = reloc_value(value);
 960                 result->oprs[operand].segment   = reloc_seg(value);
 961                 result->oprs[operand].wrt       = reloc_wrt(value);
 962
 963                 if (is_simple(value)) {
 964                     uint64_t n = reloc_value(value);
 965                     if (n == 1)
 966                         result->oprs[operand].type |= UNITY;
 967                     if (optimizing >= 0 &&
 968                         !(result->oprs[operand].type & STRICT)) {
 969                         if ((uint32_t) (n + 128) <= 255)
 970                             result->oprs[operand].type |= SBYTEDWORD;
 971                         if ((uint16_t) (n + 128) <= 255)
 972                             result->oprs[operand].type |= SBYTEWORD;
 973                         if (n <= 0xFFFFFFFF)
 974                             result->oprs[operand].type |= UDWORD;
 975                         if (n + 0x80000000 <= 0xFFFFFFFF)
 976                             result->oprs[operand].type |= SDWORD;
 977                     }
 978                 }
 979             } else if(value->type == EXPR_RDSAE) {
 980                 /*
 981                  * it's not an operand but a rounding or SAE decorator.
 982                  * put the decorator information in the (opflag_t) type field
 983                  * of previous operand.
 984                  */
 985                 operand --;
 986                 switch (value->value) {
 987                 case BRC_RN:
 988                 case BRC_RU:
 989                 case BRC_RD:
 990                 case BRC_RZ:
 991                 case BRC_SAE:
 992                     result->oprs[operand].decoflags  |=
 993                                         (value->value == BRC_SAE ? SAE : ER);
 994                     result->evex_rm = value->value;
 995                     break;
 996                 default:
 997                     nasm_error(ERR_NONFATAL, "invalid decorator");
 998                     break;
 999                 }
1000             } else {            /* it's a register */
1001                 opflags_t rs;
1002
1003                 if (value->type >= EXPR_SIMPLE || value->value != 1) {
1004                     nasm_error(ERR_NONFATAL, "invalid operand type");
1005                     result->opcode = I_none;
1006                     return result;
1007                 }
1008
1009                 /*
1010                  * check that its only 1 register, not an expression...
1011                  */
1012                 for (i = 1; value[i].type; i++)
1013                     if (value[i].value) {
1014                         nasm_error(ERR_NONFATAL, "invalid operand type");
1015                         result->opcode = I_none;
1016                         return result;
1017                     }
1018
1019                 /* clear overrides, except TO which applies to FPU regs */
1020                 if (result->oprs[operand].type & ~TO) {
1021                     /*
1022                      * we want to produce a warning iff the specified size
1023                      * is different from the register size
1024                      */
1025                     rs = result->oprs[operand].type & SIZE_MASK;
1026                 } else
1027                     rs = 0;
1028
1029                 result->oprs[operand].type      &= TO;
1030                 result->oprs[operand].type      |= REGISTER;
1031                 result->oprs[operand].type      |= nasm_reg_flags[value->type];
1032                 result->oprs[operand].decoflags |= brace_flags;
1033                 result->oprs[operand].basereg   = value->type;
1034
1035                 if (rs && (result->oprs[operand].type & SIZE_MASK) != rs)
1036                     nasm_error(ERR_WARNING | ERR_PASS1,
1037                           "register size specification ignored");
1038             }
1039         }
1040
1041         /* remember the position of operand having broadcasting/ER mode */
1042         if (result->oprs[operand].decoflags & (BRDCAST_MASK | ER | SAE))
1043             result->evex_brerop = operand;
1044     }
1045
1046     result->operands = operand; /* set operand count */
1047
1048     /* clear remaining operands */
1049     while (operand < MAX_OPERANDS)
1050         result->oprs[operand++].type = 0;
1051
1052     /*
1053      * Transform RESW, RESD, RESQ, REST, RESO, RESY, RESZ into RESB.
1054      */
1055     switch (result->opcode) {
1056     case I_RESW:
1057         result->opcode = I_RESB;
1058         result->oprs[0].offset *= 2;
1059         break;
1060     case I_RESD:
1061         result->opcode = I_RESB;
1062         result->oprs[0].offset *= 4;
1063         break;
1064     case I_RESQ:
1065         result->opcode = I_RESB;
1066         result->oprs[0].offset *= 8;
1067         break;
1068     case I_REST:
1069         result->opcode = I_RESB;
1070         result->oprs[0].offset *= 10;
1071         break;
1072     case I_RESO:
1073         result->opcode = I_RESB;
1074         result->oprs[0].offset *= 16;
1075         break;
1076     case I_RESY:
1077         result->opcode = I_RESB;
1078         result->oprs[0].offset *= 32;
1079         break;
1080     case I_RESZ:
1081         result->opcode = I_RESB;
1082         result->oprs[0].offset *= 64;
1083         break;
1084     default:
1085         break;
1086     }
1087
1088     return result;
1089 }
1090
1091 static int is_comma_next(void)
1092 {
1093     struct tokenval tv;
1094     char *p;
1095     int i;
1096
1097     p = stdscan_get();
1098     i = stdscan(NULL, &tv);
1099     stdscan_set(p);
1100
1101     return (i == ',' || i == ';' || !i);
1102 }
1103
1104 void cleanup_insn(insn * i)
1105 {
1106     extop *e;
1107
1108     while ((e = i->eops)) {
1109         i->eops = e->next;
1110         if (e->type == EOT_DB_STRING_FREE)
1111             nasm_free(e->stringval);
1112         nasm_free(e);
1113     }
1114 }