parse_gnu.c

Minix比较全的源码

/*	parse_ack.c - parse GNU assembly		Author: R.S. Veldema
 *							 <[e-mail]>
 *								26 Aug 1996
 */
#define nil 0
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include "asmconv.h"
#include "token.h"
#include "asm86.h"
#include "languages.h"

typedef struct mnemonic {	/* GNU as86 mnemonics translation table. */
	char		*name;
	opcode_t	opcode;
	optype_t	optype;
} mnemonic_t;

static mnemonic_t mnemtab[] = {			/* This array is sorted. */
	{ ".align",	DOT_ALIGN,	PSEUDO },
	{ ".ascii",	DOT_ASCII,	PSEUDO },
	{ ".asciz",	DOT_ASCIZ,	PSEUDO },
	{ ".assert",	DOT_ASSERT,	PSEUDO },
	{ ".base",	DOT_BASE,	PSEUDO },
	{ ".bss",	DOT_BSS,	PSEUDO },
	{ ".byte",	DOT_DATA1,	PSEUDO },
	{ ".comm",	DOT_COMM,	PSEUDO },
	{ ".data",	DOT_DATA,	PSEUDO },
	{ ".data1",	DOT_DATA1,	PSEUDO },
	{ ".data2",	DOT_DATA2,	PSEUDO },
	{ ".data4",	DOT_DATA4,	PSEUDO },
	{ ".end",	DOT_END,	PSEUDO },
	{ ".extern",	DOT_EXTERN,	PSEUDO },
	{ ".file",	DOT_FILE,	PSEUDO },
	{ ".globl",	DOT_DEFINE,	PSEUDO },
	{ ".lcomm",	DOT_LCOMM,	PSEUDO },
	{ ".line",	DOT_LINE,	PSEUDO },
	{ ".list",	DOT_LIST,	PSEUDO },
	{ ".long",	DOT_DATA4,	PSEUDO },
	{ ".nolist",	DOT_NOLIST,	PSEUDO },
	{ ".rom",	DOT_ROM,	PSEUDO },
	{ ".space",	DOT_SPACE,	PSEUDO },
	{ ".symb",	DOT_SYMB,	PSEUDO },
	{ ".text",	DOT_TEXT,	PSEUDO },
	{ ".word",	DOT_DATA2,	PSEUDO },
	{ "aaa",	AAA,		WORD },
	{ "aad",	AAD,		WORD },
	{ "aam",	AAM,		WORD },
	{ "aas",	AAS,		WORD },
	{ "adcb",	ADC,		BYTE },
	{ "adcl",	ADC,		WORD },
	{ "adcw",	ADC,		OWORD },
	{ "addb",	ADD,		BYTE },
	{ "addl",	ADD,		WORD },
	{ "addw",	ADD,		OWORD },
	{ "andb",	AND,		BYTE },
	{ "andl",	AND,		WORD },
	{ "andw",	AND,		OWORD },
	{ "arpl",	ARPL,		WORD },
	{ "bound",	BOUND,		WORD },
	{ "bsf",	BSF,		WORD },
	{ "bsr",	BSR,		WORD },
	{ "bswap",	BSWAP,		WORD },
	{ "btc",	BTC,		WORD },
	{ "btl",	BT,		WORD },
	{ "btr",	BTR,		WORD },
	{ "bts",	BTS,		WORD },
	{ "btw",	BT,		OWORD },
	{ "call",	CALL,		JUMP },
	{ "callf",	CALLF,		JUMP },
	{ "cbtw",	CBW,		OWORD },
	{ "cbw",	CBW,		WORD },
	{ "cdq",	CWD,		WORD },
	{ "clc",	CLC,		WORD },
	{ "cld",	CLD,		WORD },
	{ "cli",	CLI,		WORD },
	{ "cltd",	CWD,		WORD },
	{ "clts",	CLTS,		WORD },
	{ "cmc",	CMC,		WORD },
	{ "cmpb",	CMP,		BYTE },
	{ "cmpl",	CMP,		WORD },
	{ "cmps",	CMPS,		WORD },
	{ "cmpsb",	CMPS,		BYTE },
	{ "cmpw",	CMP,		OWORD },
	{ "cmpxchg",	CMPXCHG,	WORD },
	{ "cwd",	CWD,		WORD },
	{ "cwde",	CBW,		WORD },
	{ "cwtd",	CWD,		OWORD },
	{ "cwtl",	CBW,		WORD },
	{ "daa",	DAA,		WORD },
	{ "das",	DAS,		WORD },
	{ "decb",	DEC,		BYTE },
	{ "decl",	DEC,		WORD },
	{ "decw",	DEC,		OWORD },
	{ "divb",	DIV,		BYTE },
	{ "divl",	DIV,		WORD },
	{ "divw",	DIV,		OWORD },
	{ "enter",	ENTER,		WORD },
	{ "f2xm1",	F2XM1,		WORD },
	{ "fabs",	FABS,		WORD },
	{ "fadd",	FADD,		WORD },
	{ "faddd",	FADDD,		WORD },
	{ "faddp",	FADDP,		WORD },
	{ "fadds",	FADDS,		WORD },
	{ "fbld",	FBLD,		WORD },
	{ "fbstp",	FBSTP,		WORD },
	{ "fchs",	FCHS,		WORD },
	{ "fcomd",	FCOMD,		WORD },
	{ "fcompd",	FCOMPD,		WORD },
	{ "fcompp",	FCOMPP,		WORD },
	{ "fcomps",	FCOMPS,		WORD },
	{ "fcoms",	FCOMS,		WORD },
	{ "fcos",	FCOS,		WORD },
	{ "fdecstp",	FDECSTP,	WORD },
	{ "fdivd",	FDIVD,		WORD },
	{ "fdivp",	FDIVP,		WORD },
	{ "fdivrd",	FDIVRD,		WORD },
	{ "fdivrp",	FDIVRP,		WORD },
	{ "fdivrs",	FDIVRS,		WORD },
	{ "fdivs",	FDIVS,		WORD },
	{ "ffree",	FFREE,		WORD },
	{ "fiaddl",	FIADDL,		WORD },
	{ "fiadds",	FIADDS,		WORD },
	{ "ficom",	FICOM,		WORD },
	{ "ficomp",	FICOMP,		WORD },
	{ "fidivl",	FIDIVL,		WORD },
	{ "fidivrl",	FIDIVRL,	WORD },
	{ "fidivrs",	FIDIVRS,	WORD },
	{ "fidivs",	FIDIVS,		WORD },
	{ "fildl",	FILDL,		WORD },
	{ "fildq",	FILDQ,		WORD },
	{ "filds",	FILDS,		WORD },
	{ "fimull",	FIMULL,		WORD },
	{ "fimuls",	FIMULS,		WORD },
	{ "fincstp",	FINCSTP,	WORD },
	{ "fistl",	FISTL,		WORD },
	{ "fistp",	FISTP,		WORD },
	{ "fists",	FISTS,		WORD },
	{ "fisubl",	FISUBL,		WORD },
	{ "fisubrl",	FISUBRL,	WORD },
	{ "fisubrs",	FISUBRS,	WORD },
	{ "fisubs",	FISUBS,		WORD },
	{ "fld1",	FLD1,		WORD },
	{ "fldcw",	FLDCW,		WORD },
	{ "fldd",	FLDD,		WORD },
	{ "fldenv",	FLDENV,		WORD },
	{ "fldl2e",	FLDL2E,		WORD },
	{ "fldl2t",	FLDL2T,		WORD },
	{ "fldlg2",	FLDLG2,		WORD },
	{ "fldln2",	FLDLN2,		WORD },
	{ "fldpi",	FLDPI,		WORD },
	{ "flds",	FLDS,		WORD },
	{ "fldx",	FLDX,		WORD },
	{ "fldz",	FLDZ,		WORD },
	{ "fmuld",	FMULD,		WORD },
	{ "fmulp",	FMULP,		WORD },
	{ "fmuls",	FMULS,		WORD },
	{ "fnclex",	FCLEX,		WORD },
	{ "fninit",	FINIT,		WORD },
	{ "fnop",	FNOP,		WORD },
	{ "fnsave",	FSAVE,		WORD },
	{ "fnstcw",	FSTCW,		WORD },
	{ "fnstenv",	FSTENV,		WORD },
	{ "fpatan",	FPATAN,		WORD },
	{ "fprem",	FPREM,		WORD },
	{ "fprem1",	FPREM1,		WORD },
	{ "fptan",	FPTAN,		WORD },
	{ "frndint",	FRNDINT,	WORD },
	{ "frstor",	FRSTOR,		WORD },
	{ "fscale",	FSCALE,		WORD },
	{ "fsin",	FSIN,		WORD },
	{ "fsincos",	FSINCOS,	WORD },
	{ "fsqrt",	FSQRT,		WORD },
	{ "fstd",	FSTD,		WORD },
	{ "fstpd",	FSTPD,		WORD },
	{ "fstps",	FSTPS,		WORD },
	{ "fstpx",	FSTPX,		WORD },
	{ "fsts",	FSTS,		WORD },
	{ "fstsw",	FSTSW,		WORD },
	{ "fsubd",	FSUBD,		WORD },
	{ "fsubp",	FSUBP,		WORD },
	{ "fsubpr",	FSUBPR,		WORD },
	{ "fsubrd",	FSUBRD,		WORD },
	{ "fsubrs",	FSUBRS,		WORD },
	{ "fsubs",	FSUBS,		WORD },
	{ "ftst",	FTST,		WORD },
	{ "fucom",	FUCOM,		WORD },
	{ "fucomp",	FUCOMP,		WORD },
	{ "fucompp",	FUCOMPP,	WORD },
	{ "fxam",	FXAM,		WORD },
	{ "fxch",	FXCH,		WORD },
	{ "fxtract",	FXTRACT,	WORD },
	{ "fyl2x",	FYL2X,		WORD },
	{ "fyl2xp1",	FYL2XP1,	WORD },
	{ "hlt",	HLT,		WORD },
	{ "idivb",	IDIV,		BYTE },
	{ "idivl",	IDIV,		WORD },
	{ "idivw",	IDIV,		OWORD },
	{ "imulb",	IMUL,		BYTE },
	{ "imull",	IMUL,		WORD },
	{ "imulw",	IMUL,		OWORD },
	{ "inb",	IN,		BYTE },
	{ "incb",	INC,		BYTE },
	{ "incl",	INC,		WORD },
	{ "incw",	INC,		OWORD },
	{ "inl",	IN,		WORD },
	{ "insb",	INS,		BYTE },
	{ "insl",	INS,		WORD },
	{ "insw",	INS,		OWORD },
	{ "int",	INT,		WORD },
	{ "into",	INTO,		JUMP },
	{ "invd",	INVD,		WORD },
	{ "invlpg",	INVLPG,		WORD },
	{ "inw",	IN,		OWORD },
	{ "iret",	IRET,		JUMP },
	{ "iretd",	IRETD,		JUMP },
	{ "ja",		JA,		JUMP },
	{ "jae",	JAE,		JUMP },
	{ "jb",		JB,		JUMP },
	{ "jbe",	JBE,		JUMP },
	{ "jc",		JB,		JUMP },
	{ "jcxz",	JCXZ,		JUMP },
	{ "je",		JE,		JUMP },
	{ "jecxz",	JCXZ,		JUMP },
	{ "jg",		JG,		JUMP },
	{ "jge",	JGE,		JUMP },
	{ "jl",		JL,		JUMP },
	{ "jle",	JLE,		JUMP },
	{ "jmp",	JMP,		JUMP },
	{ "jmpf",	JMPF,		JUMP },
	{ "jna",	JBE,		JUMP },
	{ "jnae",	JB,		JUMP },
	{ "jnb",	JAE,		JUMP },
	{ "jnbe",	JA,		JUMP },
	{ "jnc",	JAE,		JUMP },
	{ "jne",	JNE,		JUMP },
	{ "jng",	JLE,		JUMP },
	{ "jnge",	JL,		JUMP },
	{ "jnl",	JGE,		JUMP },
	{ "jnle",	JG,		JUMP },
	{ "jno",	JNO,		JUMP },
	{ "jnp",	JNP,		JUMP },
	{ "jns",	JNS,		JUMP },
	{ "jnz",	JNE,		JUMP },
	{ "jo",		JO,		JUMP },
	{ "jp",		JP,		JUMP },
	{ "js",		JS,		JUMP },
	{ "jz",		JE,		JUMP },
	{ "lahf",	LAHF,		WORD },
	{ "lar",	LAR,		WORD },
	{ "lds",	LDS,		WORD },
	{ "leal",	LEA,		WORD },
	{ "leave",	LEAVE,		WORD },
	{ "leaw",	LEA,		OWORD },
	{ "les",	LES,		WORD },
	{ "lfs",	LFS,		WORD },
	{ "lgdt",	LGDT,		WORD },
	{ "lgs",	LGS,		WORD },
	{ "lidt",	LIDT,		WORD },
	{ "lldt",	LLDT,		WORD },
	{ "lmsw",	LMSW,		WORD },
	{ "lock",	LOCK,		WORD },
	{ "lods",	LODS,		WORD },
	{ "lodsb",	LODS,		BYTE },
	{ "loop",	LOOP,		JUMP },
	{ "loope",	LOOPE,		JUMP },
	{ "loopne",	LOOPNE,		JUMP },
	{ "loopnz",	LOOPNE,		JUMP },
	{ "loopz",	LOOPE,		JUMP },
	{ "lsl",	LSL,		WORD },
	{ "lss",	LSS,		WORD },
	{ "ltr",	LTR,		WORD },
	{ "movb",	MOV,		BYTE },
	{ "movl",	MOV,		WORD },
	{ "movsb",	MOVS,		BYTE },
	{ "movsbl",	MOVSXB,		WORD },
	{ "movsbw",	MOVSXB,		OWORD },
	{ "movsl",	MOVS,		WORD },
	{ "movsw",	MOVS,		OWORD },
	{ "movswl",	MOVSX,		WORD },
	{ "movw",	MOV,		OWORD },
	{ "movzbl",	MOVZXB,		WORD },
	{ "movzbw",	MOVZXB,		OWORD },
	{ "movzwl",	MOVZX,		WORD },
	{ "mulb",	MUL,		BYTE },
	{ "mull",	MUL,		WORD },
	{ "mulw",	MUL,		OWORD },
	{ "negb",	NEG,		BYTE },
	{ "negl",	NEG,		WORD },
	{ "negw",	NEG,		OWORD },
	{ "nop",	NOP,		WORD },
	{ "notb",	NOT,		BYTE },
	{ "notl",	NOT,		WORD },
	{ "notw",	NOT,		OWORD },
	{ "orb",	OR,		BYTE },
	{ "orl",	OR,		WORD },
	{ "orw",	OR,		OWORD },
	{ "outb",	OUT,		BYTE },
	{ "outl",	OUT,		WORD },
	{ "outsb",	OUTS,		BYTE },
	{ "outsl",	OUTS,		WORD },
	{ "outsw",	OUTS,		OWORD },
	{ "outw",	OUT,		OWORD },
	{ "pop",	POP,		WORD },
	{ "popa",	POPA,		WORD },
	{ "popad",	POPA,		WORD },
	{ "popf",	POPF,		WORD },
	{ "popl",	POP,		WORD },
	{ "push",	PUSH,		WORD },
	{ "pusha",	PUSHA,		WORD },
	{ "pushad",	PUSHA,		WORD },
	{ "pushf",	PUSHF,		WORD },
	{ "pushl",	PUSH,		WORD },
	{ "rclb",	RCL,		BYTE },
	{ "rcll",	RCL,		WORD },
	{ "rclw",	RCL,		OWORD },
	{ "rcrb",	RCR,		BYTE },
	{ "rcrl",	RCR,		WORD },
	{ "rcrw",	RCR,		OWORD },
	{ "ret",	RET,		JUMP },
	{ "retf",	RETF,		JUMP },
	{ "rolb",	ROL,		BYTE },
	{ "roll",	ROL,		WORD },
	{ "rolw",	ROL,		OWORD },
	{ "rorb",	ROR,		BYTE },
	{ "rorl",	ROR,		WORD },
	{ "rorw",	ROR,		OWORD },
	{ "sahf",	SAHF,		WORD },
	{ "salb",	SAL,		BYTE },
	{ "sall",	SAL,		WORD },
	{ "salw",	SAL,		OWORD },
	{ "sarb",	SAR,		BYTE },
	{ "sarl",	SAR,		WORD },
	{ "sarw",	SAR,		OWORD },
	{ "sbbb",	SBB,		BYTE },
	{ "sbbl",	SBB,		WORD },
	{ "sbbw",	SBB,		OWORD },
	{ "scasb",	SCAS,		BYTE },
	{ "scasl",	SCAS,		WORD },
	{ "scasw",	SCAS,		OWORD },
	{ "seta",	SETA,		BYTE },
	{ "setae",	SETAE,		BYTE },
	{ "setb",	SETB,		BYTE },
	{ "setbe",	SETBE,		BYTE },
	{ "sete",	SETE,		BYTE },
	{ "setg",	SETG,		BYTE },
	{ "setge",	SETGE,		BYTE },
	{ "setl",	SETL,		BYTE },
	{ "setna",	SETBE,		BYTE },
	{ "setnae",	SETB,		BYTE },
	{ "setnb",	SETAE,		BYTE },
	{ "setnbe",	SETA,		BYTE },
	{ "setne",	SETNE,		BYTE },
	{ "setng",	SETLE,		BYTE },
	{ "setnge",	SETL,		BYTE },
	{ "setnl",	SETGE,		BYTE },
	{ "setnle",	SETG,		BYTE },
	{ "setno",	SETNO,		BYTE },
	{ "setnp",	SETNP,		BYTE },
	{ "setns",	SETNS,		BYTE },
	{ "seto",	SETO,		BYTE },
	{ "setp",	SETP,		BYTE },
	{ "sets",	SETS,		BYTE },
	{ "setz",	SETE,		BYTE },
	{ "sgdt",	SGDT,		WORD },
	{ "shlb",	SHL,		BYTE },
	{ "shldl",	SHLD,		WORD },
	{ "shll",	SHL,		WORD },
	{ "shlw",	SHL,		OWORD },
	{ "shrb",	SHR,		BYTE },
	{ "shrdl",	SHRD,		WORD },
	{ "shrl",	SHR,		WORD },
	{ "shrw",	SHR,		OWORD },
	{ "sidt",	SIDT,		WORD },
	{ "sldt",	SLDT,		WORD },
	{ "smsw",	SMSW,		WORD },
	{ "stc",	STC,		WORD },
	{ "std",	STD,		WORD },
	{ "sti",	STI,		WORD },
	{ "stosb",	STOS,		BYTE },
	{ "stosl",	STOS,		WORD },
	{ "stosw",	STOS,		OWORD },
	{ "str",	STR,		WORD },
	{ "subb",	SUB,		BYTE },
	{ "subl",	SUB,		WORD },
	{ "subw",	SUB,		OWORD },
	{ "testb",	TEST,		BYTE },
	{ "testl",	TEST,		WORD },
	{ "testw",	TEST,		OWORD },
	{ "verr",	VERR,		WORD },
	{ "verw",	VERW,		WORD },
	{ "wait",	WAIT,		WORD },
	{ "wbinvd",	WBINVD,		WORD },
	{ "xadd",	XADD,		WORD },
	{ "xchgb",	XCHG,		BYTE },
	{ "xchgl",	XCHG,		WORD },
	{ "xchgw",	XCHG,		OWORD },
	{ "xlat",	XLAT,		WORD },
	{ "xorb",	XOR,		BYTE },
	{ "xorl",	XOR,		WORD },
	{ "xorw",	XOR,		OWORD },
};

void gnu_parse_init(char *file)
/* Prepare parsing of an GNU assembly file. */
{
	tok_init(file, '#');
}

static void zap(void)
/* An error, zap the rest of the line. */
{
	token_t *t;

	while ((t= get_token(0))->type != T_EOF && t->symbol != ';')
		skip_token(1);
}

static mnemonic_t *search_mnem(char *name)
/* Binary search for a mnemonic.  (That's why the table is sorted.) */
{
	int low, mid, high;
	int cmp;
	mnemonic_t *m;

	low= 0;
	high= arraysize(mnemtab)-1;
	while (low <= high) {
		mid= (low + high) / 2;
		m= &mnemtab[mid];

		if ((cmp= strcmp(name, m->name)) == 0) return m;

		if (cmp < 0) high= mid-1; else low= mid+1;
	}
	return nil;
}