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