parser.c

   1 /* parser.c   source line parser for the Netwide Assembler
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  *
   8  * initial version 27/iii/95 by Simon Tatham
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <stddef.h>
  14 #include <string.h>
  15 #include <ctype.h>
  16
  17 #include "nasm.h"
  18 #include "nasmlib.h"
  19 #include "parser.h"
  20 #include "float.h"
  21
  22 static long reg_flags[] = {            /* sizes and special flags */
  23     0, REG8, REG_AL, REG_AX, REG8, REG8, REG16, REG16, REG8, REG_CL,
  24     REG_CREG, REG_CREG, REG_CREG, REG_CR4, REG_CS, REG_CX, REG8,
  25     REG16, REG8, REG_DREG, REG_DREG, REG_DREG, REG_DREG, REG_DREG,
  26     REG_DREG, REG_DESS, REG_DX, REG_EAX, REG32, REG32, REG_ECX,
  27     REG32, REG32, REG_DESS, REG32, REG32, REG_FSGS, REG_FSGS,
  28     MMXREG, MMXREG, MMXREG, MMXREG, MMXREG, MMXREG, MMXREG, MMXREG,
  29     REG16, REG16, REG_DESS, FPU0, FPUREG, FPUREG, FPUREG, FPUREG,
  30     FPUREG, FPUREG, FPUREG, REG_TREG, REG_TREG, REG_TREG, REG_TREG,
  31     REG_TREG
  32 };
  33
  34 enum {                                 /* special tokens */
  35     S_BYTE, S_DWORD, S_FAR, S_LONG, S_NEAR, S_NOSPLIT, S_QWORD,
  36     S_SHORT, S_TO, S_TWORD, S_WORD
  37 };
  38
  39 static int is_comma_next (void);
  40
  41 static int i;
  42 static struct tokenval tokval;
  43 static efunc error;
  44
  45 insn *parse_line (int pass, char *buffer, insn *result,
  46                   efunc errfunc, evalfunc evaluate, evalinfofunc einfo) {
  47     int operand;
  48     int critical;
  49     struct eval_hints hints;
  50
  51     result->forw_ref = FALSE;
  52     error = errfunc;
  53     einfo ("", 0L, 0L);
  54
  55     stdscan_reset();
  56     stdscan_bufptr = buffer;
  57     i = stdscan(NULL, &tokval);
  58
  59     result->eops = NULL;               /* must do this, whatever happens */
  60     result->operands = 0;              /* must initialise this */
  61
  62     if (i==0) {                        /* blank line - ignore */
  63         result->label = NULL;          /* so, no label on it */
  64         result->opcode = -1;           /* and no instruction either */
  65         return result;
  66     }
  67     if (i != TOKEN_ID && i != TOKEN_INSN && i != TOKEN_PREFIX &&
  68         (i!=TOKEN_REG || (REG_SREG & ~reg_flags[tokval.t_integer]))) {
  69         error (ERR_NONFATAL, "label or instruction expected"
  70                " at start of line");
  71         result->label = NULL;
  72         result->opcode = -1;
  73         return result;
  74     }
  75
  76     if (i == TOKEN_ID) {               /* there's a label here */
  77         result->label = tokval.t_charptr;
  78         einfo (result->label, 0L, 0L);
  79         i = stdscan(NULL, &tokval);
  80         if (i == ':') {                /* skip over the optional colon */
  81             i = stdscan(NULL, &tokval);
  82         } else if (i == 0 && pass == 1) {
  83             error (ERR_WARNING|ERR_WARN_OL,
  84                    "label alone on a line without a colon might be in error");
  85         }
  86     } else                             /* no label; so, moving swiftly on */
  87         result->label = NULL;
  88
  89     if (i==0) {
  90         result->opcode = -1;           /* this line contains just a label */
  91         return result;
  92     }
  93
  94     result->nprefix = 0;
  95     result->times = 1L;
  96
  97     while (i == TOKEN_PREFIX ||
  98            (i==TOKEN_REG && !(REG_SREG & ~reg_flags[tokval.t_integer]))) {
  99         /*
 100          * Handle special case: the TIMES prefix.
 101          */
 102         if (i == TOKEN_PREFIX && tokval.t_integer == P_TIMES) {
 103             expr *value;
 104
 105             i = stdscan(NULL, &tokval);
 106             value = evaluate (stdscan, NULL, &tokval, NULL, pass, error, NULL);
 107             i = tokval.t_type;
 108             if (!value) {              /* but, error in evaluator */
 109                 result->opcode = -1;   /* unrecoverable parse error: */
 110                 return result;         /* ignore this instruction */
 111             }
 112             if (!is_simple (value)) {
 113                 error (ERR_NONFATAL,
 114                        "non-constant argument supplied to TIMES");
 115                 result->times = 1L;
 116             } else {
 117                 result->times = value->value;
 118                 if (value->value < 0)
 119                     error(ERR_NONFATAL, "TIMES value %d is negative",
 120                           value->value);
 121             }
 122         } else {
 123             if (result->nprefix == MAXPREFIX)
 124                 error (ERR_NONFATAL,
 125                        "instruction has more than %d prefixes", MAXPREFIX);
 126             else
 127                 result->prefixes[result->nprefix++] = tokval.t_integer;
 128             i = stdscan(NULL, &tokval);
 129         }
 130     }
 131
 132     if (i != TOKEN_INSN) {
 133         if (result->nprefix > 0 && i == 0) {
 134             /*
 135              * Instruction prefixes are present, but no actual
 136              * instruction. This is allowed: at this point we
 137              * invent a notional instruction of RESB 0.
 138              */
 139             result->opcode = I_RESB;
 140             result->operands = 1;
 141             result->oprs[0].type = IMMEDIATE;
 142             result->oprs[0].offset = 0L;
 143             result->oprs[0].segment = result->oprs[0].wrt = NO_SEG;
 144             return result;
 145         } else {
 146             error (ERR_NONFATAL, "parser: instruction expected");
 147             result->opcode = -1;
 148             return result;
 149         }
 150     }
 151
 152     result->opcode = tokval.t_integer;
 153     result->condition = tokval.t_inttwo;
 154
 155     /*
 156      * RESB, RESW and RESD cannot be satisfied with incorrectly
 157      * evaluated operands, since the correct values _must_ be known
 158      * on the first pass. Hence, even in pass one, we set the
 159      * `critical' flag on calling evaluate(), so that it will bomb
 160      * out on undefined symbols. Nasty, but there's nothing we can
 161      * do about it.
 162      *
 163      * For the moment, EQU has the same difficulty, so we'll
 164      * include that.
 165      */
 166     if (result->opcode == I_RESB ||
 167         result->opcode == I_RESW ||
 168         result->opcode == I_RESD ||
 169         result->opcode == I_RESQ ||
 170         result->opcode == I_REST ||
 171         result->opcode == I_EQU)
 172         critical = pass;
 173     else
 174         critical = (pass==2 ? 2 : 0);
 175
 176     if (result->opcode == I_DB ||
 177         result->opcode == I_DW ||
 178         result->opcode == I_DD ||
 179         result->opcode == I_DQ ||
 180         result->opcode == I_DT ||
 181         result->opcode == I_INCBIN) {
 182         extop *eop, **tail = &result->eops, **fixptr;
 183         int oper_num = 0;
 184
 185         /*
 186          * Begin to read the DB/DW/DD/DQ/DT operands.
 187          */
 188         while (1) {
 189             i = stdscan(NULL, &tokval);
 190             if (i == 0)
 191                 break;
 192             fixptr = tail;
 193             eop = *tail = nasm_malloc(sizeof(extop));
 194             tail = &eop->next;
 195             eop->next = NULL;
 196             eop->type = EOT_NOTHING;
 197             oper_num++;
 198
 199             if (i == TOKEN_NUM && tokval.t_charptr && is_comma_next()) {
 200                 eop->type = EOT_DB_STRING;
 201                 eop->stringval = tokval.t_charptr;
 202                 eop->stringlen = tokval.t_inttwo;
 203                 i = stdscan(NULL, &tokval);       /* eat the comma */
 204                 continue;
 205             }
 206
 207             if (i == TOKEN_FLOAT || i == '-') {
 208                 long sign = +1L;
 209
 210                 if (i == '-') {
 211                     char *save = stdscan_bufptr;
 212                     i = stdscan(NULL, &tokval);
 213                     sign = -1L;
 214                     if (i != TOKEN_FLOAT) {
 215                         stdscan_bufptr = save;
 216                         i = tokval.t_type = '-';
 217                     }
 218                 }
 219
 220                 if (i == TOKEN_FLOAT) {
 221                     eop->type = EOT_DB_STRING;
 222                     if (result->opcode == I_DD)
 223                         eop->stringlen = 4;
 224                     else if (result->opcode == I_DQ)
 225                         eop->stringlen = 8;
 226                     else if (result->opcode == I_DT)
 227                     eop->stringlen = 10;
 228                     else {
 229                         error(ERR_NONFATAL, "floating-point constant"
 230                               " encountered in `D%c' instruction",
 231                               result->opcode == I_DW ? 'W' : 'B');
 232                         eop->type = EOT_NOTHING;
 233                     }
 234                     eop = nasm_realloc(eop, sizeof(extop)+eop->stringlen);
 235                     tail = &eop->next;
 236                     *fixptr = eop;
 237                     eop->stringval = (char *)eop + sizeof(extop);
 238                     if (!float_const (tokval.t_charptr, sign,
 239                                       (unsigned char *)eop->stringval,
 240                                       eop->stringlen, error))
 241                         eop->type = EOT_NOTHING;
 242                     i = stdscan(NULL, &tokval);       /* eat the comma */
 243                     continue;
 244                 }
 245             }
 246
 247             /* anything else */ {
 248                 expr *value;
 249                 value = evaluate (stdscan, NULL, &tokval, NULL,
 250                                   critical, error, NULL);
 251                 i = tokval.t_type;
 252                 if (!value) {          /* error in evaluator */
 253                     result->opcode = -1;/* unrecoverable parse error: */
 254                     return result;     /* ignore this instruction */
 255                 }
 256                 if (is_unknown(value)) {
 257                     eop->type = EOT_DB_NUMBER;
 258                     eop->offset = 0;   /* doesn't matter what we put */
 259                     eop->segment = eop->wrt = NO_SEG;   /* likewise */
 260                 } else if (is_reloc(value)) {
 261                     eop->type = EOT_DB_NUMBER;
 262                     eop->offset = reloc_value(value);
 263                     eop->segment = reloc_seg(value);
 264                     eop->wrt = reloc_wrt(value);
 265                 } else {
 266                     error (ERR_NONFATAL,
 267                            "operand %d: expression is not simple"
 268                            " or relocatable", oper_num);
 269                 }
 270             }
 271
 272             /*
 273              * We're about to call stdscan(), which will eat the
 274              * comma that we're currently sitting on between
 275              * arguments. However, we'd better check first that it
 276              * _is_ a comma.
 277              */
 278             if (i == 0)                /* also could be EOL */
 279                 break;
 280             if (i != ',') {
 281                 error (ERR_NONFATAL, "comma expected after operand %d",
 282                        oper_num);
 283                 result->opcode = -1;/* unrecoverable parse error: */
 284                 return result;     /* ignore this instruction */
 285             }
 286         }
 287
 288         if (result->opcode == I_INCBIN) {
 289             /*
 290              * Correct syntax for INCBIN is that there should be
 291              * one string operand, followed by one or two numeric
 292              * operands.
 293              */
 294             if (!result->eops || result->eops->type != EOT_DB_STRING)
 295                 error (ERR_NONFATAL, "`incbin' expects a file name");
 296             else if (result->eops->next &&
 297                      result->eops->next->type != EOT_DB_NUMBER)
 298                 error (ERR_NONFATAL, "`incbin': second parameter is",
 299                        " non-numeric");
 300             else if (result->eops->next && result->eops->next->next &&
 301                      result->eops->next->next->type != EOT_DB_NUMBER)
 302                 error (ERR_NONFATAL, "`incbin': third parameter is",
 303                        " non-numeric");
 304             else if (result->eops->next && result->eops->next->next &&
 305                      result->eops->next->next->next)
 306                 error (ERR_NONFATAL, "`incbin': more than three parameters");
 307             else
 308                 return result;
 309             /*
 310              * If we reach here, one of the above errors happened.
 311              * Throw the instruction away.
 312              */
 313             result->opcode = -1;
 314             return result;
 315         }
 316
 317         return result;
 318     }
 319
 320     /* right. Now we begin to parse the operands. There may be up to three
 321      * of these, separated by commas, and terminated by a zero token. */
 322
 323     for (operand = 0; operand < 3; operand++) {
 324         expr *value;                   /* used most of the time */
 325         int mref;                      /* is this going to be a memory ref? */
 326         int bracket;                   /* is it a [] mref, or a & mref? */
 327
 328         result->oprs[operand].addr_size = 0;/* have to zero this whatever */
 329         result->oprs[operand].eaflags = 0;   /* and this */
 330         i = stdscan(NULL, &tokval);
 331         if (i == 0) break;             /* end of operands: get out of here */
 332         result->oprs[operand].type = 0;   /* so far, no override */
 333         while (i == TOKEN_SPECIAL)      {/* size specifiers */
 334             switch ((int)tokval.t_integer) {
 335               case S_BYTE:
 336                 result->oprs[operand].type |= BITS8;
 337                 break;
 338               case S_WORD:
 339                 result->oprs[operand].type |= BITS16;
 340                 break;
 341               case S_DWORD:
 342               case S_LONG:
 343                 result->oprs[operand].type |= BITS32;
 344                 break;
 345               case S_QWORD:
 346                 result->oprs[operand].type |= BITS64;
 347                 break;
 348               case S_TWORD:
 349                 result->oprs[operand].type |= BITS80;
 350                 break;
 351               case S_TO:
 352                 result->oprs[operand].type |= TO;
 353                 break;
 354               case S_FAR:
 355                 result->oprs[operand].type |= FAR;
 356                 break;
 357               case S_NEAR:
 358                 result->oprs[operand].type |= NEAR;
 359                 break;
 360               case S_SHORT:
 361                 result->oprs[operand].type |= SHORT;
 362                 break;
 363             }
 364             i = stdscan(NULL, &tokval);
 365         }
 366
 367         if (i == '[' || i == '&') {    /* memory reference */
 368             mref = TRUE;
 369             bracket = (i == '[');
 370             i = stdscan(NULL, &tokval);
 371             if (i == TOKEN_SPECIAL) {  /* check for address size override */
 372                 switch ((int)tokval.t_integer) {
 373                   case S_NOSPLIT:
 374                     result->oprs[operand].eaflags |= EAF_TIMESTWO;
 375                     break;
 376                   case S_BYTE:
 377                     result->oprs[operand].eaflags |= EAF_BYTEOFFS;
 378                     break;
 379                   case S_WORD:
 380                     result->oprs[operand].addr_size = 16;
 381                     result->oprs[operand].eaflags |= EAF_WORDOFFS;
 382                     break;
 383                   case S_DWORD:
 384                   case S_LONG:
 385                     result->oprs[operand].addr_size = 32;
 386                     result->oprs[operand].eaflags |= EAF_WORDOFFS;
 387                     break;
 388                   default:
 389                     error (ERR_NONFATAL, "invalid size specification in"
 390                            " effective address");
 391                 }
 392                 i = stdscan(NULL, &tokval);
 393             }
 394         } else {                       /* immediate operand, or register */
 395             mref = FALSE;
 396             bracket = FALSE;           /* placate optimisers */
 397         }
 398
 399         value = evaluate (stdscan, NULL, &tokval,
 400                           &result->forw_ref, critical, error, &hints);
 401         i = tokval.t_type;
 402         if (!value) {                  /* error in evaluator */
 403             result->opcode = -1;       /* unrecoverable parse error: */
 404             return result;             /* ignore this instruction */
 405         }
 406         if (i == ':' && mref) {        /* it was seg:offset */
 407             /*
 408              * Process the segment override.
 409              */
 410             if (value[1].type!=0 || value->value!=1 ||
 411                 REG_SREG & ~reg_flags[value->type])
 412                 error (ERR_NONFATAL, "invalid segment override");
 413             else if (result->nprefix == MAXPREFIX)
 414                 error (ERR_NONFATAL,
 415                        "instruction has more than %d prefixes",
 416                        MAXPREFIX);
 417             else
 418                 result->prefixes[result->nprefix++] = value->type;
 419
 420             i = stdscan(NULL, &tokval);        /* then skip the colon */
 421             if (i == TOKEN_SPECIAL) {  /* another check for size override */
 422                 switch ((int)tokval.t_integer) {
 423                   case S_WORD:
 424                     result->oprs[operand].addr_size = 16;
 425                     break;
 426                   case S_DWORD:
 427                   case S_LONG:
 428                     result->oprs[operand].addr_size = 32;
 429                     break;
 430                   default:
 431                     error (ERR_NONFATAL, "invalid size specification in"
 432                            " effective address");
 433                 }
 434                 i = stdscan(NULL, &tokval);
 435             }
 436             value = evaluate (stdscan, NULL, &tokval,
 437                               &result->forw_ref, critical, error, &hints);
 438             i = tokval.t_type;
 439             /* and get the offset */
 440             if (!value) {              /* but, error in evaluator */
 441                 result->opcode = -1;   /* unrecoverable parse error: */
 442                 return result;         /* ignore this instruction */
 443             }
 444         }
 445         if (mref && bracket) {         /* find ] at the end */
 446             if (i != ']') {
 447                 error (ERR_NONFATAL, "parser: expecting ]");
 448                 do {                   /* error recovery again */
 449                     i = stdscan(NULL, &tokval);
 450                 } while (i != 0 && i != ',');
 451             } else                     /* we got the required ] */
 452                 i = stdscan(NULL, &tokval);
 453         } else {                       /* immediate operand */
 454             if (i != 0 && i != ',' && i != ':') {
 455                 error (ERR_NONFATAL, "comma or end of line expected");
 456                 do {                   /* error recovery */
 457                     i = stdscan(NULL, &tokval);
 458                 } while (i != 0 && i != ',');
 459             } else if (i == ':') {
 460                 result->oprs[operand].type |= COLON;
 461             }
 462         }
 463
 464         /* now convert the exprs returned from evaluate() into operand
 465          * descriptions... */
 466
 467         if (mref) {                    /* it's a memory reference */
 468             expr *e = value;
 469             int b, i, s;               /* basereg, indexreg, scale */
 470             long o;                    /* offset */
 471
 472             b = i = -1, o = s = 0;
 473             result->oprs[operand].hintbase = hints.base;
 474             result->oprs[operand].hinttype = hints.type;
 475
 476             if (e->type <= EXPR_REG_END) {   /* this bit's a register */
 477                 if (e->value == 1) /* in fact it can be basereg */
 478                     b = e->type;
 479                 else           /* no, it has to be indexreg */
 480                     i = e->type, s = e->value;
 481                 e++;
 482             }
 483             if (e->type && e->type <= EXPR_REG_END) {/* it's a 2nd register */
 484                 if (e->value != 1) {   /* it has to be indexreg */
 485                     if (i != -1) {     /* but it can't be */
 486                         error(ERR_NONFATAL, "invalid effective address");
 487                         result->opcode = -1;
 488                         return result;
 489                     } else
 490                         i = e->type, s = e->value;
 491                 } else {               /* it can be basereg */
 492                     if (b != -1)       /* or can it? */
 493                         i = e->type, s = 1;
 494                     else
 495                         b = e->type;
 496                 }
 497                 e++;
 498             }
 499             if (e->type != 0) {        /* is there an offset? */
 500                 if (e->type <= EXPR_REG_END) {/* in fact, is there an error? */
 501                     error (ERR_NONFATAL, "invalid effective address");
 502                     result->opcode = -1;
 503                     return result;
 504                 } else {
 505                     if (e->type == EXPR_UNKNOWN) {
 506                         o = 0;         /* doesn't matter what */
 507                         result->oprs[operand].wrt = NO_SEG;   /* nor this */
 508                         result->oprs[operand].segment = NO_SEG;  /* or this */
 509                         while (e->type) e++;   /* go to the end of the line */
 510                     } else {
 511                         if (e->type == EXPR_SIMPLE) {
 512                             o = e->value;
 513                             e++;
 514                         }
 515                         if (e->type == EXPR_WRT) {
 516                             result->oprs[operand].wrt = e->value;
 517                             e++;
 518                         } else
 519                             result->oprs[operand].wrt = NO_SEG;
 520                         /*
 521                          * Look for a segment base type.
 522                          */
 523                         if (e->type && e->type < EXPR_SEGBASE) {
 524                             error (ERR_NONFATAL, "invalid effective address");
 525                             result->opcode = -1;
 526                             return result;
 527                         }
 528                         while (e->type && e->value == 0)
 529                             e++;
 530                         if (e->type && e->value != 1) {
 531                             error (ERR_NONFATAL, "invalid effective address");
 532                             result->opcode = -1;
 533                             return result;
 534                         }
 535                         if (e->type) {
 536                             result->oprs[operand].segment =
 537                                 e->type - EXPR_SEGBASE;
 538                             e++;
 539                         } else
 540                             result->oprs[operand].segment = NO_SEG;
 541                         while (e->type && e->value == 0)
 542                             e++;
 543                         if (e->type) {
 544                             error (ERR_NONFATAL, "invalid effective address");
 545                             result->opcode = -1;
 546                             return result;
 547                         }
 548                     }
 549                 }
 550             } else {
 551                 o = 0;
 552                 result->oprs[operand].wrt = NO_SEG;
 553                 result->oprs[operand].segment = NO_SEG;
 554             }
 555
 556             if (e->type != 0) {    /* there'd better be nothing left! */
 557                 error (ERR_NONFATAL, "invalid effective address");
 558                 result->opcode = -1;
 559                 return result;
 560             }
 561
 562             result->oprs[operand].type |= MEMORY;
 563             if (b==-1 && (i==-1 || s==0))
 564                 result->oprs[operand].type |= MEM_OFFS;
 565             result->oprs[operand].basereg = b;
 566             result->oprs[operand].indexreg = i;
 567             result->oprs[operand].scale = s;
 568             result->oprs[operand].offset = o;
 569         } else {                       /* it's not a memory reference */
 570             if (is_just_unknown(value)) {     /* it's immediate but unknown */
 571                 result->oprs[operand].type |= IMMEDIATE;
 572                 result->oprs[operand].offset = 0;   /* don't care */
 573                 result->oprs[operand].segment = NO_SEG; /* don't care again */
 574                 result->oprs[operand].wrt = NO_SEG;/* still don't care */
 575             } else if (is_reloc(value)) {     /* it's immediate */
 576                 result->oprs[operand].type |= IMMEDIATE;
 577                 result->oprs[operand].offset = reloc_value(value);
 578                 result->oprs[operand].segment = reloc_seg(value);
 579                 result->oprs[operand].wrt = reloc_wrt(value);
 580                 if (is_simple(value) && reloc_value(value)==1)
 581                     result->oprs[operand].type |= UNITY;
 582             } else {           /* it's a register */
 583                 if (value->type>=EXPR_SIMPLE || value->value!=1) {
 584                     error (ERR_NONFATAL, "invalid operand type");
 585                     result->opcode = -1;
 586                     return result;
 587                 }
 588                 /* clear overrides, except TO which applies to FPU regs */
 589                 result->oprs[operand].type &= TO;
 590                 result->oprs[operand].type |= REGISTER;
 591                 result->oprs[operand].type |= reg_flags[value->type];
 592                 result->oprs[operand].basereg = value->type;
 593             }
 594         }
 595     }
 596
 597     result->operands = operand;       /* set operand count */
 598
 599     while (operand<3)                  /* clear remaining operands */
 600         result->oprs[operand++].type = 0;
 601
 602     /*
 603      * Transform RESW, RESD, RESQ, REST into RESB.
 604      */
 605     switch (result->opcode) {
 606       case I_RESW: result->opcode=I_RESB; result->oprs[0].offset*=2; break;
 607       case I_RESD: result->opcode=I_RESB; result->oprs[0].offset*=4; break;
 608       case I_RESQ: result->opcode=I_RESB; result->oprs[0].offset*=8; break;
 609       case I_REST: result->opcode=I_RESB; result->oprs[0].offset*=10; break;
 610     }
 611
 612     return result;
 613 }
 614
 615 static int is_comma_next (void) {
 616     char *p;
 617     int i;
 618     struct tokenval tv;
 619
 620     p = stdscan_bufptr;
 621     i = stdscan (NULL, &tv);
 622     stdscan_bufptr = p;
 623     return (i == ',' || i == ';' || !i);
 624 }
 625
 626 void cleanup_insn (insn *i) {
 627     extop *e;
 628
 629     while (i->eops) {
 630         e = i->eops;
 631         i->eops = i->eops->next;
 632         nasm_free (e);
 633     }
 634 }