parser.c

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