kolibrios/programs/develop/cmm/tokr.cpp

6136 lines
136 KiB
C++
Raw Normal View History

#define _TOKR_
#include "tok.h"
char useasm=FALSE;
char asmparam=FALSE;
#include "asmnemon.h"
void asmtwo1(int basecode); // used for ADD ADC SUB SBB CMP AND OR XOR.
void asmregmem(int out1,int out2); // used for LEA LDS LES LFS LGS LSS.
void Scanbit(int basecode);
void CheckBit(int code);
void asmone1(int basecode); // used for INC and DEC.
void asmone2(int basecode); // used for NEG NOT MUL IMUL DIV IDIV.
void asmshortjump(int shortcode,int nearcode);
void lar_lsl(int code);
unsigned char tabldeckr(int code);
void protectinstr(int code,int code2);
void doasmmov(); // do MOV
void asmextend(int basecode); // procedure MOVSX and MOVZX
void movd();
void movq();
void packMMX(int code,int code1,int code2);
void asmshift(int basecode); // used for ROL ROR RCL RCR SHL SAL SHR SAR.
void Shxd(int code);
void FpuType1(unsigned int addrm);
void FpuType2(unsigned int addrm,unsigned int addrm2);
void FpuType3(unsigned int opcode,unsigned int addrm);
void FpuType4(unsigned int opcode,unsigned int addrm);
void FpuType5(unsigned int opcode,unsigned int addrm);
void FpuType6(unsigned int opcode,unsigned int addrm);
void FpuType7(unsigned int addrm);
void FpuType8(unsigned int opcode,unsigned int addrm);
void addlocaljump(int callkind);
unsigned long SaveNumber(int type,int tok4,char *name);
void cmov(int num);
void mmxiii(int type);
void prefetch(int code, int type);
void pextrw();
void pinsrw();
void pshufw();
void xmminstr(int type,int sec,int op1=tk_xmmreg,int op2=tk_xmmreg);
void xmm3instr(int type,int sec);
void xmm2xmm(int code,int code2=0,int type=tk_xmmreg);
void movxmm(int code,int code2,int addc=1);
void movxmm2(int code,int code2=0);
void movxmm3(int code,int code2=0,int type=tk_xmmreg);
void movxmm4(int code,int code2);
void shiftxmm(int rm); //rxmm,i8
void DDDW(int faradd);
void AADM(int code);
extern void shortjumperror();
extern void invalidfarjumpitem();
extern void invalidfarcallitem();
extern void bytedxexpected();
extern void axalexpected();
extern void clornumberexpected();
extern void reg32regexpected(int type);
extern void begexpected(int type);
extern void regexpected(int type);
extern void invalidoperand(int type);
extern void mmxregexpected(int type=0);
extern void mmxregordwordexpected(int type);
extern void mmxormem(int type);
extern void reg32orword(int type);
extern void xmmregorvarexpected(int type);
extern void xmmregexpected(int type);
extern void fpustakexpected(int type);
extern void fpuvarexpected(int type);
void doasm(int nexta)
{
unsigned char possiblecpu=0,next=1;
int htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
unsigned int i=0;
int razr=r16;
unsigned long hnumber;
int faradd=0;
if(nexta==FALSE){
useasm=TRUE;
nexttok();
useasm=FALSE;
}
if(tok==tk_idasm){
htok=itok.rm;
goto sw_asm;
}
if(tok==tk_ID||tok==tk_id||tok==tk_undefproc){
if(tok2==tk_colon){ //<2F><>
if(tok==tk_undefproc)doanyundefproc();
else doid((char)(tok==tk_ID?1:0),tk_void);
return;
}
strupr((char *)string);
htok=FastSearch((unsigned char *)asmMnem,ofsmnem,0,(char *)string);
sw_asm:
asmparam=TRUE;
switch(htok){
case a_add: //ADD
case a_or: //OR
case a_adc: //ADC
case a_sbb: //SBB
case a_and: //AND
case a_sub: //SUB
case a_xor: //XOR
case a_cmp: //CMP
asmtwo1(htok*8);
next=0;
break;
case a_not: //NOT
case a_neg: //NEG
case a_mul: //MUL
case a_div: //DIV
case a_idiv: //IDIV
asmone2((htok-a_not)*8+16);
break;
case a_rol: //ROL
case a_ror: //ROR
case a_rcl: //RCL
case a_rcr: //RCR
case a_shl: //SHL
case a_shr: //SHR
case a_sar: //SAR
asmshift((htok-a_rol)*8);
next=0;
break;
case a_btc: //BTC
case a_btr: //BTR
case a_bts: //BTS
case a_bt: //BT
CheckBit((htok-a_bt)*8);
next=0;
break;
case a_dec: //DEC
case a_inc: //INC
asmone1((htok-a_inc)*8);
break;
case a_shrd: //SHRD
case a_shld: //SHLD
Shxd((htok-a_shld)*8+0xa4);
next=0;
break;
case a_aaa:
ClearReg(AX);
op(0x37); //AAA
break;
case a_aad:
ClearReg(AX);
AADM(0xD5); //AAD
break;
case a_aam:
ClearReg(AX);
AADM(0xD4); //AAM
break;
case a_aas:
ClearReg(AX);
op(0x3F); //AAS
break;
case a_adrsiz:
op(0x67);
possiblecpu=3;
break;
case a_arpl: //ARPL
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok!=tk_reg)regexpected(2);
switch(htok){
case tk_intvar:
case tk_wordvar:
#ifdef OPTVARCONST
ClearVarByNum(&hstok);
#endif
CheckAllMassiv(hbuf,2,&hstr,&hstok);
KillVar(hstok.name);
outseg(&hstok,2);
op(0x63);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
case tk_reg:
ClearReg(hstok.number);
op(0x63);
op(192+(unsigned int)itok.number*8+hstok.number);
break;
default: wordvalexpected();
}
possiblecpu=2;
break;
case a_bound: //BOUND
asmregmem(0x62,0);
possiblecpu=2;
break;
case a_lea:
asmregmem(0x8D,0); //LEA
break;
case a_lds: //LDS
case a_les: //LES
asmregmem(htok-a_les+0xC4,0);
break;
case a_lss: //LSS
asmregmem(0xF,0xB2);
possiblecpu=3;
break;
case a_lgs: //LGS
case a_lfs: //LFS
asmregmem(0xF,htok-a_lfs+0xB4);
possiblecpu=3;
break;
case a_bswap: //BSWAP
nexttok();
ClearReg(itok.number);
if(tok==tk_reg32||tok==tk_reg){
op66(tok==tk_reg?r16:r32);
op(0x0F);
op(0xC8+(unsigned int)itok.number);
}
else preerror("Expecting 32 bit Register for BSWAP");
possiblecpu=4;
break;
case a_bsf: //BSF
case a_bsr: //BSR
Scanbit(htok-a_bsf+0xbc);
break;
case a_call: //CALL
nexttok();
htok=0;
if(tok==tk_ID||tok==tk_id){
if(stricmp("FAR",(char *)string)==0){
nexttok();
faradd=8;
htok=1;
}
else if(stricmp("NEAR",(char *)string)==0){
nexttok();
htok=1;
}
}
else if(tok==tk_far){
nexttok();
faradd=8;
htok=1;
}
// printf("call %d\n",tok);
switch(tok){
case tk_proc:
if(faradd==0){
if(itok.segm==DYNAMIC){
itok.segm=DYNAMIC_USED;
updatetree();
}
int flag=itok.flag;
if(itok.segm<NOT_DYNAMIC){ //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><E6A5A4><EFBFBD>
addacall(itok.number,(unsigned char)(am32!=FALSE?CALL_32:CALL_NEAR));
callloc0();
}
else callloc(itok.number);
}
else invalidfarcallitem();
break;
case tk_number:
asmparam=FALSE;
hnumber=doconstdwordmath();
if(faradd==0)callloc(hnumber);
else{
op(0x9A);
expecting2(tk_colon);
unsigned long tempi=doconstdwordmath();
if(am32==FALSE)outword((unsigned int)tempi);
else outdword(tempi);
outword(hnumber);
}
next=0;
break; /* CALL num */
case tk_postnumber:
if(faradd==0){
itok.number=itok.number-outptr-3;
op(0xE8);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(am32==FALSE)outword(itok.number);
else outdword(itok.number-2);
/* op(0xE8);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(am32==FALSE)outword((unsigned int)itok.number);
else outdword(itok.number);*/
}
else invalidfarcallitem();
break;
case tk_reg32:
op66(r32);
goto callreg;
case tk_reg:
op66(r16);
callreg:
if(faradd==0){
op(0xFF);
op(0xD0+(unsigned int)itok.number);
} /* CALL reg */
else invalidfarcallitem();
break;
case tk_ID:
case tk_id:
if(faradd==0){
tobedefined(am32==FALSE?CALL_NEAR:CALL_32,tk_void);
callloc0();
} /* CALL NEAR */
else invalidfarcallitem();
break;
case tk_declare:
tok=tk_undefproc;
updatetree();
case tk_locallabel:
case tk_undefproc:
if(faradd==0){
addacall((unsigned int)itok.number,
(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?CALL_NEAR:CALL_32)));
callloc0();
} /* CALL NEAR */
else invalidfarcallitem();
break;
case tk_dwordvar:
case tk_longvar:
i=2;
if(am32==FALSE&&htok==0)faradd=8;
case tk_intvar:
case tk_wordvar:
i+=2;
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,2);
op(0xFF); op(0x10+itok.rm+faradd);
outaddress(&itok);
break;
default:
preerror("Invalid item for CALL");
break;
}
#ifdef OPTVARCONST
FreeGlobalConst();
#endif
clearregstat();
break;
case a_cbw:
ClearReg(AX);
if(am32)op(0x66);
op(0x98); //CBW
break;
case a_cdq:
ClearReg(DX);
op66(r32);
op(0x99);
possiblecpu=3; //CDQ
break;
case a_clc:
op(0xF8); //CLC
break;
case a_cld:
op(0xFC); //CLD
break;
case a_cli:
op(0xFA); //CLI
break;
case a_clts: //CLTS
outword(0x060F);
possiblecpu=2;
break;
case a_cmc:
op(0xF5); //CMC
break;
case a_cmpsb:
ClearReg(SI);
ClearReg(DI);
op(0xA6);
break;
case a_cmpsw:
ClearReg(SI);
ClearReg(DI);
op66(r16);
op(0xA7);
break;
case a_cmpsd:
if(ScanTok3()==tk_camma&&tok2==tk_xmmreg){
xmm3instr(0xC2,0xF2);
possiblecpu=9;
next=0;
}
else{
ClearReg(SI);
ClearReg(DI);
op66(r32);
op(0xA7);
possiblecpu=3;
}
break;
case a_cmpxchg: //CMPXCHG
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
i=r16;
ClearReg(AX);
switch(htok){
case tk_reg32:
i=r32;
case tk_reg:
ClearReg(hstok.number);
switch(tok){
case tk_reg32:
if(i==r16)goto erreg;
case tk_reg:
op66(i);
outword(0xB10F);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_longvar:
case tk_dwordvar:
if(i==r16)goto erreg;
case tk_intvar:
case tk_wordvar:
#ifdef OPTVARCONST
ClearVarByNum(&itok);
#endif
CheckAllMassiv(bufrm,i,&strinf);
op66(i);
outseg(&itok,3);
outword(0xB10F);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default:
erreg:
if(i==r16)wordvalexpected();
else dwordvalexpected();
break;
}
break;
case tk_beg:
ClearReg(hstok.number);
switch(tok){
case tk_beg:
outword(0xB00F);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,1,&strinf);
outseg(&itok,3);
outword(0xB00F);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: bytevalexpected(2);
break;
}
break;
case tk_charvar:
case tk_bytevar:
#ifdef OPTVARCONST
ClearVarByNum(&hstok);
#endif
if(tok!=tk_beg)begexpected(2);
CheckAllMassiv(hbuf,1,&hstr,&hstok);
KillVar(hstok.name);
outseg(&hstok,3);
outword(0xB00F);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
case tk_longvar:
case tk_dwordvar:
if(tok!=tk_reg32)reg32expected(2);
i=r32;
goto noint;
case tk_intvar:
case tk_wordvar:
if(tok!=tk_reg)regexpected(2);
noint:
#ifdef OPTVARCONST
ClearVarByNum(&hstok);
#endif
CheckAllMassiv(hbuf,i,&hstr,&hstok);
KillVar(hstok.name);
op66(i);
outseg(&hstok,3);
outword(0xB10F);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
default:
varexpected(1);
break;
}
possiblecpu=4;
break;
case a_cmpxchg8b: //CMPXCHG8B
nexttok();
if(tok!=tk_qwordvar)qwordvalexpected();
#ifdef OPTVARCONST
ClearVarByNum(&itok);
#endif
CheckAllMassiv(bufrm,8,&strinf);
KillVar(itok.name);
outseg(&itok,3);
outword(0xc70f);
op(itok.rm+8);
outaddress(&itok);
possiblecpu=5;
break;
case a_cwd:
ClearReg(DX);
op66(r16);
op(0x99); //CWD
break;
case a_cwde:
ClearReg(AX);
if(!am32)op(0x66);
op(0x98);
possiblecpu=3;
break;
case a_cpuid:
ClearReg(AX);
ClearReg(BX);
ClearReg(CX);
ClearReg(DX);
outword(0xa20f); //CPUID
possiblecpu=5;
break;
case a_daa:
ClearReg(AX);
op(0x27); //DAA
break;
case a_das:
ClearReg(AX);
op(0x2F); //DAS
break;
case a_db: //DB
dbgact++;
asmparam=FALSE;
do{
i=1;
nexttok();
CheckIP();
if(tok==tk_number){
hnumber=doconstdwordmath();
if(tok==tk_id&&strcmp((char *)string,"dup")==0){
i=hnumber;
nexttok();
CheckMinusNum();
if(tok==tk_number)hnumber=doconstdwordmath();
else numexpected();
}
for(;i!=0;i--)op(hnumber);
}
else if(tok==tk_string){
for(i=0;i<(unsigned int)itok.number;i++)opd(string[i]);
switch(itok.flag&3){
case zero_term:
if(itok.flag&s_unicod)opd(0);
opd(0);
break;
case dos_term:
if(itok.flag&s_unicod)opd(0);
opd('$');
break;
}
nexttok();
}
else{
numexpected();
nexttok();
}
}while(tok==tk_camma);
dbgact--;
next=0;
break;
case a_dd: //DD
faradd++;
case a_dw: //DW
DDDW(faradd);
next=0;
break;
case a_enter: //ENTER
ClearReg(BP);
op(0xC8);
nexttok();
if(tok==tk_number)outword((unsigned int)doconstlongmath());
else{
numexpected(1);
nexttok();
}
expecting2(tk_camma);
if(tok==tk_number)op((int)doconstlongmath());
else{
numexpected(2);
nexttok();
}
next=0;
possiblecpu=2;
break;
case a_emms: //EMMS
outword(0x770f);
possiblecpu=6;
break;
case a_imul: //IMUL
nexttok();
if(tok2!=tk_camma){
ClearReg(AX);
switch(tok){
case tk_reg32:
possiblecpu=3;
razr=r32;
case tk_reg:
ClearReg(DX);
op66(razr);
op(246+1);
op(128+64+40+(unsigned int)itok.number);
break;
case tk_beg:
op(246);
op(128+64+40+(unsigned int)itok.number);
break;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,1,&strinf);
outseg(&itok,2);
op(246);
op(itok.rm+40);
outaddress(&itok);
break;
case tk_longvar:
case tk_dwordvar:
CheckAllMassiv(bufrm,4,&strinf);
possiblecpu=3;
razr=r32;
case tk_intvar:
case tk_wordvar:
CheckAllMassiv(bufrm,2,&strinf);
ClearReg(DX);
op66(razr);
outseg(&itok,2);
op(247);
op(itok.rm+40);
outaddress(&itok);
break;
default: varexpected(1); break;
}
}
else{
htok=tok;
hnumber=itok.number;
ClearReg(hnumber);
nextexpecting2(tk_camma);
possiblecpu=2;
if(tok2!=tk_camma){
switch(tok){
case tk_number:
switch(htok){
case tk_reg32:
possiblecpu=3;
razr=r32;
case tk_reg:
op66(razr);
if(short_ok(itok.number,TRUE))i=2; //<2F><><EFBFBD><EFBFBD><EFBFBD> <20><>
op(0x69+i);
op(0xc0+(unsigned int)hnumber+(unsigned int)hnumber*8);
if(i==2)op(itok.number);
else{
if(htok==tk_reg)outword(itok.number);
else outdword(itok.number);
}
break;
default: reg32regexpected(1);
}
break;
case tk_reg32:
razr=r32;
case tk_reg:
op66(razr);
possiblecpu=3;
if(htok!=tok)reg32regexpected(1);
outword(0xaf0f);
op(0xc0+(unsigned int)itok.number+(unsigned int)hnumber*8);
break;
case tk_longvar:
tok++;
case tk_dwordvar:
if(htok!=tk_reg32)reg32expected(1);
CheckAllMassiv(bufrm,4,&strinf);
razr=r32;
goto imul1;
case tk_intvar:
tok++;
case tk_wordvar:
imul1:
possiblecpu=3;
if(htok!=tk_reg&&(tok==tk_intvar||tok==tk_wordvar))regexpected(1);
CheckAllMassiv(bufrm,2,&strinf);
op66(razr);
outseg(&itok,3);
outword(0xaf0f);
op(itok.rm+hnumber*8);
outaddress(&itok);
break;
default: varexpected(2);
}
}
else{
int htok2=tok;
hstok=itok;
hbuf=bufrm;
hstr=strinf;
strinf.bufstr=NULL;
bufrm=NULL;
nextexpecting2(tk_camma);
if(tok!=tk_number)numexpected(3);
switch(htok2){
case tk_reg32:
possiblecpu=3;
razr=r32;
case tk_reg:
op66(razr);
if(htok!=htok2)reg32regexpected(2);
if(short_ok(itok.number,TRUE))i=2; //<2F><><EFBFBD><EFBFBD><EFBFBD> <20><>
op(0x69+i);
op(0xc0+(unsigned int)hstok.number+(unsigned int)hnumber*8);
if(i==2)op(itok.number);
else{
if(htok==tk_reg)outword(itok.number);
else outdword(itok.number);
}
break;
case tk_longvar:
tok++;
case tk_dwordvar:
possiblecpu=3;
if(htok!=tk_reg32)reg32expected(2);
CheckAllMassiv(hbuf,4,&hstr,&hstok);
razr=r32;
goto imul2;
case tk_intvar:
tok++;
case tk_wordvar:
imul2:
if(htok!=tk_reg&&(htok2==tk_intvar||htok2==tk_wordvar))regexpected(1);
CheckAllMassiv(hbuf,2,&hstr,&hstok);
op66(razr);
if(short_ok(itok.number,TRUE))i=2; //<2F><><EFBFBD><EFBFBD><EFBFBD> <20><>
outseg(&hstok,2);
op(0x69+i);
op(hstok.rm+hnumber*8);
outaddress(&hstok);
if(i==2)op(itok.number);
else{
if(htok==tk_reg)outword(itok.number);
else outdword(itok.number);
}
break;
default: varexpected(2);
}
}
}
break;
case a_in: //IN
ClearReg(AX);
nexttok();
if((tok==tk_reg||tok==tk_reg32)&&(unsigned int)itok.number==AX){
op66(tok==tk_reg?r16:r32);
if(tok==tk_reg32)possiblecpu=3;
nexttok();
expecting(tk_camma);
if(tok==tk_number){
op(0xE5);
asmparam=FALSE;
if((hnumber=doconstdwordmath())>255)bytedxexpected();
op(hnumber);
next = 0;
}
else if(tok==tk_reg&&(unsigned int)itok.number==DX)op(0xED);
else bytedxexpected();
}
else if(tok==tk_beg&&(unsigned int)itok.number==AL){
nexttok();
expecting(tk_camma);
if(tok==tk_number){
op(0xE4);
asmparam=FALSE;
if((hnumber=doconstdwordmath())>255)bytedxexpected();
op(hnumber);
next=0;
}
else if(tok==tk_reg&&(unsigned int)itok.number==DX)op(0xEC);
else bytedxexpected();
}
else axalexpected();
break;
case a_insb: //INSB
ClearReg(AX);
ClearReg(DI);
op(0x6C);
possiblecpu=2;
break;
case a_insw: //INSW
op66(r16);
possiblecpu=2;
goto insd;
break;
case a_insd: //INSD
op66(r32);
possiblecpu=3;
insd:
op(0x6D);
ClearReg(AX);
ClearReg(DI);
break;
case a_int: //INT
clearregstat();
nexttok();
if(tok==tk_number){
asmparam=FALSE;
htok=doconstlongmath();
if(htok==3)op(0xCC);
else{
op(0xCD);
op(htok);
}
next=0;
}
else numexpected();
break;
case a_into:
op(0xCE); //INTO
break;
case a_invd: //INVD
outword(0x080F);
possiblecpu=4;
break;
case a_invlpg: //INVLPG
nexttok();
switch(tok){
case tk_longvar:
case tk_dwordvar:
CheckAllMassiv(bufrm,4,&strinf);
goto invlgp;
case tk_intvar:
case tk_wordvar:
CheckAllMassiv(bufrm,2,&strinf);
invlgp:
outseg(&itok,3);
outword(0x010F);
op(itok.rm+0x38);
outaddress(&itok);
break;
case tk_undefofs:
strcpy(hstok.name,itok.name);
tok=tk_number;
case tk_number:
hnumber=doconstdwordmath();
outword(0x010f);
op((am32==FALSE?rm_d16:rm_d32)+0x38);
if(postnumflag&f_reloc)AddReloc();
if(htok==tk_undefofs)AddUndefOff(2,hstok.name);
if(am32)outdword(hnumber);
else outword(hnumber);
next=0;
break;
case tk_postnumber:
outword(0x010F);
op((am32==FALSE?rm_d16:rm_d32)+0x38);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(am32==FALSE)outword(itok.number); //<2F>뫮 0
outdword(itok.number);
break;
default:
varexpected(0); break;
}
possiblecpu=4;
break;
case a_iret:
#ifdef OPTVARCONST
ClearLVIC();
#endif
RestoreStack();
clearregstat();
op66(r16);
op(0xCF); //IRET
break;
case a_iretd:
#ifdef OPTVARCONST
ClearLVIC();
#endif
RestoreStack();
clearregstat();
op66(r32);
op(0xCF); //IRETD
break;
case a_jo:
case a_jno:
case a_jc:
case a_jnc:
case a_jz:
case a_jnz:
case a_jna:
case a_ja:
case a_js:
case a_jns:
case a_jp:
case a_jnp:
case a_jl:
case a_jnl:
case a_jng:
case a_jg:
RestoreStack();
asmshortjump((htok-a_jo)+0x70,(htok-a_jo)+0x80);
next=0;
break;
case a_jecxz: //JECXZ
RestoreStack();
op67(r32);
asmshortjump(0xE3,0);
next=0;
break;
case a_jcxz: //JCXZ
RestoreStack();
op67(r16);
asmshortjump(0xE3,0);
next=0;
break;
case a_jmp: //JMP
RestoreStack();
nexttok();
faradd=0;
lastcommand=tk_goto;
if(stricmp("FAR",itok.name)==0){
nexttok();
faradd=8;
}
else if(stricmp("NEAR",itok.name)==0)nexttok();
else if(stricmp("SHORT",itok.name)==0){ // case insensitive
nexttok();
next=(unsigned char)GOTO();
break;
}
next=gotol(faradd);
break;
case a_lahf:
ClearReg(AX);
op(0x9F); //LAHF
break;
case a_lar: //LAR
case a_lsl: //LSL
lar_lsl(htok-a_lar+2);
break;
case a_leave: //LEAVE
RestoreStack();
op(0xC9);
ClearReg(BP);
possiblecpu = 2;
break;
case a_lmsw:
protectinstr(1,0x30); //LMSW
break;
case a_loadall: // LOADALL 80286 only
outword(0x050F);
possiblecpu=2;
break;
case a_lodsb:
ClearReg(SI);
ClearReg(AX);
op(0xAC); //LODSB
break;
case a_lodsw:
op66(r16);
ClearReg(SI);
ClearReg(AX);
op(0xAD); //LODSW
break;
case a_lodsd:
op66(r32);
ClearReg(SI);
ClearReg(AX);
op(0xAD);
possiblecpu =3; //LODSD
break;
case a_lock:
op(0xF0); //LOCK
break;
case a_loop:
ConstToReg(0,CX,(am32+1)*2);
op67(r16);
asmshortjump(0xE2,0);
next=0;
break;
case a_loopd:
ConstToReg(0,CX,r32);
possiblecpu=3;
op67(r32);
asmshortjump(0xE2,0);
next=0;
break;
case a_loopz: //LOOPE LOOPZ
ClearReg(CX);
asmshortjump(0xE1,0);
next=0;
break;
case a_loopnz: //LOOPNZ LOOPNE
ClearReg(CX);
asmshortjump(0xE0,0);
next=0;
break;
case a_ltr:
protectinstr(0,0x18); //LTR
break;
case a_str:
protectinstr(0,0x08); //STR
break;
case a_lgdt:
next=tabldeckr(0x10);
break;
case a_lidt: //LIDT
next=tabldeckr(0x18);
break;
case a_lldt:
protectinstr(0,0x10); //LLDT
break;
case a_mov:
doasmmov();
next=0;
break;
case a_movsb:
movsb(); //MOVSB
break;
case a_movsd:
if(ScanTok3()==tk_camma&&(tok2==tk_xmmreg||(tok2>=tk_charvar&&tok2<tk_qwordvar))){
movxmm(0x10,0xf2);
possiblecpu=9;
}
else movsd(); //MOVSD
break;
case a_movsw:
movsw(); //MOVSW
break;
case a_movzx:
case a_movsx:
asmextend((htok-a_movzx)*8+0xB6);
break;
case a_movd:
movd(); //MOVD
break;
case a_movq:
movq(); //MOVQ
break;
case a_nop:
op(0x90); //NOP
break;
case a_opsiz: //OPSIZ OPSIZE
op(0x66);
possiblecpu=3;
break;
case a_out: //OUT
nexttok();
if(tok==tk_number){
if((hnumber=doconstdwordmath())>255)bytedxexpected();
expecting2(tk_camma);
if((tok==tk_reg||tok==tk_reg32)&&(unsigned int)itok.number==AX){
op66(tok==tk_reg?r16:r32);
if(tok==tk_reg32)possiblecpu=3;
op(0xE7); op(hnumber);
}
else if(tok==tk_beg&&(unsigned int)itok.number==AL){
op(0xE6); op(hnumber);
}
else axalexpected();
}
else if(tok==tk_reg&&(unsigned int)itok.number==DX){
nextexpecting2(tk_camma);
if((tok==tk_reg||tok==tk_reg32)&&(unsigned int)itok.number==AX){
op66(tok==tk_reg?r16:r32);
if(tok==tk_reg32)possiblecpu=3;
op(0xEF);
}
else if(tok==tk_beg&&(unsigned int)itok.number==AL)op(0xEE);
else axalexpected();
}
else bytedxexpected();
break;
case a_outsb: //OUTSB
ClearReg(SI);
op(0x6E);
possiblecpu=2;
break;
case a_outsw: //OUTSW
ClearReg(SI);
op66(r16);
op(0x6F);
possiblecpu=2;
break;
case a_outsd: //OUTSD
ClearReg(SI);
op66(r32);
op(0x6F);
possiblecpu=3;
break;
case a_pop: //POP
RestoreStack();
do{
possiblecpu=0;
asmparam=TRUE;
nexttok();
razr=r16;
switch(tok){
case tk_reg32:
possiblecpu=3;
razr=r32;
case tk_reg:
ClearReg(itok.number);
op66(razr);
op(0x58+(unsigned int)itok.number); break;
case tk_dwordvar:
tok--;
case tk_longvar:
CheckAllMassiv(bufrm,4,&strinf);
possiblecpu=3;
razr=r32;
goto pop;
case tk_wordvar:
tok--;
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
pop:
#ifdef OPTVARCONST
ClearVarByNum(&itok);
#endif
KillVar(itok.name);
op66(razr);
outseg(&itok,2);
op(0x8F); op(itok.rm);
outaddress(&itok);
break;
case tk_seg:
if(itok.number!=CS){
PopSeg((unsigned int)itok.number);
break;
}
default:
preerror("Invalid operand for POP");
break;
}
if(cpu<possiblecpu)cpu=possiblecpu;
asmparam=FALSE;
addESP-=razr==r16?2:4;
nexttok();
}while(tok==tk_camma);
next=0;
break;
case a_popa: //POPA
razr=r16;
possiblecpu=2;
goto POPAD;
case a_popad: //POPAD
razr=r32;
possiblecpu=3;
POPAD:
op66(razr);
addESP-=razr==r16?16:32;
RestoreStack();
clearregstat();
op(0x61);
break;
case a_popf:
razr=r16;
goto POPFD;
case a_popfd: //POPFD
razr=r32;
possiblecpu = 3;
POPFD:
op66(razr);
addESP-=razr==r16?2:4;
RestoreStack();
op(0x9D);
break;
case a_push: //PUSH
RestoreStack();
do{
asmparam=TRUE;
nexttok();
if((razr=Push())==FALSE)preerror("Invalid operand for PUSH");
asmparam=FALSE;
addESP+=razr==r16?2:4;
}while(tok==tk_camma);
next=0;
break;
case a_pusha: //PUSHA
razr=r16;
possiblecpu=2;
goto PUSHAD;
case a_pushad: //PUSHAD
razr=r32;
possiblecpu=3;
PUSHAD:
op66(razr);
addESP+=razr==r16?16:32;
RestoreStack();
op(0x60);
break;
case a_pushf:
razr=r16;
goto PUSHFD;
case a_pushfd: //PUSHFD
razr=r32;
possiblecpu=3;
PUSHFD:
op66(razr);
RestoreStack();
op(0x9C);
addESP+=razr==r16?2:4;
break;
case a_pcmpeqd:
case a_pcmpeqw:
case a_pcmpeqb:
case a_packssdw: //+xmm
case a_punpckhdq:
case a_punpckhwd:
case a_punpckhbw:
case a_packuswb: //+xmm
case a_pcmpgtd:
case a_pcmpgtw:
case a_pcmpgtb:
case a_packsswb: //+xmm
case a_punpckldq:
case a_punpcklwd:
case a_punpcklbw:
mmxiii(htok-a_punpcklbw+0x60);
break;
case a_pmullw:
mmxiii(0xD5); //PMULLW
break;
case a_pmuludq:
mmxiii(0xF4); //PMULUDQ
break;
case a_psubusb:
mmxiii(0xD8); //PSUBUSB
break;
case a_psubusw:
mmxiii(0xD9);//PSUBUSW
break;
case a_pand: //+xmm
mmxiii(0xDB); //PAND
break;
case a_paddusb: //+xmm
mmxiii(0xDC); //PADDUSB
break;
case a_paddusw: //+xmm
mmxiii(0xDD);//PADDUSW
break;
case a_pandn: //+xmm
mmxiii(0xDF);//PANDN
break;
case a_pause:
outword(0x90F3);
possiblecpu=9;
break;
case a_pmulhw:
mmxiii(0xE5); //PMULHW
break;
case a_psubsb:
mmxiii(0xE8); //PSUBSB
break;
case a_psubsw:
mmxiii(0xE9);//PSUBSW
break;
case a_por:
mmxiii(0xEB); //POR
break;
case a_paddsb: //+xmm
mmxiii(0xEC); //PADDSB
break;
case a_paddsw: //+xmm
mmxiii(0xED);//PADDSW
break;
case a_pxor:
mmxiii(0xEF); //PXOR
break;
case a_pmaddwd:
mmxiii(0xF5); //PMADDWD
break;
case a_psubb:
mmxiii(0xF8); //PSUBB
break;
case a_psubw:
mmxiii(0xF9);//PSUBW
break;
case a_psubd:
mmxiii(0xFA);//PSUBD
break;
case a_psubq:
mmxiii(0xFB);//PSUBQ
possiblecpu=9;
break;
case a_paddb: //+xmm
mmxiii(0xFC); //PADDB
break;
case a_paddw: //+xmm
mmxiii(0xFD);//PADDW
break;
case a_paddd: //+xmm
mmxiii(0xFE);//PADDD
break;
case a_paddq: //+xmm
mmxiii(0xD4);//PADDQ
possiblecpu=9;
break;
case a_psrlw:
packMMX(0xD1,0x71,0xd0); //PSRLW
next=0;
break;
case a_psrld:
packMMX(0xD2,0x72,0xd0);//PSRLD
next=0;
break;
case a_psrlq:
packMMX(0xD3,0x73,0xd0);//PSRLQ
next=0;
break;
case a_psraw:
packMMX(0xE1,0x71,0xe0); //PSRAW
next=0;
break;
case a_psrad:
packMMX(0xE2,0x72,0xe0);//PSRAD
next=0;
break;
case a_psllw:
packMMX(0xF1,0x71,0xf0); //PSLLW
next=0;
break;
case a_pslld:
packMMX(0xF2,0x72,0xf0);//PSLLD
next=0;
break;
case a_psllq:
packMMX(0xF3,0x73,0xf0);//PSLLQ
next=0;
break;
case a_pslldq:
shiftxmm(7);
next=0;
possiblecpu=9;
break;
case a_psrldq:
shiftxmm(3);
next=0;
possiblecpu=9;
break;
case a_rdmsr:
ClearReg(AX);
ClearReg(DX);
outword(0X320F);
possiblecpu=5;
break;
case a_rdtsc:
outword(0X310F);
possiblecpu=5;
break;
case a_rep:
op(0xF3);//REP REPE REPZ
ClearReg(CX);
break;
case a_repnz:
op(0xF2); //REPNE REPNZ
ClearReg(CX);
break;
case a_ret: //RET
#ifdef OPTVARCONST
ClearLVIC();
#endif
RestoreStack();
clearregstat();
next=0;
if(tok2==tk_number){
// usedirectiv=TRUE;
nexttok();
op(0xC2);
asmparam=FALSE;
outword((unsigned int)doconstlongmath());
// usedirectiv=FALSE;
}
else{
op(0xC3);
nexttok();
}
break;
case a_retf:
#ifdef OPTVARCONST
ClearLVIC();
#endif
RestoreStack();
clearregstat();
next=0;
if(tok2==tk_number){
nexttok();
op(0xCA);
asmparam=FALSE;
outword((unsigned int)doconstlongmath());
}
else{
op(0xCB);
nexttok();
}//RETF
break;
case a_rsm: //RSM
outword(0Xaa0F);
possiblecpu=5;
break;
case a_sahf:
op(0x9E); //SAHF
break;
case a_scasb:
op(0xAE); //SCASB
ClearReg(DI);
break;
case a_scasw:
op66(r16);
op(0xAF); //SCASW
ClearReg(DI);
break;
case a_scasd: //SCASD
op66(r32);
op(0xAF);
possiblecpu=3;
ClearReg(DI);
break;
case a_smsw:
protectinstr(1,0x20); //SMSW
break;
case a_stc:
op(0xF9); //STC
break;
case a_std:
op(0xFD); //STD
break;
case a_sti:
op(0xFB); //STI
break;
case a_stosb:
stosb(); //STOSB
break;
case a_stosw:
stosw(); //STOSW
break;
case a_stosd:
stosd(); //STOSD
break;
case a_seto:
case a_setno:
case a_setc:
case a_setnc:
case a_setz:
case a_setnz:
case a_setna:
case a_seta:
case a_sets:
case a_setns:
case a_setp:
case a_setnp:
case a_setl:
case a_setnl:
case a_setng:
case a_setg:
i=htok-a_seto;
nexttok();
switch(tok){
case tk_beg:
ClearReg(itok.number%4);
op(0xf);
op(0x90+i);
op(0xc0+(unsigned int)itok.number);
break;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,1,&strinf);
KillVar(itok.name);
outseg(&itok,3);
op(0xf);
op(0x90+i);
op(itok.rm);
outaddress(&itok);
break;
default: bytevalexpected(0);
}
possiblecpu=3;
break;
case a_sgdt:
next=tabldeckr(0);
break;
case a_sidt:
next=tabldeckr(0x8);
break;
case a_sldt:
protectinstr(0,0); //SLDT
break;
case a_fwait: //FWAIT
case a_wait:
fwait();//WAIT
break;
case a_wbinvd: //WBINVD
outword(0x090F);
possiblecpu=4;
break;
case a_wrmsr: //WRMSR
outword(0x300F);
possiblecpu=5;
break;
case a_xadd: //XADD
nexttok();
hstok=itok;
htok=tok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
switch(htok){
case tk_reg32:
razr=r32;
case tk_reg:
switch(tok){
case tk_reg32:
if(razr==r16)goto erxreg;
case tk_reg:
RegToReg(itok.number,hstok.number,razr);
ClearReg(hstok.number);
op66(razr);
outword(0xC10F);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_longvar:
case tk_dwordvar:
if(razr==r16)goto erxreg;
case tk_intvar:
case tk_wordvar:
KillVar(hstok.name);
/*if(bufrm==0&&strinf.bufstr==NULL)*/AddRegVar(hstok.number,razr,&itok);
CheckAllMassiv(bufrm,razr,&strinf);
op66(razr);
outseg(&itok,3);
outword(0xC10F);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default:
erxreg:
wordvalexpected(); break;
}
break;
case tk_beg:
switch(tok){
case tk_beg:
RegToReg(itok.number,hstok.number,r8);
ClearReg(hstok.number%4);
outword(0xC00F);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_charvar:
case tk_bytevar:
KillVar(hstok.name);
/*if(bufrm==0&&strinf.bufstr==NULL)*/AddRegVar(hstok.number,r8,&itok);
CheckAllMassiv(bufrm,1,&strinf);
outseg(&itok,3);
outword(0xC00F);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: bytevalexpected(2); break;
}
break;
case tk_charvar:
case tk_bytevar:
if(tok!=tk_beg)begexpected(2);
CheckAllMassiv(hbuf,1,&hstr,&hstok);
ClearReg(itok.number);
KillVar(hstok.name);
outseg(&hstok,3);
outword(0xC00F);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
case tk_longvar:
case tk_dwordvar:
if(tok!=tk_reg32)reg32expected(2);
razr=r32;
goto nointxadd;
case tk_intvar:
case tk_wordvar:
if(tok!=tk_reg)regexpected(1);
nointxadd:
CheckAllMassiv(hbuf,razr,&hstr,&hstok);
ClearReg(itok.number);
KillVar(hstok.name);
op66(razr);
outseg(&hstok,3);
outword(0xC10F);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
default: varexpected(1); break;
}
possiblecpu=4;
break;
case a_xchg: //XCHG
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
switch(htok){
case tk_reg32:
razr=r32;
possiblecpu=3;
case tk_reg:
switch(tok){
case tk_reg32:
if(razr==r16)goto erregx;
case tk_reg:
op66(razr);
RegSwapReg(hstok.number,itok.number,razr);
if(hstok.number==AX)op(0x90+(unsigned int)itok.number);
else if((unsigned int)itok.number==AX)op(0x90+hstok.number);
else{
op(0x87);
op(128+64+(unsigned int)itok.number*8+hstok.number);
}
break;
case tk_longvar:
case tk_dwordvar:
if(razr==r16)goto erregx;
case tk_intvar:
case tk_wordvar:
CheckAllMassiv(bufrm,razr,&strinf);
KillVar(itok.name);
IDZToReg(itok.name,hstok.number,razr);
op66(razr);
outseg(&itok,2);
op(0x87);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default:
erregx:
wordvalexpected(); break;
}
break;
case tk_beg:
switch(tok){
case tk_beg:
RegSwapReg(hstok.number,itok.number,r8);
op(0x86);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,1,&strinf);
KillVar(itok.name);
IDZToReg(itok.name,hstok.number,r8);
outseg(&itok,2);
op(0x86);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: bytevalexpected(2); break;
}
break;
case tk_charvar:
case tk_bytevar:
if(tok!=tk_beg)begexpected(2);
CheckAllMassiv(hbuf,1,&hstr,&hstok);
KillVar(hstok.name);
IDZToReg(hstok.name,itok.number,r8);
outseg(&hstok,2);
op(0x86);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
case tk_longvar:
case tk_dwordvar:
razr=r32;
possiblecpu=3;
if(tok!=tk_reg32)reg32expected(2);
goto nointx;
case tk_intvar:
case tk_wordvar:
if(tok!=tk_reg)regexpected(2);
nointx:
CheckAllMassiv(hbuf,razr,&hstr,&hstok);
KillVar(hstok.name);
IDZToReg(hstok.name,itok.number,razr);
op66(razr);
outseg(&hstok,2);
op(0x87);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
default: varexpected(1); break;
}
break;
case a_xlat:
ClearReg(AX);
op(0xD7); //XLAT
break;
case a_hlt:
op(0xF4); //HLT
break;
case a_verr:
protectinstr(0,0x20); //VERR
break;
case a_verw:
protectinstr(0,0x28); //VERW
break;
case a_test: //TEST
if(iTest()==FALSE)invalidoperand(0);
next=0;
break;
case a_fcom: //FCOM
FpuType1(0x10);
break;
case a_fcomp: //FCOMP
FpuType1(0x18);
break;
case a_fadd: //FADD
FpuType2(0,0);
break;
case a_fdiv: //FDIV
FpuType2(0x38,0x30);
break;
case a_fdivr: //FDIVR
FpuType2(0x30,0x38);
break;
case a_fmul: //FMUL
FpuType2(0x8,0x8);
break;
case a_fsub: //FSUB
FpuType2(0x28,0x20);
break;
case a_fsubr: //FSUBR
FpuType2(0x20,0x28);
break;
case a_faddp: //FADDP
FpuType3(0xDE,0);
break;
case a_fdivp: //FDIVP
FpuType3(0xDE,0x38);
break;
case a_fdivrp: //FDIVRP
FpuType3(0xDE,0x30);
break;
case a_ffree: //FFREE
FpuType3(0xDD,0);
break;
case a_fmulp: //FMULP
FpuType3(0xDE,8);
break;
case a_fsubp: //FSUBP
FpuType3(0xDE,0x28);
break;
case a_fsubrp: //FSUBRP
FpuType3(0xDE,0x20);
break;
case a_fucom: //FUCOM
FpuType3(0xDD,0x20);
break;
case a_fucomp: //FUCOMP
FpuType3(0xDD,0x28);
break;
case a_fxch: //FXCH
FpuType3(0xD9,8);
break;
case a_fiadd: //FIADD
FpuType4(0,0);
break;
case a_ficom: //FICOM
FpuType4(0,0x10);
break;
case a_ficomp: //FICOMP
FpuType4(0,0x18);
break;
case a_fidiv: //FIDIV
FpuType4(0,0x30);
break;
case a_fidivr: //FIDIVR
FpuType4(0,0x38);
break;
case a_fild: //FILD
FpuType4(1,0);
break;
case a_fimul: //FIMUL
FpuType4(0,8);
break;
case a_fist: //FIST
FpuType4(1,0x10);
break;
case a_fistp: //FISTP
FpuType4(1,0x18);
break;
case a_fisub: //FISUB
FpuType4(0,0x20);
break;
case a_fisubr: //FISUBR
FpuType4(0,0x28);
break;
case a_fld: //FLD
FpuType5(0xD9,0);
break;
case a_fst: //FST
FpuType5(0xDD,0x10);
break;
case a_fstp: //FSTP
FpuType5(0xDD,0x18);
break;
case a_fbld: //FBLD
FpuType6(0xDF,0X20);
break;
case a_fbstp: //FBSTP
FpuType6(0xDF,0X30);
break;
case a_fildq: //FILDQ
FpuType6(0xDF,0x28);
break;
case a_fldenv: //FLDENV <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
FpuType6(0xD9,0x20);
break;
case a_frstor: //FRSTOR <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
FpuType6(0xDD,0x20);
break;
case a_fsave: //FSAVE <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
fwait();
case a_fnsave: //FNSAVE <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
FpuType6(0xDD,0x30);
break;
case a_fstenv: //FSTENV <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
fwait();
case a_fnstenv: //FNSTENV <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
FpuType6(0xD9,0x30);
break;
case a_fldcw: //FLDCW
FpuType7(0x28);
break;
case a_fstcw: //FSTCW
fwait();
case a_fnstcw: //FNSTCW
FpuType7(0x38);
break;
case a_f2xm1:
outword(0xf0d9); //F2XM1
possiblecpu=2;
break;
case a_fabs:
outword(0xE1D9); //FABS
break;
case a_fchs:
outword(0xE0D9); //FCHS
break;
case a_fclex: //FCLEX
fwait();
// outword(0xE2DB);
// break;
case a_fnclex:
outword(0xE2DB); //FNCLEX
break;
case a_fcompp:
outword(0xD9DE); //FCOMPP
break;
case a_fcos: //FCOS
outword(0xFFD9);
possiblecpu=3;
break;
case a_fdecstr:
outword(0xF6D9); //FDECSTP
break;
case a_fdisi:
fwait();
case a_fndisi:
outword(0xE1DB); //FDISI
break;
case a_feni:
fwait();
case a_fneni:
outword(0xE0DB); //FENI
break;
case a_fincstr:
outword(0xF7D9); //FINCSTP
break;
case a_finit: //FINIT
fwait();
case a_fninit:
outword(0xE3DB); //FNINIT
break;
case a_fldlg2:
outword(0xECD9); //FLDLG2
break;
case a_fldln2:
outword(0xEDD9); //FLDLN2
break;
case a_fldl2e:
outword(0xEAD9); //FLDL2E
break;
case a_fldl2t:
outword(0xE9D9); //FLDL2T
break;
case a_fldpi:
outword(0xEBD9); //FLDPI
break;
case a_fldz:
outword(0xEED9); //FLDZ
break;
case a_fld1:
outword(0xE8D9); //FLD1
break;
case a_fnop:
outword(0xD0D9); //FNOP
break;
case a_fpatan:
outword(0xF3D9); //FPATAN
break;
case a_fprem:
outword(0xF8D9); //FPREM
break;
case a_fprem1:
outword(0xF5D9); //FPREM1
possiblecpu=3;
break;
case a_fptan:
outword(0xF2D9); //FPTAN
break;
case a_frndint:
outword(0xFCD9); //FRNDINT
break;
case a_fsetpm:
fwait();
case a_fnsetpm:
outword(0xE4DB); //FSETPM
possiblecpu=2;
break;
case a_fscale:
outword(0XFDD9); //FSCALE
break;
case a_fsin: //FSIN
outword(0xFED9);
possiblecpu=3;
break;
case a_fsincos: //FSINCOS
outword(0xFBD9);
possiblecpu=3;
break;
case a_fsqrt:
outword(0xFAD9); //FSQRT
break;
case a_fstsw: //FSTSW
fwait();
case a_fnstsw: //FNSTSW
nexttok();
switch(tok){
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
KillVar(itok.name);
outseg(&itok,2);
op(0xDD);
op(itok.rm+0x38);
outaddress(&itok);
break;
case tk_reg:
if(itok.number==0)outword(0xe0df);
else preerror("Use only AX");
ClearReg(AX);
break;
default: wordvalexpected();
}
break;
case a_ftst:
outword(0xE4D9); //FTST
break;
case a_fucompp: //FUCOMPP
outword(0xE9DA);
possiblecpu=3;
break;
case a_fxam:
outword(0xE5D9); //FXAM
break;
case a_fxtract:
outword(0xF4D9); //FXTRACT
break;
case a_fyl2x:
outword(0xF1D9); //FYL2X
break;
case a_fyl2xp1:
outword(0xF9D9); //FYL2XP1
break;
case a_ud2:
outword(0x0B0F); //UD2
possiblecpu=7;
break;
case a_sysenter:
outword(0x340F); //SYSENTER
possiblecpu=7;
break;
case a_sysexit:
outword(0x350F); //SYSEXIT
possiblecpu=7;
break;
case a_rdpmc:
outword(0x330F); //RDPMC
possiblecpu=7;
break;
case a_fcmovnu:
i+=8;
case a_fcmovnbe:
i+=8;
case a_fcmovne:
i+=8;
case a_fcmovnb:
FpuType8(0xDB,i);
break;
case a_fcmovu:
i+=8;
case a_fcmovbe:
i+=8;
case a_fcmove:
i+=8;
case a_fcmovb:
FpuType8(0xDA,i);
break;
case a_fcomi: //FCOMI
i+=8;
case a_fucomi:
FpuType8(0xDB,i+0x28);
break;
case a_fcomip:
i+=8;
case a_fucomip:
FpuType8(0xDF,i+0x28);
break;
case a_cmovo:
case a_cmovno:
case a_cmovc:
case a_cmovnc:
case a_cmovz:
case a_cmovnz:
case a_cmovna:
case a_cmova:
case a_cmovs:
case a_cmovns:
case a_cmovp:
case a_cmovnp:
case a_cmovl:
case a_cmovnl:
case a_cmovng:
case a_cmovg:
cmov(htok-a_cmovo);
possiblecpu=7;
break;
case a_lfence: //LFENCE
outword(0xAE0F);
op(0xE8);
possiblecpu=9;
break;
case a_mfence: //MFENCE
outword(0xAE0F);
op(0xF0);
possiblecpu=9;
break;
case a_sfence: //SFENCE
outword(0xAE0F);
op(0xF8);
possiblecpu=8;
break;
case a_maskmovq: //MASKMOVQ
nexttok();
hnumber=itok.number;
if(tok!=tk_mmxreg)mmxregexpected(1);
nextexpecting2(tk_camma);
if(tok!=tk_mmxreg)mmxregexpected(2);
outword(0xF70F);
op(0xC0+hnumber+itok.number*8);
possiblecpu=8;
break;
case a_movntq: //MOVNTQ
movxmm3(0xE7,0,tk_mmxreg);
possiblecpu=8;
break;
case a_pavgb:
mmxiii(0xE0);
break;
case a_pavgw:
mmxiii(0xE3);
break;
case a_pmaxub:
mmxiii(0xDE);
break;
case a_pmaxsw:
mmxiii(0xEE);
break;
case a_pminub:
mmxiii(0xDA);
break;
case a_pminsw:
mmxiii(0xEA);
break;
case a_pmulhuw:
mmxiii(0xE4);
break;
case a_psadbw:
mmxiii(0xF6);
break;
case a_prefetcht0:
prefetch(0x18,1);
possiblecpu=8;
break;
case a_prefetcht1:
prefetch(0x18,2);
possiblecpu=8;
break;
case a_prefetcht2:
prefetch(0x18,3);
possiblecpu=8;
break;
case a_prefetchnta:
prefetch(0x18,0);
possiblecpu=8;
break;
case a_pextrw:
pextrw();
next=0;
break;
case a_pinsrw:
pinsrw();
next=0;
break;
case a_pmovmskb:
nexttok();
if(tok!=tk_reg32)reg32expected(1);
htok=itok.number;
ClearReg(htok);
nextexpecting2(tk_camma);
if(tok==tk_xmmreg){
op(0x66);
possiblecpu=9;
}
else{
possiblecpu=8;
if(tok!=tk_mmxreg)mmxregexpected(2);
}
outword(0xD70F);
op(rm_mod11+htok*8+itok.number);
break;
case a_pshufw:
pshufw();
next=0;
possiblecpu=8;
break;
case a_pshufd:
xmm3instr(0x70,0x66);
possiblecpu=9;
next=0;
break;
case a_pshufhw:
xmm3instr(0x70,0xf3);
possiblecpu=9;
next=0;
break;
case a_pshuflw:
xmm3instr(0x70,0xf2);
possiblecpu=9;
next=0;
break;
case a_addpd:
xmminstr(0x58,0x66);
possiblecpu=9;
break;
case a_addps:
xmminstr(0x58,0);
possiblecpu=8;
break;
case a_addsd:
xmminstr(0x58,0xF2);
possiblecpu=9;
break;
case a_addss:
xmminstr(0x58,0xF3);
possiblecpu=8;
break;
case a_addsubpd:
xmminstr(0xD0,0x66);
possiblecpu=9;
break;
case a_addsubps:
xmminstr(0xD0,0xF2);
possiblecpu=9;
break;
case a_andnpd:
xmminstr(0x55,0x66);
possiblecpu=9;
break;
case a_andnps:
xmminstr(0x55,0);
possiblecpu=8;
break;
case a_andpd:
xmminstr(0x54,0x66);
possiblecpu=9;
break;
case a_andps:
xmminstr(0x54,0);
possiblecpu=8;
break;
case a_comisd:
xmminstr(0x2F,0x66);
possiblecpu=9;
break;
case a_comiss:
xmminstr(0x2F,0);
possiblecpu=8;
break;
case a_divps:
xmminstr(0x5E,0);
possiblecpu=8;
break;
case a_divsd:
xmminstr(0x5E,0xf2);
possiblecpu=9;
break;
case a_divss:
xmminstr(0x5E,0xF3);
possiblecpu=8;
break;
case a_haddpd:
xmminstr(0x7C,0x66);
possiblecpu=9;
break;
case a_haddps:
xmminstr(0x7C,0xF2);
possiblecpu=9;
break;
case a_hsubpd:
xmminstr(0x7D,0x66);
possiblecpu=9;
break;
case a_hsubps:
xmminstr(0x7D,0xF2);
possiblecpu=9;
break;
case a_maskmovdqu:
xmm2xmm(0xf7,0x66);
possiblecpu=9;
break;
case a_maxpd:
xmminstr(0x5f,0x66);
possiblecpu=9;
break;
case a_maxps:
xmminstr(0x5F,0);
possiblecpu=8;
break;
case a_maxsd:
xmminstr(0x5f,0xf2);
possiblecpu=9;
break;
case a_maxss:
xmminstr(0x5F,0xF3);
possiblecpu=8;
break;
case a_minpd:
xmminstr(0x5d,0x66);
possiblecpu=9;
break;
case a_minps:
xmminstr(0x5D,0);
possiblecpu=8;
break;
case a_minsd:
xmminstr(0x5d,0xf2);
possiblecpu=9;
break;
case a_minss:
xmminstr(0x5D,0xF3);
possiblecpu=8;
break;
case a_mulpd:
xmminstr(0x59,0x66);
possiblecpu=9;
break;
case a_mulps:
xmminstr(0x59,0);
possiblecpu=8;
break;
case a_mulsd:
xmminstr(0x59,0xF2);
possiblecpu=9;
break;
case a_mulss:
xmminstr(0x59,0xF3);
possiblecpu=8;
break;
case a_orpd:
xmminstr(0x56,0x66);
possiblecpu=9;
break;
case a_orps:
xmminstr(0x56,0);
possiblecpu=8;
break;
case a_rcpps:
xmminstr(0x53,0);
possiblecpu=8;
break;
case a_rcpss:
xmminstr(0x53,0xF3);
possiblecpu=8;
break;
case a_rsqrtps:
xmminstr(0x52,0);
possiblecpu=8;
break;
case a_rsqrtss:
xmminstr(0x52,0xF3);
possiblecpu=8;
break;
case a_sqrtpd:
xmminstr(0x51,0x66);
possiblecpu=9;
break;
case a_sqrtps:
xmminstr(0x51,0);
possiblecpu=8;
break;
case a_sqrtsd:
xmminstr(0x51,0xf2);
possiblecpu=9;
break;
case a_sqrtss:
xmminstr(0x51,0xF3);
possiblecpu=8;
break;
case a_subpd:
xmminstr(0x5C,0x66);
possiblecpu=9;
break;
case a_subps:
xmminstr(0x5C,0);
possiblecpu=8;
break;
case a_subsd:
xmminstr(0x5C,0xF2);
possiblecpu=9;
break;
case a_subss:
xmminstr(0x5C,0xF3);
possiblecpu=8;
break;
case a_ucomisd:
xmminstr(0x2E,0x66);
possiblecpu=9;
break;
case a_ucomiss:
xmminstr(0x2E,0);
possiblecpu=8;
break;
case a_unpckhpd:
xmminstr(0x15,0x66);
possiblecpu=9;
break;
case a_unpckhps:
xmminstr(0x15,0);
possiblecpu=8;
break;
case a_unpcklpd:
xmminstr(0x14,0x66);
possiblecpu=9;
break;
case a_unpcklps:
xmminstr(0x14,0);
possiblecpu=8;
break;
case a_xorpd:
xmminstr(0x57,0x66);
possiblecpu=9;
break;
case a_xorps:
xmminstr(0x57,0);
possiblecpu=8;
break;
case a_cmppd:
xmm3instr(0xC2,0x66);
possiblecpu=9;
next=0;
break;
case a_cmpeqpd:
case a_cmpltpd:
case a_cmplepd:
case a_cmpunordpd:
case a_cmpneqpd:
case a_cmpnltpd:
case a_cmpnlepd:
case a_cmpordpd:
xmminstr(0xC2,0x66);
possiblecpu=9;
op(htok-a_cmpeqpd);
break;
case a_cmpps:
xmm3instr(0xC2,0);
possiblecpu=8;
next=0;
break;
case a_cmpeqps:
case a_cmpltps:
case a_cmpleps:
case a_cmpunordps:
case a_cmpneqps:
case a_cmpnltps:
case a_cmpnleps:
case a_cmpordps:
xmminstr(0xC2,0);
possiblecpu=9;
op(htok-a_cmpeqps);
break;
case a_cmpss:
xmm3instr(0xC2,0xF3);
possiblecpu=8;
next=0;
break;
case a_cmpeqss:
case a_cmpltss:
case a_cmpless:
case a_cmpunordss:
case a_cmpneqss:
case a_cmpnltss:
case a_cmpnless:
case a_cmpordss:
xmminstr(0xC2,0xF3);
possiblecpu=9;
op(htok-a_cmpeqss);
break;
case a_cmpeqsd:
case a_cmpltsd:
case a_cmplesd:
case a_cmpunordsd:
case a_cmpneqsd:
case a_cmpnltsd:
case a_cmpnlesd:
case a_cmpordsd:
xmminstr(0xC2,0xF2);
op(htok-a_cmpeqsd);
possiblecpu=9;
break;
case a_shufpd:
xmm3instr(0xC6,0x66);
possiblecpu=9;
next=0;
break;
case a_shufps:
xmm3instr(0xC6,0);
possiblecpu=8;
next=0;
break;
case a_cvtdq2pd:
xmminstr(0xE6,0xF3);
possiblecpu=9;
break;
case a_cvtdq2ps:
xmminstr(0x5B,0);
possiblecpu=9;
break;
case a_cvtpd2dq:
xmminstr(0xE6,0xF2);
possiblecpu=9;
break;
case a_cvtpd2pi:
xmminstr(0x2d,0x66,tk_mmxreg,tk_xmmreg);
possiblecpu=9;
break;
case a_cvtpd2ps:
xmminstr(0x5a,0x66);
possiblecpu=9;
break;
case a_cvtpi2pd:
xmminstr(0x2a,0x66,tk_xmmreg,tk_mmxreg);
possiblecpu=9;
break;
case a_cvtpi2ps:
xmminstr(0x2a,0,tk_xmmreg,tk_mmxreg);
possiblecpu=8;
break;
case a_cvtps2dq:
xmminstr(0x5b,0x66);
possiblecpu=9;
break;
case a_cvtps2pd:
xmminstr(0x5a,0);
possiblecpu=9;
break;
case a_cvtsi2ss:
xmminstr(0x2a,0xf3,tk_xmmreg,tk_reg32);
possiblecpu=8;
break;
case a_cvtps2pi:
xmminstr(0x2d,0,tk_mmxreg,tk_xmmreg);
possiblecpu=9;
break;
case a_cvtsd2si:
xmminstr(0x2d,0xf2,tk_reg32,tk_xmmreg);
possiblecpu=9;
break;
case a_cvtsd2ss:
xmminstr(0x5a,0xf2);
possiblecpu=9;
break;
case a_cvtsi2sd:
xmminstr(0x2a,0xf2,tk_xmmreg,tk_reg32);
possiblecpu=9;
break;
case a_cvtss2sd:
xmminstr(0x5a,0xf3);
possiblecpu=9;
break;
case a_cvtss2si:
xmminstr(0x2d,0xf3,tk_reg32,tk_xmmreg);
possiblecpu=8;
break;
case a_cvttpd2pi:
xmminstr(0x2c,0x66,tk_mmxreg,tk_xmmreg);
possiblecpu=9;
break;
case a_cvttpd2dq:
xmminstr(0xE6,0x66);
possiblecpu=9;
break;
case a_cvttps2dq:
xmminstr(0x5B,0xF3);
possiblecpu=9;
break;
case a_cvttps2pi:
xmminstr(0x2c,0,tk_mmxreg,tk_xmmreg);
possiblecpu=8;
break;
case a_cvttsd2si:
xmminstr(0x2C,0xF2,tk_reg32,tk_xmmreg);
possiblecpu=9;
break;
case a_cvttss2si:
xmminstr(0x2C,0xF3,tk_reg32,tk_xmmreg);
possiblecpu=8;
break;
case a_divpd:
xmminstr(0x5E,0x66);
possiblecpu=9;
break;
case a_punpckhqdq:
xmminstr(0x6D,0x66);
possiblecpu=9;
break;
case a_punpcklqdq:
xmminstr(0x6C,0x66);
possiblecpu=9;
break;
case a_fxrstor:
prefetch(0xAE,1);
possiblecpu=8;
break;
case a_fxsave:
prefetch(0xAE,0);
possiblecpu=8;
break;
case a_ldmxcsr:
prefetch(0xAE,2);
possiblecpu=8;
break;
case a_stmxcsr:
prefetch(0xAE,3);
possiblecpu=8;
break;
case a_clflush:
prefetch(0xAE,7);
possiblecpu=9;
break;
case a_monitor:
outword(0x010F);
op(0xc8);
possiblecpu=9;
break;
case a_mwait:
outword(0x010F);
op(0xc9);
possiblecpu=9;
break;
case a_lddqu:
movxmm4(0xF0,0xF2);
possiblecpu=9;
break;
case a_movhlps:
xmm2xmm(0x12);
possiblecpu=8;
break;
case a_movlhps:
xmm2xmm(0x16);
possiblecpu=8;
break;
case a_movmskps:
xmm2xmm(0x50,0,tk_reg32);
possiblecpu=8;
break;
case a_movntdq:
movxmm3(0xE7,0x66);
possiblecpu=9;
break;
case a_movntpd:
movxmm3(0x2B,0x66);
possiblecpu=9;
break;
case a_movntps:
movxmm3(0x2b,0);
possiblecpu=8;
break;
case a_movapd:
movxmm(0x28,0x66);
possiblecpu=9;
break;
case a_movaps:
movxmm(0x28,0);
possiblecpu=8;
break;
case a_movdqa:
movxmm(0x6f,0x66,0x10);
possiblecpu=9;
break;
case a_movddup:
xmminstr(0x12,0xF2);
possiblecpu=9;
break;
case a_movshdup:
xmminstr(0x16,0xF3);
possiblecpu=9;
break;
case a_movsldup:
xmminstr(0x12,0xF3);
possiblecpu=9;
break;
case a_movdqu:
movxmm(0x6f,0xf3,0x10);
possiblecpu=9;
break;
case a_movdq2q:
xmm2xmm(0xd6,0xf2,tk_mmxreg);
possiblecpu=9;
break;
case a_movhpd:
movxmm2(0x16,0x66);
possiblecpu=9;
break;
case a_movlpd:
movxmm2(0x12,0x66);
possiblecpu=9;
break;
case a_movmskpd:
xmm2xmm(0x50,0x66,tk_reg32);
possiblecpu=9;
break;
case a_movnti: //MOVNTI
movxmm3(0xC3,0,tk_reg32);
possiblecpu=9;
break;
case a_movq2dq: //MOVQ2DQ
nexttok();
hnumber=itok.number;
if(tok!=tk_xmmreg)xmmregexpected(1);
nextexpecting2(tk_camma);
if(tok!=tk_mmxreg)mmxregexpected(2);
op(0xF3);
outword(0xD60F);
op(0xC0+hnumber+itok.number*8);
possiblecpu=9;
break;
case a_movupd:
movxmm(0x10,0x66);
possiblecpu=9;
break;
case a_movups:
movxmm(0x10,0);
possiblecpu=8;
break;
case a_movss:
movxmm(0x10,0xF3);
possiblecpu=8;
break;
case a_movhps:
movxmm2(0x16);
possiblecpu=8;
break;
case a_movlps:
movxmm2(0x12);
possiblecpu=8;
break;
case -1: codeexpected(); break;
default:
preerror("sorry, this instruction is not supported");
break;
}
asmparam=FALSE;
if(cpu<possiblecpu)cpu=possiblecpu;
if(next)nexttok();
}
else if(tok==tk_seg){
switch((unsigned int)itok.number){
case ES: op(0x26); break;
case SS: op(0x36); break;
case CS: op(0x2E); break;
case DS: op(0x3E); break;
case FS: op(0x64);
if(cpu<3)cpu=3;
break;
case GS: op(0x65);
if(cpu<3)cpu=3;
break;
default: beep(); break;
}
nextexpecting2(tk_colon);
}
else if(tok==tk_locallabel)define_locallabel();
else if(tok==tk_at&&ScanTok3()==tk_colon){
nexttok();
LLabel();
}
else codeexpected();
if(tok==tk_semicolon)nexttok();
}
void cmov(int num)
{
int type=r32;
int reg;
nexttok();
if(tok==tk_reg)type=r16;
else if(tok!=tk_reg32)reg32regexpected(1);
reg=itok.number;
ClearReg(reg);
nextexpecting2(tk_camma);
op66(type);
switch(tok){
case tk_reg:
if(type==r32)reg32expected(2);
goto regs;
case tk_reg32:
if(type==r16)regexpected(2);
regs:
op(0x0F);
op(0x40+num);
op(0xC0+reg*8+itok.number);
break;
case tk_wordvar:
case tk_intvar:
if(type==r32)dwordvalexpected();
CheckAllMassiv(bufrm,2,&strinf);
goto dwords;
case tk_dwordvar:
case tk_longvar:
if(type==r16)wordvalexpected();
CheckAllMassiv(bufrm,4,&strinf);
dwords:
outseg(&itok,3);
op(0x0F);
op(0x40+num);
op(itok.rm+reg*8);
outaddress(&itok);
break;
default:
varexpected(2);
break;
}
}
#ifdef OPTVARCONST
int GetOperand(int code)
{
switch(code){
case a_inc: //INC
case a_add: return tk_plus;
case a_or: return tk_or;
case a_and: return tk_and;
case a_dec: //DEC
case a_sub: return tk_minus;
case a_xor: return tk_xor;
case a_not: return tk_not;
case a_neg: return tk_numsign;
case a_shl: return tk_ll;
case a_shr: return tk_rr;
}
return tokens;
}
#endif
void asmtwo1(int basecode) // used for ADD ADC SUB SBB CMP AND OR XOR.
{
unsigned long holdnumber2;
int htok,typet=r16;
long longholdnumber;
char *hbuf;
ITOK hstok;
unsigned char next=1;
SINFO hstr;
#ifdef OPTVARCONST
int initconst=FALSE;
int operand=GetOperand(basecode/8);
#endif
nexttok();
hstok=itok;
htok=tok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
int i=tok;
switch(htok){
case tk_reg:
if((basecode/8)!=a_cmp)ClearReg(hstok.number);
switch(tok){
case tk_undefofs:
strcpy(hstok.name,itok.name);
tok=tk_number;
goto wnum;
case tk_minus:
if(tok2!=tk_number){
wordvalexpected();
break;
}
case tk_number:
wnum:
asmparam=FALSE;
holdnumber2=doconstlongmath();
next=0;
op66(r16);
if(hstok.number==AX){
op(4+1+basecode);
if((postnumflag&f_reloc)!=0)AddReloc();
if(i==tk_undefofs)AddUndefOff(2,hstok.name);
outword(holdnumber2);
}
else{
if((postnumflag&f_reloc)==0&&short_ok(holdnumber2)){
op(128+2+1);
op(128+64+hstok.number+basecode);
op(holdnumber2);
}
else{
op(128+1);
op(128+64+hstok.number+basecode);
if((postnumflag&f_reloc)!=0)AddReloc();
if(i==tk_undefofs)AddUndefOff(2,hstok.name);
outword(holdnumber2);
}
}
break;
case tk_postnumber:
op66(r16);
if(hstok.number==AX)op(4+1+basecode);
else{
op(128+1);
op(128+64+hstok.number+basecode);
}
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
outword((unsigned int)itok.number);
break;
case tk_reg:
op66(r16);
op(2+1+basecode);
op(128+64+(unsigned int)itok.number+hstok.number*8);
break;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
op66(r16);
outseg(&itok,2);
op(2+1+basecode);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: wordvalexpected(); break;
}
break;
case tk_reg32:
if((basecode/8)!=a_cmp)ClearReg(hstok.number);
switch(tok){
case tk_undefofs:
strcpy(hstok.name,itok.name);
tok=tk_number;
goto dnum;
case tk_minus:
i=tk_number;
if(tok2!=tk_number){
dwordvalexpected();
break;
}
case tk_number:
dnum:
op66(r32);
asmparam=FALSE;
longholdnumber=doconstdwordmath();
next=0;
if(i==tk_number&&(postnumflag&f_reloc)==0&&short_ok(longholdnumber,TRUE)){
op(128+2+1);
op(128+64+hstok.number+basecode);
op((int)longholdnumber);
}
else{
if(hstok.number==EAX)op(4+1+basecode);
else{
op(128+1);
op(128+64+hstok.number+basecode);
}
if((postnumflag&f_reloc)!=0)AddReloc();
if(i==tk_undefofs)AddUndefOff(2,hstok.name);
outdword(longholdnumber);
}
break;
case tk_postnumber:
op66(r32);
if(hstok.number==EAX)op(4+1+basecode);
else{
op(128+1);
op(128+64+hstok.number+basecode);
}
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
outdword(itok.number);
break;
case tk_reg32:
op66(r32);
op(2+1+basecode);
op(128+64+(unsigned int)itok.number+hstok.number*8);
break;
case tk_dwordvar:
case tk_longvar:
CheckAllMassiv(bufrm,4,&strinf);
op66(r32);
outseg(&itok,2);
op(2+1+basecode);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: dwordvalexpected(); break;
}
if(cpu<3)cpu=3;
break;
case tk_beg:
if((basecode/8)!=a_cmp)ClearReg(hstok.number>3?hstok.number-4:hstok.number);
switch(tok){
case tk_minus:
if(tok2!=tk_number){
bytevalexpected(2);
break;
}
case tk_number:
asmparam=FALSE;
holdnumber2=doconstlongmath();
next=0;
if(hstok.number==AL)op(4+basecode);
else{
op(128);
op(128+64+hstok.number+basecode);
}
op(holdnumber2);
break;
case tk_beg:
op(2+basecode);
op(128+64+(unsigned int)itok.number+hstok.number*8);
break;
case tk_bytevar:
case tk_charvar:
CheckAllMassiv(bufrm,1,&strinf);
outseg(&itok,2);
op(2+basecode);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: bytevalexpected(2); break;
}
break;
case tk_dwordvar:
case tk_longvar:
typet=r32;
if(cpu<3)cpu=3;
case tk_intvar:
case tk_wordvar:
if((basecode/8)!=a_cmp)KillVar(hstok.name);
CheckAllMassiv(hbuf,typet,&hstr,&hstok);
op66(typet);
outseg(&hstok,2);
switch(tok){
case tk_undefofs:
strcpy(hstok.name,itok.name);
tok=tk_number;
goto vnum;
case tk_minus:
if(tok2!=tk_number)goto erval;
case tk_number:
vnum:
asmparam=FALSE;
holdnumber2=doconstlongmath();
#ifdef OPTVARCONST
if(i==tk_number&&(postnumflag&f_reloc)==0){
initconst=UpdVarConst(&hstok,holdnumber2,tk_dword,operand);
}
#endif
next=0;
if(i!=tk_undefofs&&(postnumflag&f_reloc)==0&&short_ok(holdnumber2,typet/2-1)){
op(128+2+1);
op(hstok.rm+basecode);
outaddress(&hstok);
op(holdnumber2);
}
else{
op(128+1);
op(hstok.rm+basecode);
outaddress(&hstok);
if((postnumflag&f_reloc)!=0)AddReloc();
if(i==tk_undefofs)AddUndefOff(2,hstok.name);
if(typet==r16)outword(holdnumber2);
else outdword(holdnumber2);
}
break;
case tk_postnumber:
if(typet==r32)goto erval;
op(128+1);
op(hstok.rm+basecode);
outaddress(&hstok);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(typet==r16)outword(itok.number);
else outdword(itok.number);
break;
case tk_reg32:
if(typet==r16)goto erval;
case tk_reg:
op(1+basecode);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
default:
erval:
if(typet==r16)wordvalexpected();
else dwordvalexpected();
break;
}
#ifdef OPTVARCONST
if(initconst==FALSE)ClearVarByNum(&hstok);
#endif
break;
case tk_bytevar:
case tk_charvar:
if((basecode/8)!=a_cmp)KillVar(hstok.name);
CheckAllMassiv(hbuf,1,&hstr,&hstok);
switch(tok){
case tk_minus:
if(tok2!=tk_number){
bytevalexpected(2);
break;
}
case tk_number:
asmparam=FALSE;
holdnumber2=doconstlongmath();
#ifdef OPTVARCONST
if((postnumflag&f_reloc)==0){
initconst=UpdVarConst(&hstok,holdnumber2,tk_byte,operand);
}
#endif
next=0;
outseg(&hstok,2);
op(128);
op(hstok.rm+basecode);
outaddress(&hstok);
op(holdnumber2);
break;
case tk_beg:
outseg(&hstok,2);
op(basecode);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
default: bytevalexpected(2); break;
}
#ifdef OPTVARCONST
if(initconst==FALSE)ClearVarByNum(&hstok);
#endif
break;
default: varexpected(1); break;
}
if(next)nexttok();
}
int GOTO()
{
unsigned char next=1;
CheckIP();
#ifdef OPTVARCONST
ClearLVIC();
#endif
clearregstat();
switch(tok){
case tk_proc:
case tk_interruptproc:
if(itok.segm!=NOT_DYNAMIC){
idrec *ptr=itok.rec;
itok.segm=ptr->recsegm=DYNAMIC_USED;
itok.rm=tok=tk_undefofs; //ᬥ饭<E1ACA5><E9A5AD> <20><><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
goto undefproc;
}
jumploc(itok.number); //<2F><> <20><><EFBFBD><EFBFBD><E6A5A4><EFBFBD> <20><><EFBFBD><><E0A0AD><EFBFBD>
break;
case tk_number:
asmparam=FALSE;
jumploc(doconstlongmath());//<2F><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
next=0;
break;
case tk_ID:
addlocaljump(CALL_SHORT); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
outword(0x00EB); // JMP SHORT
break;
case tk_id:
tobedefined(CALL_SHORT,tk_void);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFA2AB><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
outword(0x00EB); // JMP SHORT
break;
case tk_declare:
tok=tk_undefproc;
updatetree();
case tk_locallabel:
case tk_undefproc: //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFA2AB><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
undefproc:
addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:CALL_SHORT));
outword(0x00EB); // JMP SHORT
break;
default: shortjumperror(); break;
}
return next;
}
unsigned char gotol(int faradd)
{
unsigned char next=1;
unsigned long hnumber;
unsigned int i=0;
CheckIP();
#ifdef OPTVARCONST
ClearLVIC();
#endif
clearregstat();
switch(tok){
case tk_declare:
if(tok2!=tk_openbracket){
tok=tk_undefproc;
updatetree();
}
case tk_locallabel:
case tk_undefproc:
if(tok2==tk_openbracket){
asmparam=FALSE;
if(doanyundefproc(TRUE)==tokens)next=0;
break;
}
if(faradd==0){
addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?JMP_NEAR:JMP_32)));
jumploc0();
} /* JMP num */
else invalidfarjumpitem();
break;
case tk_proc:
if(tok2==tk_openbracket){
doanyproc(TRUE);
break;
}
if(itok.segm!=NOT_DYNAMIC){
idrec *ptr=itok.rec;
itok.segm=ptr->recsegm=DYNAMIC_USED;
itok.rm=tok=tk_undefofs; //ᬥ饭<E1ACA5><E9A5AD> <20><><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
if(faradd==0){
addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?JMP_NEAR:JMP_32)));
jumploc0();
break;
} /* JMP num */
}
case tk_interruptproc:
if(faradd==0)jumploc(itok.number);
else invalidfarjumpitem();
break;
case tk_apiproc:
asmparam=FALSE;
if(tok2==tk_openbracket){
if(doanyundefproc(TRUE)==tokens)next=0;
}
else{
if(FastCallApi==TRUE){
outword(0x25ff);
AddApiToPost(itok.number);
}
else{
addacall(itok.number,(unsigned char)CALL_32);
jumploc0();
}
}
break;
case tk_minus:
if(tok2!=tk_number)goto err;
case tk_number:
asmparam=FALSE;
hnumber=doconstdwordmath();
if(faradd==0)jumploc(hnumber);
else{
op(0xEA);
expecting2(tk_colon);
int htok=tok;
char name[IDLENGTH];
if(tok==tk_undefofs){
tok=tk_number;
strcpy(name,itok.name);
}
unsigned long tempi=doconstdwordmath();
if(postnumflag&f_reloc)AddReloc();
if(htok==tk_undefofs)AddUndefOff(2,name);
if(am32==FALSE)outword((unsigned int)tempi);
else outdword(tempi);
outword((unsigned int)hnumber);
}
next=0;
break; /* JMP num */
case tk_postnumber:
if(faradd==0){
op(0xE9);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(am32==FALSE)outword((unsigned int)itok.number);
else outdword(itok.number);
}
else invalidfarjumpitem();
break;
case tk_reg32:
op66(r32);
goto jmpreg;
case tk_reg:
op66(r16);
jmpreg:
if(faradd==0){
op(0xFF);
op(0xE0+(unsigned int)itok.number);
} /* JMP reg */
else invalidfarjumpitem();
break;
case tk_ID:
if(faradd==0){
addlocaljump(am32==FALSE?JMP_NEAR:JMP_32);
jumploc0();
} /* JMP num */
else invalidfarjumpitem();
break;
case tk_id:
if(faradd==0){
tobedefined(am32==FALSE?JMP_NEAR:JMP_32,tk_void);
jumploc0();
} /* JMP num */
else invalidfarjumpitem();
break;
case tk_dwordvar:
case tk_longvar:
i=2;
case tk_intvar:
case tk_wordvar:
i+=2;
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,2);
op(0xFF); op(0x20+itok.rm+(faradd==0?(i==4&&am32==0?8:0):8));
outaddress(&itok);
break;
default:
err:
preerror("Invalid item for JMP");
break;
}
return next;
}
void asmregmem(int out1,int out2) // used for LEA LDS LES LFS LGS LSS.
{
int holdreg;
nexttok();
op66(tok==tk_reg?r16:r32);
if(tok!=tk_reg32&&tok!=tk_reg)reg32regexpected(1);
holdreg=(unsigned int)itok.number;
ClearReg(itok.number);
nextexpecting2(tk_camma);
switch(tok){
case tk_intvar:
case tk_wordvar:
case tk_charvar:
case tk_bytevar:
case tk_longvar:
case tk_dwordvar:
break;
default: varexpected(2);
}
CheckAllMassiv(bufrm,2,&strinf);
if(out2==0)outseg(&itok,2);
else outseg(&itok,3);
op(out1);
if(out2!=0)op(out2);
op(itok.rm+holdreg*8);
outaddress(&itok);
}
void Scanbit(int basecode)
{
unsigned long hnumber;
int htok,typet=r16;
nexttok();
hnumber=itok.number;
ClearReg(itok.number);
htok=tok;
nextexpecting2(tk_camma);
switch(htok){
case tk_reg32:
typet=r32;
if(tok==tk_reg||tok==tk_wordvar||tok==tk_intvar)goto erval;
case tk_reg:
switch(tok){
case tk_reg32:
if(typet==r16)goto erval;
case tk_reg:
op66(typet);
op(0xf);
op(basecode);
op(0xc0+(unsigned int)itok.number+hnumber*8);
break;
case tk_dwordvar:
case tk_longvar:
if(typet==r16)goto erval;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,typet,&strinf);
op66(typet);
outseg(&itok,3);
op(0xf);
op(basecode);
op(itok.rm+hnumber*8);
outaddress(&itok);
break;
default:
erval:
if(typet==r16)wordvalexpected();
else dwordvalexpected();
break;
}
break;
default: reg32regexpected(1);
}
if(cpu<3)cpu=3;
}
void CheckBit(int code)
{
unsigned long holdnumber2;
int htok;
ITOK hstok;
unsigned char next=1;
char *hbuf;
SINFO hstr;
nexttok();
hstok=itok;
htok=tok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
switch(htok){
case tk_reg32:
case tk_reg:
op66(htok==tk_reg?r16:r32);
if(code)ClearReg(hstok.number);
switch(tok){
case tk_number:
asmparam=FALSE;
holdnumber2=doconstlongmath();
next=0;
outword(0xba0f);
op(0xe0+code+hstok.number);
op(holdnumber2);
break;
case tk_reg32:
if(tok!=htok){
dwordvalexpected();
break;
}
case tk_reg:
if(tok!=htok)wordvalexpected();
op(0xf);
op(0xa3+code);
op(0xc0+hstok.number+(unsigned int)itok.number*8);
break;
default: wordvalexpected(); break;
}
break;
case tk_intvar:
case tk_wordvar:
CheckAllMassiv(hbuf,2,&hstr,&hstok);
if(code)KillVar(hstok.name);
op66(r16);
switch(tok){
case tk_number:
varc:
asmparam=FALSE;
holdnumber2=doconstlongmath();
next=0;
outseg(&hstok,3);
outword(0xba0f);
op(hstok.rm+code+0x20);
outaddress(&hstok);
op(holdnumber2);
break;
case tk_reg:
varreg:
outseg(&hstok,3);
op(0xf);
op(0xa3+code);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
break;
default: wordvalexpected(); break;
}
#ifdef OPTVARCONST
if(code)ClearVarByNum(&hstok);
#endif
break;
case tk_dwordvar:
case tk_longvar:
CheckAllMassiv(hbuf,4,&hstr,&hstok);
if(code)KillVar(hstok.name);
op66(r32);
if(tok==tk_number)goto varc;
if(tok==tk_reg32)goto varreg;
dwordvalexpected();
break;
default: varexpected(1);
}
if(cpu<3)cpu=3;
if(next)nexttok();
}
void asmone1(int basecode) // used for INC and DEC.
{
int razr=r16;
#ifdef OPTVARCONST
int operand=GetOperand(basecode/8+a_inc);
#endif
nexttok();
switch(tok){
case tk_reg32:
if(cpu<3)cpu=3;
razr=r32;
case tk_reg:
ClearReg(itok.number);
op66(razr);
op(64+basecode+(unsigned int)itok.number);
break;
case tk_beg:
ClearReg(itok.number);
op(254); op(128+64+basecode+(unsigned int)itok.number);
break;
case tk_charvar:
case tk_bytevar:
#ifdef OPTVARCONST
UpdVarConst(&itok,1,tk_byte,operand);
#endif
CheckAllMassiv(bufrm,1,&strinf);
KillVar(itok.name);
outseg(&itok,2);
op(254);
op(itok.rm+basecode);
outaddress(&itok);
break;
case tk_longvar:
case tk_dwordvar:
CheckAllMassiv(bufrm,4,&strinf);
if(cpu<3)cpu=3;
razr=r32;
goto dec;
case tk_intvar:
case tk_wordvar:
CheckAllMassiv(bufrm,2,&strinf);
dec:
#ifdef OPTVARCONST
UpdVarConst(&itok,1,tk_dword,operand);
#endif
KillVar(itok.name);
op66(razr);
outseg(&itok,2);
op(255);
op(itok.rm+basecode);
outaddress(&itok);
break;
default: varexpected(0); break;
}
}
void asmone2(int basecode) // used for NEG NOT MUL IMUL DIV IDIV.
{
int razr=r16;
#ifdef OPTVARCONST
int operand=GetOperand((basecode-16)/8+a_not);
#endif
nexttok();
switch(tok){
case tk_reg32:
if(cpu<3)cpu=3;
razr=r32;
case tk_reg:
ClearReg(itok.number);
op66(razr);
op(246+1); op(128+64+basecode+(unsigned int)itok.number); break;
case tk_beg:
ClearReg(itok.number);
op(246); op(128+64+basecode+(unsigned int)itok.number); break;
razr=r8;
case tk_charvar:
case tk_bytevar:
#ifdef OPTVARCONST
UpdVarConst(&itok,0,tk_dword,operand);
#endif
CheckAllMassiv(bufrm,1,&strinf);
KillVar(itok.name);
outseg(&itok,2);
op(246);
op(itok.rm+basecode);
outaddress(&itok);
razr=r8;
break;
case tk_longvar:
case tk_dwordvar:
CheckAllMassiv(bufrm,4,&strinf);
if(cpu<3)cpu=3;
razr=r32;
goto neg;
case tk_intvar:
case tk_wordvar:
CheckAllMassiv(bufrm,2,&strinf);
neg:
#ifdef OPTVARCONST
UpdVarConst(&itok,0,tk_dword,operand);
#endif
KillVar(itok.name);
op66(razr);
outseg(&itok,2);
op(247);
op(itok.rm+basecode);
outaddress(&itok);
break;
default: varexpected(0); break;
}
if(basecode!=16&&basecode!=24){
ClearReg(AX);
if(razr!=r8)ClearReg(DX);
}
}
void asmshortjump(int shortcode,int nearcode)
{
unsigned char next=1,shortjump=1;
unsigned int address;
#ifdef OPTVARCONST
ClearLVIC();
#endif
nexttok();
if(stricmp("FAR",itok.name)==0){ // case insensitive
preerror("FAR jump not available for this instruction");
nexttok();
}
else if(stricmp("NEAR",itok.name)==0){ // case insensitive
shortjump=0;
nexttok();
}
else if(stricmp("SHORT",itok.name)==0)nexttok(); // case insensitive
if(shortjump){
CheckIP();
switch(tok){
case tk_proc:
*(unsigned int *)&itok.number-=outptr+2;
if(short_ok(itok.number)){
op(shortcode);
op((unsigned int)itok.number);
}
else shortjumptoolarge();
break;
case tk_number:
asmparam=FALSE;
address=doconstdwordmath()-(outptr+2);
if(short_ok(address)){
op(shortcode);
op(address);
}
else shortjumptoolarge();
next=0;
break;
case tk_ID:
addlocaljump(CALL_SHORT);
op(shortcode); op(0x00); /* JXX SHORT */
break;
case tk_id:
tobedefined(CALL_SHORT,tk_void);
op(shortcode); op(0x00); /* JXX SHORT */
break;
case tk_declare:
tok=tk_undefproc;
updatetree();
case tk_locallabel:
case tk_undefproc:
addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:CALL_SHORT));
op(shortcode); op(0x00); /* JXX SHORT */
break;
default: shortjumperror(); break;
}
}
else if(nearcode!=0){
unsigned long numlong;
asmparam=FALSE;
switch(tok){
case tk_proc:
op(0xF); op(nearcode);
numlong=itok.number-outptr-2;
if(am32==FALSE)outword((unsigned int)numlong);
else outdword(numlong-2);
break;
case tk_number:
op(0xF); op(nearcode);
numlong=doconstdwordmath()-outptr-2;
if(am32==FALSE)outword((unsigned int)numlong);
else outdword(numlong-2);
next=0;
break;
case tk_undefofs: // ???? 32 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <><E0A5A6>
op(0xF); op(nearcode);
AddUndefOff(2,itok.name);
outword(-(int)(outptr-2));
if(am32!=FALSE)outword(0x0000);
break;
case tk_postnumber:
op(0xF); op(nearcode);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
numlong=itok.number-outptr-2;
if(am32==FALSE)outword((unsigned int)numlong);
else outdword(numlong-2);
break;
case tk_ID:
op(0xF); // must go before tobedefined()
addlocaljump(am32==FALSE?CALL_NEAR:CALL_32);
op(nearcode); outword(0x0000); /* JXX NEAR */
if(am32!=FALSE)outword(0x0000);
break;
case tk_id:
op(0xF); // must go before tobedefined()
tobedefined(am32==FALSE?CALL_NEAR:CALL_32,tk_void);
op(nearcode); outword(0x0000); /* JXX NEAR */
if(am32!=FALSE)outword(0x0000);
break;
case tk_declare:
tok=tk_undefproc;
updatetree();
case tk_locallabel:
case tk_undefproc:
op(0xF); // must go before addacall()
addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?CALL_NEAR:CALL_32)));
op(nearcode); outword(0x0000); /* JXX NEAR */
if(am32!=FALSE)outword(0x0000);
break;
default: preerror("Invalid operand for NEAR jump"); break;
}
if(cpu<3)cpu=3;
}
else preerror("NEAR jump not available for this instruction");
if(next)nexttok();
}
void lar_lsl(int code)
{
unsigned char possiblecpu=0;
int razr=r16;
nexttok();
if(tok!=tk_reg&&tok!=tk_reg32)reg32regexpected(1);
int htok=tok;
int hnumber=(unsigned int)itok.number;
ClearReg(itok.number);
nextexpecting2(tk_camma);
switch(tok){
case tk_reg32:
if(htok==tk_reg)reg32expected(1);
possiblecpu=3;
razr=r32;
goto lar;
case tk_reg:
if(htok==tk_reg32)regexpected(1);
possiblecpu=2;
lar:
op66(razr);
op(0x0f);
op(code);
op(0xc0+(unsigned int)itok.number+hnumber*8);
break;
case tk_longvar:
case tk_dwordvar:
if(htok==tk_reg)reg32expected(1);
CheckAllMassiv(bufrm,4,&strinf);
possiblecpu=3;
razr=r32;
goto lar1;
case tk_intvar:
case tk_wordvar:
if(htok==tk_reg32)regexpected(1);
possiblecpu=2;
CheckAllMassiv(bufrm,2,&strinf);
lar1:
op66(razr);
outseg(&itok,3);
op(0x0f);
op(code);
op(itok.rm+hnumber*8);
outaddress(&itok);
break;
default: invalidoperand(2); break;
}
if(possiblecpu>cpu)cpu=possiblecpu;
}
unsigned char tabldeckr(int code)
{
unsigned int i=0;
int htok;
unsigned char next=1;
char name[IDLENGTH];
nexttok();
htok=tok;
KillVar(itok.name);
switch(tok){
case tk_longvar:
case tk_dwordvar:
i=2;
case tk_intvar:
case tk_wordvar:
i++;
case tk_charvar:
case tk_bytevar:
i++;
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,3);
outword(0x010f);
op(itok.rm+code);
outaddress(&itok);
break;
case tk_undefofs:
strcpy(name,itok.name);
tok=tk_number;
case tk_number:
i=doconstdwordmath();
outword(0x010f);
op((am32==FALSE?rm_d16:rm_d32)+code);
if(postnumflag&f_reloc)AddReloc();
if(htok==tk_undefofs)AddUndefOff(2,name);
if(am32)outdword(i);
else outword(i);
next=0;
break;
default: varexpected(0);
}
if(cpu<2)cpu=2;
return next;
}
void protectinstr(int code,int code2)
{
int i=0;
nexttok();
switch(tok){
case tk_longvar:
case tk_dwordvar:
i=2;
case tk_intvar:
case tk_wordvar:
i++;
case tk_charvar:
case tk_bytevar:
i++;
#ifdef OPTVARCONST
ClearVarByNum(&itok);
#endif
CheckAllMassiv(bufrm,i,&strinf);
KillVar(itok.name);
outseg(&itok,3);
op(0x0f);
op(code);
op(itok.rm+code2);
outaddress(&itok);
break;
case tk_reg32:
case tk_reg:
ClearReg(itok.number);
op(0x0f);
op(code);
op(0xc0+code2+(unsigned int)itok.number);
break;
default: wordvalexpected();
}
if(cpu<2)cpu=2;
}
void doasmmov() // do MOV
{
unsigned char next=1,possiblecpu=0;
int htok,typet;
ITOK hstok;
char *hbuf;
SINFO hstr;
#ifdef OPTVARCONST
int initconst=FALSE;
#endif
nexttok();
hstok=itok;
htok=tok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
typet=r16;
int i=tok;
switch(htok){
case tk_reg32:
possiblecpu=3;
typet=r32;
case tk_reg:
switch(tok){
case tk_debugreg:
ClearReg(hstok.number);
if(typet==r16)goto erreg;
outword(0x210F);
op(128+64+(unsigned int)itok.number*8+hstok.number);
possiblecpu=4;
if((unsigned int)itok.number<=DR3||(unsigned int)itok.number==DR6
||(unsigned int)itok.number==DR7)possiblecpu=3;
break;
case tk_controlreg:
ClearReg(hstok.number);
if(typet==r16)goto erreg;
outword(0x200F);
op(128+64+(unsigned int)itok.number*8+hstok.number);
possiblecpu=4;
if((unsigned int)itok.number<=CR3)possiblecpu=3;
break;
case tk_testreg:
ClearReg(hstok.number);
if(typet==r16)goto erreg;
outword(0x240F);
op(128+64+(unsigned int)itok.number*8+hstok.number);
possiblecpu=4;
if((unsigned int)itok.number==TR6||(unsigned int)itok.number==TR7)possiblecpu=3;
break;
case tk_reg32:
if(typet==r16)goto erreg;
case tk_reg:
RegToReg(hstok.number,itok.number,typet);
op66(typet);
op(0x89);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_undefofs:
strcpy(hstok.name,itok.name);
tok=tk_number;
goto wnum;
case tk_minus:
if(tok2!=tk_number){
wordvalexpected();
break;
}
case tk_number:
wnum:
op66(typet);
op(0xB8+hstok.number);
ClearReg(hstok.number);
asmparam=FALSE;
SaveNumber(typet,i,hstok.name);
next=0;
break;
case tk_postnumber:
ClearReg(hstok.number);
op66(typet);
op(0xB8+hstok.number);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(typet==r32)outdword(itok.number);
else outword((unsigned int)itok.number);
break;
case tk_dwordvar:
case tk_longvar:
if(typet==r16)goto erreg;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,typet,&strinf);
IDZToReg(itok.name,hstok.number,typet);
op66(typet);
if(hstok.number==0&&((itok.rm==rm_d16&&itok.sib==CODE16)||(itok.rm==rm_d32&&(itok.sib==CODE32||itok.sib==0)))){
outseg(&itok,1);
op(0xA1);
}
else{
outseg(&itok,2);
op(0x8B);
op(itok.rm+hstok.number*8);
}
outaddress(&itok);
break;
case tk_seg:
if(typet==r32)goto erreg;
IDZToReg(itok.name,hstok.number,typet);
op66(r16);
op(0x8C);
op(128+64+(unsigned int)itok.number*8+hstok.number);
if((unsigned int)itok.number==FS||(unsigned int)itok.number==GS)possiblecpu=3;
break;
default:
erreg:
invalidoperand(2); break;
}
break;
case tk_beg:
ClearReg(hstok.number%4);
switch(tok){
case tk_beg:
op(0x88);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_number:
op(0xB0+hstok.number);
asmparam=FALSE;
op((int)doconstlongmath());
next=0;
break;
case tk_bytevar:
case tk_charvar:
CheckAllMassiv(bufrm,1,&strinf);
if(hstok.number==0&&((itok.rm==rm_d16&&itok.sib==CODE16)||(itok.rm==rm_d32&&(itok.sib==CODE32||itok.sib==0)))){
outseg(&itok,1);
op(0xA0);
}
else{
outseg(&itok,2);
op(0x8A);
op(itok.rm+hstok.number*8);
}
outaddress(&itok);
break;
default: invalidoperand(2); break;
}
break;
case tk_seg:
if(hstok.number==CS){
invalidoperand(1); break;
}
switch(tok){
case tk_reg:
op66(r16);
op(0x8E);
op(128+64+hstok.number*8+(unsigned int)itok.number);
if(hstok.number==FS||hstok.number==GS)possiblecpu=3;
break;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
op66(r16);
outseg(&itok,2);
op(0x8E);
op(itok.rm+hstok.number*8);
outaddress(&itok);
if(hstok.number==FS||hstok.number==GS)possiblecpu=3;
break;
default: invalidoperand(2); break;
}
break;
case tk_dwordvar:
case tk_longvar:
possiblecpu=3;
typet=r32;
case tk_wordvar:
case tk_intvar:
KillVar(itok.name);
CheckAllMassiv(hbuf,typet,&hstr,&hstok);
op66(typet);
switch(tok){
case tk_reg32:
if(typet==r16)goto ervar;
case tk_reg:
/*if((tok==tk_reg||tok==tk_reg32)&&hbuf==NULL&&hstr.bufstr==NULL)*/
AddRegVar(itok.number,typet,&hstok);
if(itok.number==0&&((hstok.rm==rm_d16&&hstok.sib==CODE16)||(hstok.rm==rm_d32&&(hstok.sib==CODE32||hstok.sib==0)))){
outseg(&hstok,1);
op(0xA3);
outaddress(&hstok);
}
else{
outseg(&hstok,2);
op(0x89);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
}
break;
case tk_undefofs:
strcpy(hstok.name,itok.name);
tok=tk_number;
goto vnum;
case tk_minus:
if(tok2!=tk_number){
wordvalexpected();
break;
}
case tk_number:
vnum:
outseg(&hstok,2);
op(0xC7);
op(hstok.rm);
outaddress(&hstok);
asmparam=FALSE;
#ifdef OPTVARCONST
unsigned long t;
t=SaveNumber(typet,i,hstok.name);
if(typet==r16)t&=0xffff;
else t&=0xffffffff;
if((i==tk_number||i==tk_minus)&&(postnumflag&f_reloc)){
Const2Var(&hstok,t,tk_dword);
initconst=TRUE;
}
#else
SaveNumber(typet,i,hstok.name);
#endif
next=0;
break;
case tk_postnumber:
outseg(&hstok,2);
op(0xC7);
op(hstok.rm);
outaddress(&hstok);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(typet==r16)outword((unsigned int)itok.number);
else outdword(itok.number);
break;
case tk_seg:
outseg(&hstok,2);
if(typet==r32)goto ervar;
op(0x8C);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
if(hstok.number==FS||hstok.number==GS)possiblecpu=3;
break;
default:
ervar:
invalidoperand(2); break;
}
#ifdef OPTVARCONST
if(initconst==FALSE)ClearVarByNum(&hstok);
#endif
break;
case tk_charvar:
case tk_bytevar:
KillVar(itok.name);
CheckAllMassiv(hbuf,1,&hstr,&hstok);
switch(tok){
case tk_beg:
/*if(tok==tk_beg&&hbuf==NULL&&hstr.bufstr==NULL)*/
AddRegVar(itok.number,r8,&hstok);
if(itok.number==0&&((hstok.rm==rm_d16&&hstok.sib==CODE16)||(hstok.rm==rm_d32&&(hstok.sib==CODE32||hstok.sib==0)))){
outseg(&hstok,1);
op(0xA2);
outaddress(&hstok);
}
else{
outseg(&hstok,2);
op(0x88);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
}
break;
case tk_number:
outseg(&hstok,2);
op(0xC6);
op(hstok.rm);
outaddress(&hstok);
asmparam=FALSE;
#ifdef OPTVARCONST
long t;
t=doconstlongmath()&0xff;
op(t);
if((postnumflag&f_reloc)){
initconst=TRUE;
Const2Var(&hstok,t,tk_byte);
}
#else
op((int)doconstlongmath());
#endif
next=0;
break;
default: invalidoperand(2); break;
}
#ifdef OPTVARCONST
if(initconst==FALSE)ClearVarByNum(&hstok);
#endif
break;
case tk_debugreg:
if(tok==tk_reg32){
outword(0x230F);
op(128+64+hstok.number*8+(unsigned int)itok.number);
possiblecpu=4;
if(hstok.number<=DR3||hstok.number==DR6||hstok.number==DR7)possiblecpu=3;
}
else invalidoperand(2);
break;
case tk_controlreg:
if(tok==tk_reg32){
outword(0x220F);
op(128+64+hstok.number*8+(unsigned int)itok.number);
possiblecpu=4;
if(hstok.number<=CR3)possiblecpu=3;
}
else invalidoperand(2);
break;
case tk_testreg:
if(tok==tk_reg32){
outword(0x260F);
op(128+64+hstok.number*8+(unsigned int)itok.number);
possiblecpu=4;
if(hstok.number==TR6||hstok.number==TR7)possiblecpu=3;
}
else invalidoperand(2);
break;
default: invalidoperand(1); break;
}
asmparam=FALSE;
if(possiblecpu>cpu)cpu=possiblecpu;
if(next)nexttok();
}
void asmextend(int basecode) // procedure MOVSX and MOVZX
{
int regnum;
int razr=r16;
nexttok();
if(tok==tk_reg32)razr=r32;
if(tok!=tk_reg32&&tok!=tk_reg)reg32regexpected(1);
regnum=(unsigned int)itok.number*8;
ClearReg(itok.number);
nextexpecting2(tk_camma);
switch(tok){
case tk_reg:
op66(razr);
op(0xF); op(basecode|1);
op(128+64+regnum+(unsigned int)itok.number);
break;
case tk_beg:
op66(razr);
op(0xF); op(basecode);
op(128+64+regnum+(unsigned int)itok.number);
break;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
op66(razr);
outseg(&itok,3);
op(0xF); op(basecode|1);
op(itok.rm+regnum);
outaddress(&itok);
break;
case tk_bytevar:
case tk_charvar:
CheckAllMassiv(bufrm,1,&strinf);
op66(razr);
outseg(&itok,3);
op(0xF); op(basecode);
op(itok.rm+regnum);
outaddress(&itok);
break;
default: varexpected(2); break;
}
if(cpu<3)cpu=3;
}
void movd()
{
ITOK hstok;
int htok;
char *hbuf;
SINFO hstr;
int i=0;
nexttok();
hstok=itok;
htok=tok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok==tk_xmmreg)i++;
switch(htok){
case tk_reg32:
ClearReg(hstok.number);
if(tok==tk_mmxreg||i){ //MOVD EAX,MM0
if(i)op(0x66);
outword(0x7E0F);
op(0xc0+hstok.number+(unsigned int)itok.number*8);
}
else mmxregexpected(2);
break;
case tk_dwordvar:
case tk_longvar:
if(tok==tk_mmxreg||i){ //MOVD mem,MM0
#ifdef OPTVARCONST
ClearVarByNum(&hstok);
#endif
CheckAllMassiv(hbuf,4,&hstr,&hstok);
KillVar(hstok.name);
outseg(&hstok,i==0?3:4);
if(i)op(0x66);
outword(0x7E0F);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
}
else mmxregexpected(2);
break;
case tk_xmmreg:
i++;
case tk_mmxreg:
switch(tok){
case tk_reg32: //MOVD MM0,EAX
if(i)op(0x66);
outword(0x6E0F);
op(0xc0+hstok.number*8+(unsigned int)itok.number);
break;
case tk_dwordvar: //MOVD MMO,mem
case tk_longvar:
CheckAllMassiv(bufrm,4,&strinf);
outseg(&itok,i==0?3:4);
if(i)op(0x66);
outword(0x6E0F);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: dwordvalexpected();
}
break;
default: mmxregordwordexpected(1);
}
if(cpu<6)cpu=6;
if(i&&cpu<9)cpu=9;
}
void movq()
{
int htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
int i=1,xmm=0;
nexttok();
hstok=itok;
htok=tok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok==tk_xmmreg)xmm++;
switch(htok){
case tk_qwordvar:
case tk_doublevar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
if(tok==tk_mmxreg||xmm){ //MOVQ mem,MM0
#ifdef OPTVARCONST
ClearVarByNum(&hstok);
#endif
KillVar(hstok.name);
CheckAllMassiv(hbuf,i,&hstr,&hstok);
outseg(&hstok,xmm==0?3:4);
if(xmm){
op(0x66);
outword(0xD60f);
}
else outword(0x7F0F);
op(hstok.rm+(unsigned int)itok.number*8);
outaddress(&hstok);
}
else mmxregexpected(2);
break;
case tk_mmxreg:
switch(tok){
case tk_mmxreg: //MOVQ MM0,MM1
outword(0x6F0F);
op(0xc0+hstok.number*8+(unsigned int)itok.number);
break;
case tk_qwordvar:
case tk_doublevar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,3);
outword(0x6F0F);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default: mmxregordwordexpected(2);
}
break;
case tk_xmmreg:
switch(tok){
case tk_xmmreg:
op(0xF3);
outword(0x7e0F);
op(0xc0+hstok.number*8+(unsigned int)itok.number);
break;
case tk_qwordvar:
case tk_doublevar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,4);
op(0xF3);
outword(0x7E0F);
op(itok.rm+hstok.number*8);
outaddress(&itok);
xmm++;
break;
default: xmmregorvarexpected(2);
}
break;
default: mmxregordwordexpected(1);
}
if(cpu<6)cpu=6;
if(xmm&&cpu<9)cpu=9;
}
void packMMX(int code,int code1,int code2)
{
unsigned int hnumber;
int htok,next=TRUE;
int i=1;
int xmm=FALSE;
nexttok();
hnumber=(unsigned int)itok.number;
htok=tok;
nextexpecting2(tk_camma);
if(htok==tk_xmmreg)xmm=TRUE;
else if(htok!=tk_mmxreg)mmxregexpected(1);
switch(tok){
case tk_mmxreg:
if(xmm)xmmregexpected(2);
op(0x0f);
op(code);
op(0xc0+hnumber*8+(unsigned int)itok.number);
break;
case tk_xmmreg:
if(!xmm)mmxregexpected(2);
else op(0x66);
op(0x0f);
op(code);
op(0xc0+hnumber*8+(unsigned int)itok.number);
break;
case tk_number:
if(xmm)op(0x66);
op(0x0f);
op(code1);
op(code2+hnumber);
asmparam=FALSE;
op((unsigned int)doconstlongmath());
next=FALSE;
break;
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,xmm==FALSE?3:4);
if(xmm)op(0x66);
op(0x0f);
op(code);
op(itok.rm+hnumber*8);
outaddress(&itok);
break;
default:
mmxregordwordexpected(2);
break;
}
if(cpu<6)cpu=6;
if(xmm&&cpu<9)cpu=9;
if(next==TRUE)nexttok();
}
void asmshift(int basecode) // used for ROL ROR RCL RCR SHL SAL SHR SAR.
{
int htok,precode;
unsigned char holdbyte;
int usenumsh=TRUE;
ITOK hstok;
char *hbuf;
char next=1;
SINFO hstr;
int razr=r16;
#ifdef OPTVARCONST
int operand=GetOperand(basecode/8+a_rol);
#endif
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok==tk_beg&&(unsigned int)itok.number==CL){
precode=0xD2;
usenumsh=FALSE;
}
else if(tok==tk_number){
asmparam=FALSE;
holdbyte=(unsigned char)doconstlongmath();
if(holdbyte==1){
precode=0xD0;
usenumsh=FALSE;
}
else /*if(holdbyte!=0)*/{
precode=0xC0;
if(cpu<2)cpu=2;
}
next=0;
}
else clornumberexpected();
// if(precode!=0){
switch(htok){
case tk_reg32:
if(cpu<3)cpu=3;
razr=r32;
case tk_reg:
ClearReg(hstok.number);
op66(razr);
op(precode+1); op(128+64+basecode+hstok.number);
break;
case tk_beg:
ClearReg(hstok.number);
op(precode); op(128+64+basecode+hstok.number);
break;
case tk_charvar:
case tk_bytevar:
#ifdef OPTVARCONST
if(precode==0xD0||precode==0xc0)UpdVarConst(&hstok,holdbyte,tk_byte,operand);
else ClearVarByNum(&hstok);
#endif
CheckAllMassiv(hbuf,1,&hstr,&hstok);
KillVar(hstok.name);
outseg(&hstok,2);
op(precode);
op(hstok.rm+basecode);
outaddress(&hstok);
break;
case tk_dwordvar:
case tk_longvar:
CheckAllMassiv(hbuf,4,&hstr,&hstok);
if(cpu<3)cpu=3;
razr=r32;
goto rol;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(hbuf,2,&hstr,&hstok);
rol:
#ifdef OPTVARCONST
if(precode==0xD0||precode==0xc0)UpdVarConst(&hstok,holdbyte,tk_byte,operand);
else ClearVarByNum(&hstok);
#endif
KillVar(hstok.name);
op66(razr);
outseg(&hstok,2);
op(precode+1);
op(hstok.rm+basecode);
outaddress(&hstok);
break;
default: varexpected(1); break;
}
if(usenumsh)op(holdbyte);
if(next)nexttok();
}
void CheckCl(int code)
{
op(0xf);
if(tok==tk_beg){
if(itok.number==CL)code++;
else clornumberexpected();
}
else if(tok!=tk_number)clornumberexpected();
op(code);
}
void Shxd(int code)
{
unsigned int h2number;
int htok,h2tok;
ITOK hstok;
char *hbuf;
unsigned char next=1;
SINFO hstr;
nexttok();
hstok=itok;
htok=tok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
h2number=(unsigned int)itok.number;
ClearReg(itok.number);
h2tok=tok;
nextexpecting2(tk_camma);
switch(htok){
case tk_reg:
if(h2tok==tk_reg){
op66(r16);
regreg:
ClearReg(hstok.number);
CheckCl(code);
op(0xc0+hstok.number+(unsigned int)h2number*8);
if(tok==tk_number){
asmparam=FALSE;
op(doconstlongmath());
next=0;
}
}
else regexpected(2);
break;
case tk_reg32:
if(h2tok==tk_reg32){
op66(r32);
goto regreg;
}
else reg32expected(2);
break;
case tk_intvar:
case tk_wordvar:
if(h2tok==tk_reg){
CheckAllMassiv(hbuf,2,&hstr,&hstok);
op66(r16);
varreg:
#ifdef OPTVARCONST
ClearVarByNum(&hstok);
#endif
KillVar(hstok.name);
outseg(&hstok,3);
CheckCl(code);
op(hstok.rm+h2number*8);
outaddress(&hstok);
if(tok==tk_number){
asmparam=FALSE;
op(doconstlongmath());
next=0;
}
}
else regexpected(2);
break;
case tk_dwordvar:
case tk_longvar:
if(h2tok==tk_reg32){
CheckAllMassiv(hbuf,4,&hstr,&hstok);
op66(r32);
goto varreg;
}
else reg32expected(2);
break;
default: valueexpected();
}
if(cpu<3)cpu=3;
if(next)nexttok();
}
void FpuType1(unsigned int addrm)
{
int opcode=0xd8;
int oscan=scanlexmode;
scanlexmode=ASMLEX;
nexttok();
retoldscanmode(oscan);
if(tok==tk_endline||tok==tk_semicolon){
op(0xD8);
op(0xC1+addrm);
return;
}
if(tok==tk_double){
opcode=0xdc;
nexttok();
}
switch(tok){
case tk_fpust:
op(0xD8);
op(0xC0+(unsigned int)itok.number+addrm);
break;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
CheckAllMassiv(bufrm,4,&strinf);
outseg(&itok,2);
op(opcode);
op(itok.rm+addrm);
outaddress(&itok);
break;
case tk_doublevar:
CheckAllMassiv(bufrm,8,&strinf);
outseg(&itok,2);
op(0xDC);
op(itok.rm+addrm);
outaddress(&itok);
break;
default: fpuvarexpected(0);
}
}
void FpuType2(unsigned int addrm,unsigned int addrm2)
{
long hnum;
int opcode=0xd8;
int oscan=scanlexmode;
scanlexmode=ASMLEX;
nexttok();
retoldscanmode(oscan);
if(tok==tk_endline||tok==tk_semicolon){
op(0xDE);
op(0xC1+addrm);
return;
}
if(tok==tk_double){
opcode=0xdc;
nexttok();
}
switch(tok){
case tk_fpust:
hnum=itok.number;
nextexpecting2(tk_camma);
if(hnum==0){
if(tok==tk_fpust){
op(0xD8);
op(0xC0+addrm2+(unsigned int)itok.number);
}
else fpustakexpected(2);
}
else{
if(tok==tk_fpust){
if(itok.number!=0)fpu0expected();
op(0xDC);
op(0xC0+(unsigned int)hnum+addrm);
}
else fpustakexpected(2);
}
break;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
CheckAllMassiv(bufrm,4,&strinf);
outseg(&itok,2);
op(opcode);
op(addrm2+itok.rm);
outaddress(&itok);
break;
case tk_doublevar:
CheckAllMassiv(bufrm,8,&strinf);
outseg(&itok,2);
op(0xDC);
op(addrm2+itok.rm);
outaddress(&itok);
break;
default: fpuvarexpected(1);
}
}
void FpuType3(unsigned int opcode,unsigned int addrm)
{
int oscan=scanlexmode;
scanlexmode=ASMLEX;
nexttok();
// scanlexmode=oscan;
retoldscanmode(oscan);
if((tok==tk_endline||tok==tk_semicolon)&&opcode!=0xDD){
op(opcode);
op(0xC1+addrm);
}
else if(tok==tk_fpust){
op(opcode);
op(0xC0+(unsigned int)itok.number+addrm);
}
else fpustakexpected(1);
if(opcode==0xDE&&tok2==tk_camma){
nexttok();
nexttok();
if(tok!=tk_fpust||itok.number!=0)fpu0expected();
}
}
void FpuType4(unsigned int opcode,unsigned int addrm)
{
nexttok();
if(opcode==1&&(addrm==0x18||addrm==0)&&tok==tk_qwordvar){
if(addrm==0)addrm=0x28;
else addrm=0x38;
CheckAllMassiv(bufrm,8,&strinf);
KillVar(itok.name);
outseg(&itok,2);
op(0xDF);
op(itok.rm+addrm);
outaddress(&itok);
return;
}
switch(tok){
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
KillVar(itok.name);
outseg(&itok,2);
op(0xDE + opcode);
op(itok.rm+addrm);
outaddress(&itok);
break;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
CheckAllMassiv(bufrm,4,&strinf);
KillVar(itok.name);
outseg(&itok,2);
op(0xDA+opcode);
op(itok.rm+addrm);
outaddress(&itok);
break;
default: fpuvarexpected(0);
}
}
void FpuType5(unsigned int opcode,unsigned int addrm)
{
int opc=0xd9;
int i=4;
nexttok();
if(tok==tk_qword||tok==tk_double){
nexttok();
tok=tk_qwordvar;
}
else if((strcmp(itok.name,"tbyte")==0||strcmp(itok.name,"ldouble")==0)&&addrm!=0x10){
opc=0xdb;
i=10;
if(addrm==0)addrm=40;
else addrm=56;
nexttok();
if(tok>=tk_charvar&&tok<=tk_wordvar)tok=tk_dwordvar;
}
switch(tok){
case tk_fpust:
op(opcode);
op(0xC0+(unsigned int)itok.number+addrm);
break;
case tk_qwordvar:
case tk_doublevar:
opc=0xdd;
i=8;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
CheckAllMassiv(bufrm,i,&strinf);
if(opcode!=0xD9)KillVar(itok.name);
outseg(&itok,2);
op(opc);
op(itok.rm+addrm);
outaddress(&itok);
break;
default: fpuvarexpected(0);
}
}
void FpuType6(unsigned int opcode,unsigned int addrm)
{
int i=0;
nexttok();
if(opcode==0xDF){
if(tok==tk_qword){
nexttok();
tok=tk_qwordvar;
}
if(strcmp(itok.name,"tbyte")==0){
i=2;
nexttok();
tok=tk_qwordvar;
}
}
switch(tok){
case tk_qwordvar:
if(opcode!=0xDF)wordvalexpected();
i=+4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i+=2;
CheckAllMassiv(bufrm,i,&strinf);
KillVar(itok.name);
outseg(&itok,2);
op(opcode);
op(itok.rm+addrm);
outaddress(&itok);
break;
default: wordvalexpected();
}
}
void FpuType7(unsigned int addrm)
{
nexttok();
switch(tok){
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
if(addrm!=0x28)KillVar(itok.name);
outseg(&itok,2);
op(0xD9);
op(itok.rm+addrm);
outaddress(&itok);
break;
default: wordvalexpected();
}
}
void FpuType8(unsigned int opcode,unsigned int addrm)
{
nexttok();
if(tok==tk_fpust&&itok.number==0&&tok2==tk_camma){
nexttok();
nexttok();
}
if(tok==tk_fpust){
op(opcode);
op(0xC0+(unsigned int)itok.number+addrm);
if(cpu<7)cpu=7;
}
else fpustakexpected(1);
}
/* ***************** start of some quick codes ****************** */
int short_ok(long thenumber,int reg32)
{
if(reg32==TRUE){
if(thenumber<=SHORTMAX&&thenumber>=SHORTMIN)return(1);
}
else{
if((short)thenumber<=SHORTMAX&&(short)thenumber>=SHORTMIN)return(1);
}
return(0);
}
void cbw()
{
if(optimizespeed&&(chip==5||chip==6)){
outdword(0xFCC0C488); //mov ah,al sar AH,7
op(7);
}
else{
op66(r16);
op(0x98);
}
ClearReg(AX);
}
void stosb()
{
op(0xAA);
ClearReg(DI);
}
void stosw()
{
op66(r16);
op(0xAB);
ClearReg(DI);
}
void stosd()
{
op66(r32);
op(0xAB);
if(cpu<3)cpu=3;
ClearReg(DI);
}
void movsb()
{
op(0xA4);
ClearReg(DI);
ClearReg(SI);
}
void movsw()
{
op66(r16);
op(0xA5);
ClearReg(DI);
ClearReg(SI);
}
void movsd()
{
op66(r32);
op(0xA5);
if(cpu<3)cpu=3;
ClearReg(DI);
ClearReg(SI);
}
void pushds() /* produce PUSH DS */
{
RestoreStack();
op(0x1E);
}
void pushss()
{
RestoreStack();
op(0x16); /* PUSH SS */
}
void popes() /* produce POP ES */
{
RestoreStack();
op(0x07);
}
void ret() /* produce RET */
{
RestoreStack();
op(0xC3);
}
void retf() /* produce RETF */
{
RestoreStack();
op(0xCB);
}
void jumploc(long loc) /* produce JUMP # */
{
loc=loc-outptr-3;
if(loc>-130&&loc<127){
loc++;
op(0xEB);
op(loc);
if(loc==0)notunreach=TRUE;
}
else{
if(am32==FALSE){
op(0xE9);
outword(loc);
}
else{
if(!optimizespeed&&(loc>126&&loc<65533)){
outword(0xE966);
outword(loc-1);
}
else{
op(0xE9);
outdword(loc-2);
}
}
}
}
void callloc(long loc) /* produce CALL # */
{
loc=loc-outptr-3;
op(0xE8);
if(am32==FALSE) outword(loc);
else outdword(loc-2);
}
void xorAHAH() /* produce XOR AH,AH */
{
outword(0xE430);
ConstToReg(0,AH,r8);
}
void xorAXAX() /* produce XOR AX,AX */
{
op66(r16);
outword(0xC031);
ConstToReg(0,AX,r16);
}
void xorEAXEAX() /* produce XOR EAX,EAX */
{
op66(r32);
outword(0xC031);
if(cpu<3)cpu=3;
ConstToReg(0,AX,r32);
}
void ZeroReg(int reg, int razr)
{
op66(razr);
op(0x31);
op(0xc0+9*reg); //xor reg,reg
ConstToReg(0,reg,razr);
}
void fwait()
{
op(0x9B);
}
void cwdq(int razr)
{
op66(razr);
if(optimizespeed&&(chip==5||chip==6)){
outword(0xC289); //mov dx,ax
op66(razr);
outword(0xFAC1); //sar dx,15
op(razr==r16?15:31);
}
else op(0x99);
ClearReg(DX);
}
void nextexpecting2(int want)
{
nexttok();
expecting2(want);
}
void expecting2(int want)
{
if(want!=tok)SwTok(want);
nexttok();
}
void CheckIP()
{
if(tok==tk_dollar){
tok=tk_number;
itok.number=outptr;
}
}
void jumploc0()
{
op(0xE9);
outword(0); /* the large jump */
if(am32!=FALSE)outword(0);
}
void callloc0()
{
op(0xE8);
outword(0);
if(am32!=FALSE)outword(0);
}
void Leave()
{
if((optimizespeed&&chip>3&&chip<7)||chip==0){
outword(0xEC89); // MOV SP,BP
op(0x5D);
}
else op(0xC9);
}
void tobedefined(int callkind,int expectedreturn)
{
// strcpy(itok.name,(char *)string);
string[0]=0;
itok.flag=(unsigned char)(tok==tk_ID?tp_fastcall:(comfile==file_w32?tp_stdcall:tp_pascal));
tok=tk_undefproc;
itok.number=secondcallnum;
itok.segm=NOT_DYNAMIC;
itok.rm=expectedreturn;
itok.post=0;
addtotree(itok.name);
addacall(secondcallnum++,(unsigned char)callkind);
}
void addlocaljump(int callkind)
{
addlocalvar((char *)string,tk_locallabel,secondcallnum,TRUE);
addacall(secondcallnum++,(char)callkind);
}
unsigned long SaveNumber(int type,int tok4,char *name)
{
unsigned long t=doconstdwordmath();
if(tok4==tk_undefofs)AddUndefOff(0,name);
else if((postnumflag&f_reloc)!=0)AddReloc();
if(type==r16)outword((unsigned int)t);
else outdword(t);
return t;
}
void Swap2tok(int *tok4, ITOK *itok4, char **buf4, SINFO *strinf4, int *tok6,
ITOK *itok6, char **buf6, SINFO *strinf6)
{
int htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
htok=*tok4;
*tok4=*tok6;
*tok6=htok;
hstok=*itok4;
*itok4=*itok6;
*itok6=hstok;
hbuf=*buf4;
*buf4=*buf6;
*buf6=hbuf;
hstr=*strinf4;
*strinf4=*strinf6;
*strinf6=hstr;
}
int iTest(int mode)
{
int htok,i;
ITOK hstok;
char *hbuf;
SINFO hstr;
unsigned char possiblecpu=0,next=1;
unsigned long num;
asmparam=TRUE;
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
if(tok==tk_number)hstok.number=doconstlongmath();
else nexttok();
expecting2(tk_camma);
i=r16;
// printf("tok=%d itok.number=%u bufrm=%s htok=%d hstok.number=%u nbuf=%s\n",
// tok,itok.number,bufrm,htok,hstok.number,hbuf);
if(htok==tk_number||htok==tk_postnumber)Swap2tok(&tok,&itok,&bufrm,&strinf,
&htok,&hstok,&hbuf,&hstr);
// printf("tok=%d itok.number=%u bufrm=%s htok=%d hstok.number=%u nbuf=%s\n",
// tok,itok.number,bufrm,htok,hstok.number,hbuf);
switch(htok){
case tk_reg32:
i=r32;
possiblecpu=3;
case tk_reg:
switch(tok){
case tk_reg32:
if(i==r16){
reg32expected(1);
return FALSE;
}
op66(i);
op(0x85);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_reg:
if(i==r32){
reg32expected(2);
return FALSE;
}
op66(i);
op(0x85);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_number:
asmparam=FALSE;
num=doconstdwordmath();
if(mode){
if(num<256&&hstok.number<4)goto testal;
if(num<65536)i=r16;
}
op66(i);
if(hstok.number==AX)op(0xA9);
else{
op(0xF7);
op(128+64+hstok.number);
}
if(i==r16)outword((unsigned int)num);
else outdword(num);
next=0;
break;
case tk_postnumber:
if(i==r32)return FALSE;
op66(r16);
if(hstok.number==AX)op(0xA9);
else{
op(0xF7);
op(128+64+hstok.number);
}
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
outword(itok.number); //<2F>뫮 0
break;
case tk_dwordvar:
case tk_longvar:
if(i==r16){
reg32expected(1);
return FALSE;
}
CheckAllMassiv(bufrm,i,&strinf);
op66(i);
outseg(&itok,2);
op(0x85);
op(hstok.number*8+itok.rm);
outaddress(&itok);
break;
case tk_wordvar:
case tk_intvar:
if(i==r32){
regexpected(1);
return FALSE;
}
CheckAllMassiv(bufrm,i,&strinf);
op66(i);
outseg(&itok,2);
op(0x85);
op(hstok.number*8+itok.rm);
outaddress(&itok);
break;
default: return FALSE;
}
break;
case tk_beg:
switch(tok){
case tk_beg:
op(0x84);
op(128+64+(unsigned int)itok.number*8+hstok.number);
break;
case tk_number:
asmparam=FALSE;
num=doconstdwordmath();
testal:
if(hstok.number==AL)op(0xA8);
else{
op(0xF6);
op(128+64+hstok.number);
}
op(num);
next=0;
break;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,1,&strinf);
outseg(&itok,2);
op(0x84);
op(hstok.number*8+itok.rm);
outaddress(&itok);
break;
default: return FALSE;
}
break;
case tk_dwordvar:
case tk_longvar:
i=r32;
possiblecpu=3;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(hbuf,i,&hstr,&hstok);
switch(tok){
case tk_reg32:
if(i==r16){
regexpected(2);
return FALSE;
}
op66(i);
outseg(&hstok,2);
op(0x85);
op((unsigned int)itok.number*8+hstok.rm);
outaddress(&hstok);
break;
case tk_reg:
if(i==r32){
reg32expected(2);
return FALSE;
}
op66(i);
outseg(&hstok,2);
op(0x85);
op((unsigned int)itok.number*8+hstok.rm);
outaddress(&hstok);
break;
case tk_number:
asmparam=FALSE;
num=doconstdwordmath();
if(mode){
if(num<256)goto testbyte;
if(num<65536)i=r16;
}
op66(i);
outseg(&hstok,2);
op(0xF7);
op(hstok.rm);
outaddress(&hstok);
if(i==r32)outdword(num);
else outword((unsigned int)num);
next=0;
break;
case tk_postnumber:
op66(i);
outseg(&hstok,2);
if(i==r32)return FALSE;
op(0xF7);
op(hstok.rm);
outaddress(&hstok);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
outword((unsigned int)itok.number);
break;
default: return FALSE;
}
break;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(hbuf,1,&hstr,&hstok);
switch(tok){
case tk_beg:
outseg(&hstok,2);
op(0x84);
op((unsigned int)itok.number*8+hstok.rm);
outaddress(&hstok);
break;
case tk_number:
asmparam=FALSE;
num=doconstdwordmath();
testbyte:
outseg(&hstok,2);
op(0xF6);
op(hstok.rm);
outaddress(&hstok);
op(num);
next=0;
break;
default: return FALSE;
}
break;
default: return FALSE;
}
if(cpu<possiblecpu)cpu=possiblecpu;
if(next)nexttok();
return TRUE;
}
void mmxiii(int type)
{
int num1,i=1;
int xmm=FALSE;
nexttok();
if(tok==tk_xmmreg)xmm=TRUE;
else if(tok!=tk_mmxreg)mmxregexpected(1);
num1=itok.number;
nextexpecting2(tk_camma);
switch(tok){
case tk_mmxreg:
if(xmm)xmmregorvarexpected(2);
op(0x0F);
op(type);
op(rm_mod11+itok.number+num1*8);
break;
case tk_xmmreg:
if(xmm==FALSE)mmxormem(2);
outword(0x0F66);
op(type);
op(rm_mod11+itok.number+num1*8);
break;
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,xmm==FALSE?3:4);
if(xmm)op(0x66);
op(0x0F);
op(type);
op(itok.rm+num1*8);
outaddress(&itok);
break;
default:
mmxormem(2);
break;
}
if(cpu<8)cpu=8;
if(xmm&&cpu<9)cpu=9;
}
void prefetch(int code,int type)
{
int i=1;
nexttok();
switch(tok){
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
KillVar(itok.name);
outseg(&itok,3);
op(0x0f);
op(code);
op(itok.rm+type*8);
outaddress(&itok);
break;
default:
datatype_expected(1);
break;
}
}
void pextrw()
{
int num1,num2;
int xmm=FALSE;
nexttok();
if(tok!=tk_reg32)reg32expected(1);
num1=itok.number;
ClearReg(num1);
nextexpecting2(tk_camma);
if(tok==tk_xmmreg)xmm=TRUE;
else if(tok!=tk_mmxreg)mmxregexpected(2);
num2=itok.number;
nextexpecting2(tk_camma);
if(tok!=tk_number)numexpected(3);
if(xmm)op(0x66);
outword(0xC50F);
op(rm_mod11+num1+num2*8);
op(doconstdwordmath());
if(cpu<8)cpu=8;
if(xmm&&cpu<9)cpu=9;
}
void pinsrw()
{
int num1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
int xmm=FALSE;
nexttok();
if(tok==tk_xmmreg)xmm=TRUE;
else if(tok!=tk_mmxreg)mmxregexpected(1);
num1=itok.number;
nextexpecting2(tk_camma);
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok!=tk_number)numexpected(3);
switch(htok){
case tk_reg32:
if(xmm)op(0x66);
outword(0xC40F);
op(rm_mod11+num1+hstok.number*8);
break;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(hbuf,2,&hstr);
outseg(&hstok,xmm==FALSE?3:4);
if(xmm)op(0x66);
outword(0xC40F);
op(hstok.rm+num1*8);
outaddress(&hstok);
break;
default:
reg32orword(2);
break;
}
op(doconstdwordmath());
if(cpu<8)cpu=8;
if(xmm&&cpu<9)cpu=9;
}
void pshufw()
{
int num1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
int i=1;
nexttok();
if(tok!=tk_mmxreg)mmxregexpected(1);
num1=itok.number;
nextexpecting2(tk_camma);
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok!=tk_number)numexpected(3);
switch(htok){
case tk_mmxreg:
outword(0x700F);
op(rm_mod11+num1+hstok.number*8);
break;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(hbuf,i,&hstr);
KillVar(hstok.name);
outseg(&hstok,3);
outword(0x700F);
op(hstok.rm+num1*8);
outaddress(&hstok);
break;
default:
mmxregordwordexpected(2);
break;
}
op(doconstdwordmath());
}
void xmminstr(int type,int sec,int op1,int op2)
{
int num1,i=1;
nexttok();
if(tok!=op1){
if(op1==tk_mmxreg)mmxregexpected(1);
else if(op1==tk_reg32)reg32expected(1);
else xmmregexpected(1);
}
if(tok==tk_reg32)ClearReg(itok.number);
num1=itok.number;
nextexpecting2(tk_camma);
switch ( tok ) {
case tk_reg32:
case tk_mmxreg:
case tk_xmmreg:
if(tok!=op2){
if(op2==tk_mmxreg)mmxregexpected(2);
else if(op2==tk_reg32)reg32expected(2);
else xmmregexpected(2);
}
if(sec)op(sec);
op(0x0F);
op(type);
op(rm_mod11+itok.number+num1*8);
break;
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,sec==0?3:4);
if(sec)op(sec);
op(0x0F);
op(type);
op(itok.rm+num1*8);
outaddress(&itok);
break;
default:
if(op2==tk_mmxreg)mmxregordwordexpected(2);
else if(op2==tk_reg32)reg32orword(2);
else xmmregorvarexpected(2);
break;
}
}
void xmm3instr(int type,int sec) //xmm,xmm/mem,i8
{
int num1,i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
nexttok();
if(tok!=tk_xmmreg)xmmregexpected(1);
num1=itok.number;
nextexpecting2(tk_camma);
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok!=tk_number)numexpected(3);
switch(htok){
case tk_xmmreg:
if(sec)op(sec);
op(0x0F);
op(type);
op(rm_mod11+hstok.number+num1*8);
break;
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(hbuf,i,&hstr);
outseg(&hstok,sec==0?3:4);
if(sec)op(sec);
op(0x0F);
op(type);
op(hstok.rm+num1*8);
outaddress(&hstok);
break;
default:
xmmregorvarexpected(2);
break;
}
op(doconstdwordmath());
}
void xmm2xmm(int code,int code2,int type)
{
int num;
nexttok();
if(tok!=type){
if(type==tk_mmxreg)mmxregexpected(1);
else if(type==tk_reg32)reg32expected(1);
else xmmregexpected(1);
}
if(tok==tk_reg32)ClearReg(itok.number);
num=itok.number;
nextexpecting2(tk_camma);
if(tok!=tk_xmmreg)xmmregexpected(2);
if(code2)op(code2);
op(0x0F);
op(code);
op(rm_mod11+itok.number+num*8);
}
void movxmm3(int code,int code2,int type)
{
int i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
if(tok!=type){
if(type==tk_mmxreg)mmxregexpected(2);
else if(type==tk_xmmreg)xmmregexpected(2);
else reg32expected(2);
}
switch(htok){
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i+=1;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(hbuf,i,&hstr);
KillVar(hstok.name);
outseg(&hstok,code2==0?3:4);
if(code2)op(code2);
op(0x0F);
op(code);
op(hstok.rm+itok.number*8);
outaddress(&hstok);
break;
default: varexpected(1);
}
}
void movxmm4(int code,int code2)
{
int i=1;
int num;
nexttok();
num=itok.number;
if(tok!=tk_xmmreg)xmmregexpected(1);
nextexpecting2(tk_camma);
switch(tok){
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i+=1;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,(code2==0?3:4));
if(code2)op(code2);
op(0x0F);
op(code);
op(itok.rm+num*8);
outaddress(&itok);
break;
default: varexpected(2);
}
}
void movxmm(int code,int code2,int addc)
{
int i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
switch(htok){
case tk_xmmreg:
switch(tok){
case tk_xmmreg:
if(code2)op(code2);
op(0x0F);
op(code);
op(rm_mod11+itok.number+hstok.number*8);
break;
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,(code2==0?3:4));
if(code2)op(code2);
op(0x0F);
op(code);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default:
xmmregorvarexpected(2);
break;
}
break;
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
if(tok!=tk_xmmreg)xmmregexpected(2);
CheckAllMassiv(hbuf,i,&hstr);
KillVar(hstok.name);
outseg(&hstok,code2==0?3:4);
if(code2)op(code2);
op(0x0F);
op(code+addc);
op(hstok.rm+itok.number*8);
outaddress(&hstok);
break;
default:
xmmregorvarexpected(1);
break;
}
}
void movxmm2(int code,int code2)
{
int i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
nexttok();
htok=tok;
hstok=itok;
hbuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nextexpecting2(tk_camma);
switch(htok){
case tk_xmmreg:
switch(tok){
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,(code2==0?3:4));
if(code2)op(code2);
op(0x0F);
op(code);
op(itok.rm+hstok.number*8);
outaddress(&itok);
break;
default:
datatype_expected(2);
break;
}
break;
case tk_qwordvar:
i+=4;
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
i+=2;
case tk_wordvar:
case tk_intvar:
i++;
case tk_charvar:
case tk_bytevar:
if(tok!=tk_xmmreg)xmmregexpected(2);
CheckAllMassiv(hbuf,i,&hstr);
KillVar(hstok.name);
outseg(&hstok,code2==0?3:4);
if(code2)op(code2);
op(0x0F);
op(code+1);
op(hstok.rm+itok.number*8);
outaddress(&hstok);
break;
default:
xmmregorvarexpected(1);
break;
}
}
void shiftxmm(int rm) //rxmm,i8
{
int num;
nexttok();
if(tok!=tk_xmmreg)xmmregexpected(1);
num=itok.number;
nextexpecting2(tk_camma);
if(tok!=tk_number)numexpected(2);
op(0x66);
op(0x0F);
op(0x73);
op(rm*8+num+rm_mod11);
op(doconstdwordmath());
}
void DDDW(int faradd)
{
int htok,i;
char name[IDLENGTH];
unsigned long hnumber;
if(dbg&2)AddDataNullLine(faradd==0?2:4);
dbgact++;
asmparam=FALSE;
do{
i=1;
nexttok();
CheckIP();
htok=tok;
switch(tok){
case tk_undefofs:
tok=tk_number;
strcpy(name,itok.name);
case tk_number:
hnumber=doconstdwordmath();
if(tok==tk_id&&strcmp((char *)string,"dup")==0){
i=hnumber;
nexttok();
CheckMinusNum();
htok=tok;
if(tok==tk_undefofs){
tok=tk_number;
strcpy(name,itok.name);
}
if(tok==tk_number)hnumber=doconstdwordmath();
else numexpected();
}
for(;i!=0;i--){
if(postnumflag&f_reloc)AddReloc();
if(htok==tk_undefofs)AddUndefOff(2,name);
if(faradd)outdword(hnumber);
else outword(hnumber);
}
break;
case tk_postnumber:
setwordpost(&itok);
if(faradd)outdword(itok.number);
else outword(itok.number);
nexttok();
break;
default:
numexpected();
nexttok();
break;
}
}while(tok==tk_camma);
dbgact--;
}
void AADM(int code)
{
op(code);
itok.number=10;
if(tok2==tk_number)nexttok();
op(itok.number); //AAD
ClearReg(AX);
}
int Push(ITOK *wtok)
{
int i;
int razr;
ITOK hstok;
unsigned long hnumber;
int possiblecpu=0;
int next=1;
i=(am32+1)*2;
razr=r16;
switch(tok){
case tk_id:
case tk_ID:
if((stricmp("dword",(char *)string)==0)||(stricmp("long",(char *)string)==0))i=r32;
else if((stricmp("word",(char *)string)==0)||(stricmp("int",(char *)string)==0))i=r16;
else return FALSE;
goto swpushpar;
case tk_dword:
case tk_long:
i=r32;
goto swpushpar;
case tk_int:
case tk_word:
i=r16;
swpushpar:
nexttok();
CheckMinusNum();
if(tok==tk_number)goto pushnum;
if(tok==tk_undefofs)goto pushundef;
return FALSE;
case tk_reg32:
possiblecpu=3;
case tk_reg:
op66(tok==tk_reg?r16:r32);
op(0x50+(unsigned int)itok.number);
break;
case tk_seg:
PushSeg((unsigned int)itok.number);
break;
case tk_undefofs:
pushundef:
hstok=itok;
tok=tk_number;
hnumber=doconstlongmath();
op66(i); ////
op(0x68);
if(postnumflag&f_reloc)AddReloc();
AddUndefOff(2,hstok.name);
if(i==r16)outword(hnumber);
else outdword(hnumber);
possiblecpu=(unsigned char)(i==r16?2:3);
next=0;
break;
case tk_minus:
if(tok2!=tk_number)return FALSE;
case tk_number:
pushnum:
hnumber=doconstlongmath();
if(i==r16)hnumber&=0xffff;
else hnumber&=0xffffffff;
if(wtok&&(postnumflag&f_reloc)==0)Const2Var(wtok,hnumber,i==r16?tk_word:tk_dword);
op66(i);
if((postnumflag&f_reloc)==0&&short_ok(hnumber,i/2-1)){
op(0x6A);
op(hnumber);
}
else{
op(0x68);
if((postnumflag&f_reloc)!=0)AddReloc();
if(i==r16)outword(hnumber);
else outdword(hnumber);
}
possiblecpu=(unsigned char)(i==r16?2:3);
next=0;
break;
case tk_dwordvar:
case tk_longvar:
CheckAllMassiv(bufrm,4,&strinf);
possiblecpu=3;
razr=r32;
goto push;
case tk_wordvar:
case tk_intvar:
CheckAllMassiv(bufrm,2,&strinf);
push:
op66(razr);
outseg(&itok,2);
op(0xFF); op(0x30+itok.rm);
outaddress(&itok);
break;
case tk_postnumber:
op(0x68);
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(am32==FALSE)outword((unsigned int)itok.number);
else outdword(itok.number);
break;
case tk_string:
op66(i);
op(0x68);
if(am32==FALSE)outword(addpoststring());
else outdword(addpoststring());
break;
default:
return FALSE;
}
if(cpu<possiblecpu)cpu=possiblecpu;
asmparam=FALSE;
if(next)nexttok();
return i;
}
/* end of TOKR.C */