commands/i386/asmconv/parse_gnu.c

   1 /*      parse_ack.c - parse GNU assembly                Author: R.S. Veldema
   2  *                                                       <rveldema@cs.vu.nl>
   3  *                                                              26 Aug 1996
   4  */
   5 #define nil 0
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <limits.h>
  10 #include <assert.h>
  11 #include "asmconv.h"
  12 #include "token.h"
  13 #include "asm86.h"
  14 #include "languages.h"
  15
  16 typedef struct mnemonic {       /* GNU as86 mnemonics translation table. */
  17         char            *name;
  18         opcode_t        opcode;
  19         optype_t        optype;
  20 } mnemonic_t;
  21
  22 static mnemonic_t mnemtab[] = {                 /* This array is sorted. */
  23         { ".align",     DOT_ALIGN,      PSEUDO },
  24         { ".ascii",     DOT_ASCII,      PSEUDO },
  25         { ".asciz",     DOT_ASCIZ,      PSEUDO },
  26         { ".assert",    DOT_ASSERT,     PSEUDO },
  27         { ".base",      DOT_BASE,       PSEUDO },
  28         { ".bss",       DOT_BSS,        PSEUDO },
  29         { ".byte",      DOT_DATA1,      PSEUDO },
  30         { ".comm",      DOT_COMM,       PSEUDO },
  31         { ".data",      DOT_DATA,       PSEUDO },
  32         { ".data1",     DOT_DATA1,      PSEUDO },
  33         { ".data2",     DOT_DATA2,      PSEUDO },
  34         { ".data4",     DOT_DATA4,      PSEUDO },
  35         { ".end",       DOT_END,        PSEUDO },
  36         { ".extern",    DOT_EXTERN,     PSEUDO },
  37         { ".file",      DOT_FILE,       PSEUDO },
  38         { ".globl",     DOT_DEFINE,     PSEUDO },
  39         { ".lcomm",     DOT_LCOMM,      PSEUDO },
  40         { ".line",      DOT_LINE,       PSEUDO },
  41         { ".list",      DOT_LIST,       PSEUDO },
  42         { ".long",      DOT_DATA4,      PSEUDO },
  43         { ".nolist",    DOT_NOLIST,     PSEUDO },
  44         { ".rom",       DOT_ROM,        PSEUDO },
  45         { ".space",     DOT_SPACE,      PSEUDO },
  46         { ".symb",      DOT_SYMB,       PSEUDO },
  47         { ".text",      DOT_TEXT,       PSEUDO },
  48         { ".word",      DOT_DATA2,      PSEUDO },
  49         { "aaa",        AAA,            WORD },
  50         { "aad",        AAD,            WORD },
  51         { "aam",        AAM,            WORD },
  52         { "aas",        AAS,            WORD },
  53         { "adcb",       ADC,            BYTE },
  54         { "adcl",       ADC,            WORD },
  55         { "adcw",       ADC,            OWORD },
  56         { "addb",       ADD,            BYTE },
  57         { "addl",       ADD,            WORD },
  58         { "addw",       ADD,            OWORD },
  59         { "andb",       AND,            BYTE },
  60         { "andl",       AND,            WORD },
  61         { "andw",       AND,            OWORD },
  62         { "arpl",       ARPL,           WORD },
  63         { "bound",      BOUND,          WORD },
  64         { "bsf",        BSF,            WORD },
  65         { "bsr",        BSR,            WORD },
  66         { "bswap",      BSWAP,          WORD },
  67         { "btc",        BTC,            WORD },
  68         { "btl",        BT,             WORD },
  69         { "btr",        BTR,            WORD },
  70         { "bts",        BTS,            WORD },
  71         { "btw",        BT,             OWORD },
  72         { "call",       CALL,           JUMP },
  73         { "callf",      CALLF,          JUMP },
  74         { "cbtw",       CBW,            OWORD },
  75         { "cbw",        CBW,            WORD },
  76         { "cdq",        CWD,            WORD },
  77         { "clc",        CLC,            WORD },
  78         { "cld",        CLD,            WORD },
  79         { "cli",        CLI,            WORD },
  80         { "cltd",       CWD,            WORD },
  81         { "clts",       CLTS,           WORD },
  82         { "cmc",        CMC,            WORD },
  83         { "cmpb",       CMP,            BYTE },
  84         { "cmpl",       CMP,            WORD },
  85         { "cmps",       CMPS,           WORD },
  86         { "cmpsb",      CMPS,           BYTE },
  87         { "cmpw",       CMP,            OWORD },
  88         { "cmpxchg",    CMPXCHG,        WORD },
  89         { "cwd",        CWD,            WORD },
  90         { "cwde",       CBW,            WORD },
  91         { "cwtd",       CWD,            OWORD },
  92         { "cwtl",       CBW,            WORD },
  93         { "daa",        DAA,            WORD },
  94         { "das",        DAS,            WORD },
  95         { "decb",       DEC,            BYTE },
  96         { "decl",       DEC,            WORD },
  97         { "decw",       DEC,            OWORD },
  98         { "divb",       DIV,            BYTE },
  99         { "divl",       DIV,            WORD },
 100         { "divw",       DIV,            OWORD },
 101         { "enter",      ENTER,          WORD },
 102         { "f2xm1",      F2XM1,          WORD },
 103         { "fabs",       FABS,           WORD },
 104         { "fadd",       FADD,           WORD },
 105         { "faddd",      FADDD,          WORD },
 106         { "faddp",      FADDP,          WORD },
 107         { "fadds",      FADDS,          WORD },
 108         { "fbld",       FBLD,           WORD },
 109         { "fbstp",      FBSTP,          WORD },
 110         { "fchs",       FCHS,           WORD },
 111         { "fcomd",      FCOMD,          WORD },
 112         { "fcompd",     FCOMPD,         WORD },
 113         { "fcompp",     FCOMPP,         WORD },
 114         { "fcomps",     FCOMPS,         WORD },
 115         { "fcoms",      FCOMS,          WORD },
 116         { "fcos",       FCOS,           WORD },
 117         { "fdecstp",    FDECSTP,        WORD },
 118         { "fdivd",      FDIVD,          WORD },
 119         { "fdivp",      FDIVP,          WORD },
 120         { "fdivrd",     FDIVRD,         WORD },
 121         { "fdivrp",     FDIVRP,         WORD },
 122         { "fdivrs",     FDIVRS,         WORD },
 123         { "fdivs",      FDIVS,          WORD },
 124         { "ffree",      FFREE,          WORD },
 125         { "fiaddl",     FIADDL,         WORD },
 126         { "fiadds",     FIADDS,         WORD },
 127         { "ficom",      FICOM,          WORD },
 128         { "ficomp",     FICOMP,         WORD },
 129         { "fidivl",     FIDIVL,         WORD },
 130         { "fidivrl",    FIDIVRL,        WORD },
 131         { "fidivrs",    FIDIVRS,        WORD },
 132         { "fidivs",     FIDIVS,         WORD },
 133         { "fildl",      FILDL,          WORD },
 134         { "fildq",      FILDQ,          WORD },
 135         { "filds",      FILDS,          WORD },
 136         { "fimull",     FIMULL,         WORD },
 137         { "fimuls",     FIMULS,         WORD },
 138         { "fincstp",    FINCSTP,        WORD },
 139         { "fistl",      FISTL,          WORD },
 140         { "fistp",      FISTP,          WORD },
 141         { "fists",      FISTS,          WORD },
 142         { "fisubl",     FISUBL,         WORD },
 143         { "fisubrl",    FISUBRL,        WORD },
 144         { "fisubrs",    FISUBRS,        WORD },
 145         { "fisubs",     FISUBS,         WORD },
 146         { "fld1",       FLD1,           WORD },
 147         { "fldcw",      FLDCW,          WORD },
 148         { "fldd",       FLDD,           WORD },
 149         { "fldenv",     FLDENV,         WORD },
 150         { "fldl2e",     FLDL2E,         WORD },
 151         { "fldl2t",     FLDL2T,         WORD },
 152         { "fldlg2",     FLDLG2,         WORD },
 153         { "fldln2",     FLDLN2,         WORD },
 154         { "fldpi",      FLDPI,          WORD },
 155         { "flds",       FLDS,           WORD },
 156         { "fldx",       FLDX,           WORD },
 157         { "fldz",       FLDZ,           WORD },
 158         { "fmuld",      FMULD,          WORD },
 159         { "fmulp",      FMULP,          WORD },
 160         { "fmuls",      FMULS,          WORD },
 161         { "fnclex",     FCLEX,          WORD },
 162         { "fninit",     FINIT,          WORD },
 163         { "fnop",       FNOP,           WORD },
 164         { "fnsave",     FSAVE,          WORD },
 165         { "fnstcw",     FSTCW,          WORD },
 166         { "fnstenv",    FSTENV,         WORD },
 167         { "fpatan",     FPATAN,         WORD },
 168         { "fprem",      FPREM,          WORD },
 169         { "fprem1",     FPREM1,         WORD },
 170         { "fptan",      FPTAN,          WORD },
 171         { "frndint",    FRNDINT,        WORD },
 172         { "frstor",     FRSTOR,         WORD },
 173         { "fscale",     FSCALE,         WORD },
 174         { "fsin",       FSIN,           WORD },
 175         { "fsincos",    FSINCOS,        WORD },
 176         { "fsqrt",      FSQRT,          WORD },
 177         { "fstd",       FSTD,           WORD },
 178         { "fstpd",      FSTPD,          WORD },
 179         { "fstps",      FSTPS,          WORD },
 180         { "fstpx",      FSTPX,          WORD },
 181         { "fsts",       FSTS,           WORD },
 182         { "fstsw",      FSTSW,          WORD },
 183         { "fsubd",      FSUBD,          WORD },
 184         { "fsubp",      FSUBP,          WORD },
 185         { "fsubpr",     FSUBPR,         WORD },
 186         { "fsubrd",     FSUBRD,         WORD },
 187         { "fsubrs",     FSUBRS,         WORD },
 188         { "fsubs",      FSUBS,          WORD },
 189         { "ftst",       FTST,           WORD },
 190         { "fucom",      FUCOM,          WORD },
 191         { "fucomp",     FUCOMP,         WORD },
 192         { "fucompp",    FUCOMPP,        WORD },
 193         { "fxam",       FXAM,           WORD },
 194         { "fxch",       FXCH,           WORD },
 195         { "fxtract",    FXTRACT,        WORD },
 196         { "fyl2x",      FYL2X,          WORD },
 197         { "fyl2xp1",    FYL2XP1,        WORD },
 198         { "hlt",        HLT,            WORD },
 199         { "idivb",      IDIV,           BYTE },
 200         { "idivl",      IDIV,           WORD },
 201         { "idivw",      IDIV,           OWORD },
 202         { "imulb",      IMUL,           BYTE },
 203         { "imull",      IMUL,           WORD },
 204         { "imulw",      IMUL,           OWORD },
 205         { "inb",        IN,             BYTE },
 206         { "incb",       INC,            BYTE },
 207         { "incl",       INC,            WORD },
 208         { "incw",       INC,            OWORD },
 209         { "inl",        IN,             WORD },
 210         { "insb",       INS,            BYTE },
 211         { "insl",       INS,            WORD },
 212         { "insw",       INS,            OWORD },
 213         { "int",        INT,            WORD },
 214         { "into",       INTO,           JUMP },
 215         { "invd",       INVD,           WORD },
 216         { "invlpg",     INVLPG,         WORD },
 217         { "inw",        IN,             OWORD },
 218         { "iret",       IRET,           JUMP },
 219         { "iretd",      IRETD,          JUMP },
 220         { "ja",         JA,             JUMP },
 221         { "jae",        JAE,            JUMP },
 222         { "jb",         JB,             JUMP },
 223         { "jbe",        JBE,            JUMP },
 224         { "jc",         JB,             JUMP },
 225         { "jcxz",       JCXZ,           JUMP },
 226         { "je",         JE,             JUMP },
 227         { "jecxz",      JCXZ,           JUMP },
 228         { "jg",         JG,             JUMP },
 229         { "jge",        JGE,            JUMP },
 230         { "jl",         JL,             JUMP },
 231         { "jle",        JLE,            JUMP },
 232         { "jmp",        JMP,            JUMP },
 233         { "jmpf",       JMPF,           JUMP },
 234         { "jna",        JBE,            JUMP },
 235         { "jnae",       JB,             JUMP },
 236         { "jnb",        JAE,            JUMP },
 237         { "jnbe",       JA,             JUMP },
 238         { "jnc",        JAE,            JUMP },
 239         { "jne",        JNE,            JUMP },
 240         { "jng",        JLE,            JUMP },
 241         { "jnge",       JL,             JUMP },
 242         { "jnl",        JGE,            JUMP },
 243         { "jnle",       JG,             JUMP },
 244         { "jno",        JNO,            JUMP },
 245         { "jnp",        JNP,            JUMP },
 246         { "jns",        JNS,            JUMP },
 247         { "jnz",        JNE,            JUMP },
 248         { "jo",         JO,             JUMP },
 249         { "jp",         JP,             JUMP },
 250         { "js",         JS,             JUMP },
 251         { "jz",         JE,             JUMP },
 252         { "lahf",       LAHF,           WORD },
 253         { "lar",        LAR,            WORD },
 254         { "lds",        LDS,            WORD },
 255         { "leal",       LEA,            WORD },
 256         { "leave",      LEAVE,          WORD },
 257         { "leaw",       LEA,            OWORD },
 258         { "les",        LES,            WORD },
 259         { "lfs",        LFS,            WORD },
 260         { "lgdt",       LGDT,           WORD },
 261         { "lgs",        LGS,            WORD },
 262         { "lidt",       LIDT,           WORD },
 263         { "lldt",       LLDT,           WORD },
 264         { "lmsw",       LMSW,           WORD },
 265         { "lock",       LOCK,           WORD },
 266         { "lods",       LODS,           WORD },
 267         { "lodsb",      LODS,           BYTE },
 268         { "loop",       LOOP,           JUMP },
 269         { "loope",      LOOPE,          JUMP },
 270         { "loopne",     LOOPNE,         JUMP },
 271         { "loopnz",     LOOPNE,         JUMP },
 272         { "loopz",      LOOPE,          JUMP },
 273         { "lsl",        LSL,            WORD },
 274         { "lss",        LSS,            WORD },
 275         { "ltr",        LTR,            WORD },
 276         { "movb",       MOV,            BYTE },
 277         { "movl",       MOV,            WORD },
 278         { "movsb",      MOVS,           BYTE },
 279         { "movsbl",     MOVSXB,         WORD },
 280         { "movsbw",     MOVSXB,         OWORD },
 281         { "movsl",      MOVS,           WORD },
 282         { "movsw",      MOVS,           OWORD },
 283         { "movswl",     MOVSX,          WORD },
 284         { "movw",       MOV,            OWORD },
 285         { "movzbl",     MOVZXB,         WORD },
 286         { "movzbw",     MOVZXB,         OWORD },
 287         { "movzwl",     MOVZX,          WORD },
 288         { "mulb",       MUL,            BYTE },
 289         { "mull",       MUL,            WORD },
 290         { "mulw",       MUL,            OWORD },
 291         { "negb",       NEG,            BYTE },
 292         { "negl",       NEG,            WORD },
 293         { "negw",       NEG,            OWORD },
 294         { "nop",        NOP,            WORD },
 295         { "notb",       NOT,            BYTE },
 296         { "notl",       NOT,            WORD },
 297         { "notw",       NOT,            OWORD },
 298         { "orb",        OR,             BYTE },
 299         { "orl",        OR,             WORD },
 300         { "orw",        OR,             OWORD },
 301         { "outb",       OUT,            BYTE },
 302         { "outl",       OUT,            WORD },
 303         { "outsb",      OUTS,           BYTE },
 304         { "outsl",      OUTS,           WORD },
 305         { "outsw",      OUTS,           OWORD },
 306         { "outw",       OUT,            OWORD },
 307         { "pop",        POP,            WORD },
 308         { "popa",       POPA,           WORD },
 309         { "popad",      POPA,           WORD },
 310         { "popf",       POPF,           WORD },
 311         { "popl",       POP,            WORD },
 312         { "push",       PUSH,           WORD },
 313         { "pusha",      PUSHA,          WORD },
 314         { "pushad",     PUSHA,          WORD },
 315         { "pushf",      PUSHF,          WORD },
 316         { "pushl",      PUSH,           WORD },
 317         { "rclb",       RCL,            BYTE },
 318         { "rcll",       RCL,            WORD },
 319         { "rclw",       RCL,            OWORD },
 320         { "rcrb",       RCR,            BYTE },
 321         { "rcrl",       RCR,            WORD },
 322         { "rcrw",       RCR,            OWORD },
 323         { "ret",        RET,            JUMP },
 324         { "retf",       RETF,           JUMP },
 325         { "rolb",       ROL,            BYTE },
 326         { "roll",       ROL,            WORD },
 327         { "rolw",       ROL,            OWORD },
 328         { "rorb",       ROR,            BYTE },
 329         { "rorl",       ROR,            WORD },
 330         { "rorw",       ROR,            OWORD },
 331         { "sahf",       SAHF,           WORD },
 332         { "salb",       SAL,            BYTE },
 333         { "sall",       SAL,            WORD },
 334         { "salw",       SAL,            OWORD },
 335         { "sarb",       SAR,            BYTE },
 336         { "sarl",       SAR,            WORD },
 337         { "sarw",       SAR,            OWORD },
 338         { "sbbb",       SBB,            BYTE },
 339         { "sbbl",       SBB,            WORD },
 340         { "sbbw",       SBB,            OWORD },
 341         { "scasb",      SCAS,           BYTE },
 342         { "scasl",      SCAS,           WORD },
 343         { "scasw",      SCAS,           OWORD },
 344         { "seta",       SETA,           BYTE },
 345         { "setae",      SETAE,          BYTE },
 346         { "setb",       SETB,           BYTE },
 347         { "setbe",      SETBE,          BYTE },
 348         { "sete",       SETE,           BYTE },
 349         { "setg",       SETG,           BYTE },
 350         { "setge",      SETGE,          BYTE },
 351         { "setl",       SETL,           BYTE },
 352         { "setna",      SETBE,          BYTE },
 353         { "setnae",     SETB,           BYTE },
 354         { "setnb",      SETAE,          BYTE },
 355         { "setnbe",     SETA,           BYTE },
 356         { "setne",      SETNE,          BYTE },
 357         { "setng",      SETLE,          BYTE },
 358         { "setnge",     SETL,           BYTE },
 359         { "setnl",      SETGE,          BYTE },
 360         { "setnle",     SETG,           BYTE },
 361         { "setno",      SETNO,          BYTE },
 362         { "setnp",      SETNP,          BYTE },
 363         { "setns",      SETNS,          BYTE },
 364         { "seto",       SETO,           BYTE },
 365         { "setp",       SETP,           BYTE },
 366         { "sets",       SETS,           BYTE },
 367         { "setz",       SETE,           BYTE },
 368         { "sgdt",       SGDT,           WORD },
 369         { "shlb",       SHL,            BYTE },
 370         { "shldl",      SHLD,           WORD },
 371         { "shll",       SHL,            WORD },
 372         { "shlw",       SHL,            OWORD },
 373         { "shrb",       SHR,            BYTE },
 374         { "shrdl",      SHRD,           WORD },
 375         { "shrl",       SHR,            WORD },
 376         { "shrw",       SHR,            OWORD },
 377         { "sidt",       SIDT,           WORD },
 378         { "sldt",       SLDT,           WORD },
 379         { "smsw",       SMSW,           WORD },
 380         { "stc",        STC,            WORD },
 381         { "std",        STD,            WORD },
 382         { "sti",        STI,            WORD },
 383         { "stosb",      STOS,           BYTE },
 384         { "stosl",      STOS,           WORD },
 385         { "stosw",      STOS,           OWORD },
 386         { "str",        STR,            WORD },
 387         { "subb",       SUB,            BYTE },
 388         { "subl",       SUB,            WORD },
 389         { "subw",       SUB,            OWORD },
 390         { "testb",      TEST,           BYTE },
 391         { "testl",      TEST,           WORD },
 392         { "testw",      TEST,           OWORD },
 393         { "verr",       VERR,           WORD },
 394         { "verw",       VERW,           WORD },
 395         { "wait",       WAIT,           WORD },
 396         { "wbinvd",     WBINVD,         WORD },
 397         { "xadd",       XADD,           WORD },
 398         { "xchgb",      XCHG,           BYTE },
 399         { "xchgl",      XCHG,           WORD },
 400         { "xchgw",      XCHG,           OWORD },
 401         { "xlat",       XLAT,           WORD },
 402         { "xorb",       XOR,            BYTE },
 403         { "xorl",       XOR,            WORD },
 404         { "xorw",       XOR,            OWORD },
 405 };
 406
 407 void gnu_parse_init(char *file)
 408 /* Prepare parsing of an GNU assembly file. */
 409 {
 410         tok_init(file, '#');
 411 }
 412
 413 static void zap(void)
 414 /* An error, zap the rest of the line. */
 415 {
 416         token_t *t;
 417
 418         while ((t= get_token(0))->type != T_EOF && t->symbol != ';')
 419                 skip_token(1);
 420 }
 421
 422 static mnemonic_t *search_mnem(char *name)
 423 /* Binary search for a mnemonic.  (That's why the table is sorted.) */
 424 {
 425         int low, mid, high;
 426         int cmp;
 427         mnemonic_t *m;
 428
 429         low= 0;
 430         high= arraysize(mnemtab)-1;
 431         while (low <= high) {
 432                 mid= (low + high) / 2;
 433                 m= &mnemtab[mid];
 434
 435                 if ((cmp= strcmp(name, m->name)) == 0) return m;
 436
 437                 if (cmp < 0) high= mid-1; else low= mid+1;
 438         }
 439         return nil;
 440 }
 441
 442 static expression_t *gnu_get_C_expression(int *pn)
 443 /* Read a "C-like" expression.  Note that we don't worry about precedence,
 444  * the expression is printed later like it is read.  If the target language
 445  * does not have all the operators (like ~) then this has to be repaired by
 446  * changing the source file.  (No problem, you still have one source file
 447  * to maintain, not two.)
 448  */
 449 {
 450         expression_t *e, *a1, *a2;
 451         token_t *t;
 452
 453         if ((t= get_token(*pn))->symbol == '(') {
 454                 /* ( expr ): grouping. */
 455                 (*pn)++;
 456                 if ((a1= gnu_get_C_expression(pn)) == nil) return nil;
 457                 if (get_token(*pn)->symbol != ')') {
 458                         parse_err(1, t, "missing )\n");
 459                         del_expr(a1);
 460                         return nil;
 461                 }
 462                 (*pn)++;
 463                 e= new_expr();
 464                 e->operator= '[';
 465                 e->middle= a1;
 466         } else
 467         if (t->type == T_WORD || t->type == T_STRING) {
 468                 /* Label, number, or string. */
 469                 e= new_expr();
 470                 e->operator= t->type == T_WORD ? 'W' : 'S';
 471                 e->name= allocate(nil, (t->len+1) * sizeof(e->name[0]));
 472                 memcpy(e->name, t->name , t->len+1);
 473                 e->len= t->len;
 474                 (*pn)++;
 475         } else
 476         if (t->symbol == '+' || t->symbol == '-' || t->symbol == '~') {
 477                 /* Unary operator. */
 478                 (*pn)++;
 479                 if ((a1= gnu_get_C_expression(pn)) == nil) return nil;
 480                 e= new_expr();
 481                 e->operator= t->symbol;
 482                 e->middle= a1;
 483         } else {
 484                 parse_err(1, t, "expression syntax error\n");
 485                 return nil;
 486         }
 487
 488         switch ((t= get_token(*pn))->symbol) {
 489         case '%':
 490         case '+':
 491         case '-':
 492         case '*':
 493         case '/':
 494         case '&':
 495         case '|':
 496         case '^':
 497         case S_LEFTSHIFT:
 498         case S_RIGHTSHIFT:
 499                 (*pn)++;
 500                 a1= e;
 501                 if ((a2= gnu_get_C_expression(pn)) == nil) {
 502                         del_expr(a1);
 503                         return nil;
 504                 }
 505                 e= new_expr();
 506                 e->operator= t->symbol;
 507                 e->left= a1;
 508                 e->right= a2;
 509         }
 510         return e;
 511 }
 512
 513 static expression_t *gnu_get_operand(int *pn, int deref)
 514 /* Get something like: $immed, memory, offset(%base,%index,scale), or simpler. */
 515 {
 516         expression_t *e, *offset, *base, *index;
 517         token_t *t;
 518         int c;
 519
 520         if (get_token(*pn)->symbol == '$') {
 521                 /* An immediate value. */
 522                 (*pn)++;
 523                 return gnu_get_C_expression(pn);
 524         }
 525
 526         if (get_token(*pn)->symbol == '*') {
 527                 /* Indirection. */
 528                 (*pn)++;
 529                 if ((offset= gnu_get_operand(pn, deref)) == nil) return nil;
 530                 e= new_expr();
 531                 e->operator= '(';
 532                 e->middle= offset;
 533                 return e;
 534         }
 535
 536         if ((get_token(*pn)->symbol == '%')
 537                 && (t= get_token(*pn + 1))->type == T_WORD
 538                 && isregister(t->name)
 539         ) {
 540                 /* A register operand. */
 541                 (*pn)+= 2;
 542                 e= new_expr();
 543                 e->operator= 'W';
 544                 e->name= copystr(t->name);
 545                 return e;
 546         }
 547
 548         /* Offset? */
 549         if (get_token(*pn)->symbol != '('
 550                                 || get_token(*pn + 1)->symbol != '%') {
 551                 /* There is an offset. */
 552                 if ((offset= gnu_get_C_expression(pn)) == nil) return nil;
 553         } else {
 554                 /* No offset. */
 555                 offset= nil;
 556         }
 557
 558         /* (%base,%index,scale) ? */
 559         base= index= nil;
 560         if (get_token(*pn)->symbol == '(') {
 561                 (*pn)++;
 562
 563                 /* %base ? */
 564                 if (get_token(*pn)->symbol == '%'
 565                         && (t= get_token(*pn + 1))->type == T_WORD
 566                         && isregister(t->name)
 567                 ) {
 568                         /* A base register expression. */
 569                         base= new_expr();
 570                         base->operator= 'B';
 571                         base->name= copystr(t->name);
 572                         (*pn)+= 2;
 573                 }
 574
 575                 if (get_token(*pn)->symbol == ',') (*pn)++;
 576
 577                 /* %index ? */
 578                 if (get_token(*pn)->symbol == '%'
 579                         && (t= get_token(*pn + 1))->type == T_WORD
 580                         && isregister(t->name)
 581                 ) {
 582                         /* A index register expression. */
 583                         index= new_expr();
 584                         index->operator= '1';           /* for now */
 585                         index->name= copystr(t->name);
 586                         (*pn)+= 2;
 587                 }
 588
 589                 if (get_token(*pn)->symbol == ',') (*pn)++;
 590
 591                 /* scale ? */
 592                 if ((base != nil || index != nil)
 593                         && (t= get_token(*pn))->type == T_WORD
 594                         && strchr("1248", t->name[0]) != nil
 595                         && t->name[1] == 0
 596                 ) {
 597                         if (index == nil) {
 598                                 /* Base is really an index register. */
 599                                 index= base;
 600                                 base= nil;
 601                         }
 602                         index->operator= t->name[0];
 603                         (*pn)++;
 604                 }
 605
 606                 if (get_token(*pn)->symbol == ')') {
 607                         /* Ending paren. */
 608                         (*pn)++;
 609                 } else {
 610                         /* Alas. */
 611                         parse_err(1, t, "operand syntax error\n");
 612                         del_expr(offset);
 613                         del_expr(base);
 614                         del_expr(index);
 615                         return nil;
 616                 }
 617         }
 618
 619         if (base == nil && index == nil) {
 620                 if (deref) {
 621                         /* Return a lone offset as (offset). */
 622                         e= new_expr();
 623                         e->operator= '(';
 624                         e->middle= offset;
 625                 } else {
 626                         /* Return a lone offset as is. */
 627                         e= offset;
 628                 }
 629         } else {
 630                 e= new_expr();
 631                 e->operator= 'O';
 632                 e->left= offset;
 633
 634                 e->middle= base;
 635                 e->right= index;
 636         }
 637         return e;
 638 }
 639
 640 static expression_t *gnu_get_oplist(int *pn, int deref)
 641 /* Get a comma (or colon for jmpf and callf) separated list of instruction
 642  * operands.
 643  */
 644 {
 645         expression_t *e, *o1, *o2;
 646         token_t *t;
 647
 648         if ((e= gnu_get_operand(pn, deref)) == nil) return nil;
 649
 650         if ((t= get_token(*pn))->symbol == ',' || t->symbol == ':') {
 651                 o1= e;
 652                 (*pn)++;
 653                 if ((o2= gnu_get_oplist(pn, deref)) == nil) {
 654                         del_expr(o1);
 655                         return nil;
 656                 }
 657                 e= new_expr();
 658                 e->operator= ',';
 659                 e->left= o1;
 660                 e->right= o2;
 661         }
 662         return e;
 663 }
 664
 665
 666 static asm86_t *gnu_get_statement(void)
 667 /* Get a pseudo op or machine instruction with arguments. */
 668 {
 669         token_t *t= get_token(0);
 670         asm86_t *a;
 671         mnemonic_t *m;
 672         int n;
 673         int prefix_seen;
 674         int deref;
 675
 676         assert(t->type == T_WORD);
 677
 678         a= new_asm86();
 679
 680         /* Process instruction prefixes. */
 681         for (prefix_seen= 0;; prefix_seen= 1) {
 682                 if (strcmp(t->name, "rep") == 0
 683                         || strcmp(t->name, "repe") == 0
 684                         || strcmp(t->name, "repne") == 0
 685                         || strcmp(t->name, "repz") == 0
 686                         || strcmp(t->name, "repnz") == 0
 687                 ) {
 688                         if (a->rep != ONCE) {
 689                                 parse_err(1, t,
 690                                         "can't have more than one rep\n");
 691                         }
 692                         switch (t->name[3]) {
 693                         case 0:         a->rep= REP;    break;
 694                         case 'e':
 695                         case 'z':       a->rep= REPE;   break;
 696                         case 'n':       a->rep= REPNE;  break;
 697                         }
 698                 } else
 699                 if (!prefix_seen) {
 700                         /* No prefix here, get out! */
 701                         break;
 702                 } else {
 703                         /* No more prefixes, next must be an instruction. */
 704                         if (t->type != T_WORD
 705                                 || (m= search_mnem(t->name)) == nil
 706                                 || m->optype == PSEUDO
 707                         ) {
 708                                 parse_err(1, t,
 709                 "machine instruction expected after instruction prefix\n");
 710                                 del_asm86(a);
 711                                 return nil;
 712                         }
 713                         break;
 714                 }
 715
 716                 /* Skip the prefix and extra newlines. */
 717                 do {
 718                         skip_token(1);
 719                 } while ((t= get_token(0))->symbol == ';');
 720         }
 721
 722         /* All the readahead being done upsets the line counter. */
 723         a->line= t->line;
 724
 725         /* Read a machine instruction or pseudo op. */
 726         if ((m= search_mnem(t->name)) == nil) {
 727                 parse_err(1, t, "unknown instruction '%s'\n", t->name);
 728                 del_asm86(a);
 729                 return nil;
 730         }
 731         a->opcode= m->opcode;
 732         a->optype= m->optype;
 733         a->oaz= 0;
 734         if (a->optype == OWORD) {
 735                 a->oaz|= OPZ;
 736                 a->optype= WORD;
 737         }
 738
 739         switch (a->opcode) {
 740         case IN:
 741         case OUT:
 742         case INT:
 743                 deref= 0;
 744                 break;
 745         default:
 746                 deref= (a->optype >= BYTE);
 747         }
 748         n= 1;
 749         if (get_token(1)->symbol != ';'
 750                         && (a->args= gnu_get_oplist(&n, deref)) == nil) {
 751                 del_asm86(a);
 752                 return nil;
 753         }
 754         if (get_token(n)->symbol != ';') {
 755                 parse_err(1, t, "garbage at end of instruction\n");
 756                 del_asm86(a);
 757                 return nil;
 758         }
 759         if (!is_pseudo(a->opcode)) {
 760                 /* GNU operand order is the other way around. */
 761                 expression_t *e, *t;
 762
 763                 e= a->args;
 764                 while (e != nil && e->operator == ',') {
 765                         t= e->right; e->right= e->left; e->left= t;
 766                         e= e->left;
 767                 }
 768         }
 769         switch (a->opcode) {
 770         case DOT_ALIGN:
 771                 /* Delete two argument .align, because ACK can't do it.
 772                  * Raise 2 to the power of .align's argument.
 773                  */
 774                 if (a->args == nil || a->args->operator != 'W') {
 775                         del_asm86(a);
 776                         return nil;
 777                 }
 778                 if (a->args != nil && a->args->operator == 'W'
 779                         && isanumber(a->args->name)
 780                 ) {
 781                         unsigned n;
 782                         char num[sizeof(int) * CHAR_BIT / 3 + 1];
 783
 784                         n= 1 << strtoul(a->args->name, nil, 0);
 785                         sprintf(num, "%u", n);
 786                         deallocate(a->args->name);
 787                         a->args->name= copystr(num);
 788                 }
 789                 break;
 790         case JMPF:
 791         case CALLF:
 792                 /*FALL THROUGH*/
 793         case JMP:
 794         case CALL:
 795                 break;
 796         default:;
 797         }
 798         skip_token(n+1);
 799         return a;
 800 }
 801
 802
 803 asm86_t *gnu_get_instruction(void)
 804 {
 805         asm86_t *a= nil;
 806         expression_t *e;
 807         token_t *t;
 808
 809         while ((t= get_token(0))->symbol == ';' || t->symbol == '/') {
 810                 zap();          /* if a comment started by a '/' */
 811                 skip_token(1);
 812         }
 813
 814         if (t->type == T_EOF) return nil;
 815
 816         if (t->symbol == '#') {
 817                 /* Preprocessor line and file change. */
 818
 819                 if ((t= get_token(1))->type != T_WORD || !isanumber(t->name)
 820                         || get_token(2)->type != T_STRING
 821                 ) {
 822                         parse_err(1, t, "file not preprocessed?\n");
 823                         zap();
 824                 } else {
 825                         set_file(get_token(2)->name,
 826                                 strtol(get_token(1)->name, nil, 0) - 1);
 827
 828                         /* GNU CPP adds extra cruft, simply zap the line. */
 829                         zap();
 830                 }
 831                 a= gnu_get_instruction();
 832         } else
 833         if (t->type == T_WORD && get_token(1)->symbol == ':') {
 834                 /* A label definition. */
 835
 836                 a= new_asm86();
 837                 a->line= t->line;
 838                 a->opcode= DOT_LABEL;
 839                 a->optype= PSEUDO;
 840                 a->args= e= new_expr();
 841                 e->operator= ':';
 842                 e->name= copystr(t->name);
 843                 skip_token(2);
 844         } else
 845         if (t->type == T_WORD && get_token(1)->symbol == '=') {
 846                 int n= 2;
 847
 848                 if ((e= gnu_get_C_expression(&n)) == nil) {
 849                         zap();
 850                         a= gnu_get_instruction();
 851                 } else
 852                 if (get_token(n)->symbol != ';') {
 853                         parse_err(1, t, "garbage after assignment\n");
 854                         zap();
 855                         a= gnu_get_instruction();
 856                 } else {
 857                         a= new_asm86();
 858                         a->line= t->line;
 859                         a->opcode= DOT_EQU;
 860                         a->optype= PSEUDO;
 861                         a->args= new_expr();
 862                         a->args->operator= '=';
 863                         a->args->name= copystr(t->name);
 864                         a->args->middle= e;
 865                         skip_token(n+1);
 866                 }
 867         } else
 868         if (t->type == T_WORD) {
 869                 if ((a= gnu_get_statement()) == nil) {
 870                         zap();
 871                         a= gnu_get_instruction();
 872                 }
 873         } else {
 874                 parse_err(1, t, "syntax error\n");
 875                 zap();
 876                 a= gnu_get_instruction();
 877         }
 878         return a;
 879 }