#include "all.h"
/* implicit operands, not needed for assembly */
#define AFv ANONE
#define AXb ANONE
#define AXv ANONE
#define AYb ANONE
#define AYv ANONE
#define A0 ANONE
#define A1 ANONE
#define A2 ANONE
#define A3 ANONE
#define A4 ANONE
#define AMa2 ANONE
typedef struct Optab Optab;
struct Optab {
int op;
uchar arg1;
uchar arg2;
uchar arg3;
};
static uchar needmodrm[NAMODE] = {
[AEb] 1,
[AEv] 1,
[AGb] 1,
[AGv] 1,
[AM] 1,
[AMp] 1,
[ASw] 1,
};
/*
static uchar small[NAMODE] = {
[ANONE] 1,
[AEb] 1,
[AGb] 1,
[AOb] 1,
[AXb] 1,
[AYb] 1,
[AIb] 1,
[AAL] 1,
[ABL] 1,
[ACL] 1,
[ADL] 1,
[AAH] 1,
[ABH] 1,
[ACH] 1,
[ADH] 1,
};
*/
static Optab optab[256] = {
//00
{OADD, AEb, AGb}, {OADD, AEv, AGv}, {OADD, AGb, AEb}, {OADD, AGv, AEv},
{OADD, AAL, AIb}, {OADD, AAX, AIv}, {OPUSH, AES, }, {OPOP, AES },
{OOR, AEb, AGb}, {OOR, AEv, AGv}, {OOR, AGb, AEb}, {OOR, AGv, AEv},
{OOR, AAL, AIb}, {OOR, AAX, AIv}, {OPUSH, ACS, }, {OBAD, },
//10
{OADC, AEb, AGb}, {OADC, AEv, AGv}, {OADC, AGb, AEb}, {OADC, AGv, AEv},
{OADC, AAL, AIb}, {OADC, AAX, AIv}, {OPUSH, ASS, }, {OPOP, ASS, },
{OSBB, AEb, AGb}, {OSBB, AEv, AGv}, {OSBB, AGb, AEb}, {OSBB, AGv, AEv},
{OSBB, AAL, AIb}, {OSBB, AAX, AIv}, {OPUSH, ADS, }, {OPOP, ADS, },
//20
{OAND, AEb, AGb}, {OAND, AEv, AGv}, {OAND, AGb, AEb}, {OAND, AGv, AEv},
{OAND, AAL, AIb}, {OAND, AAX, AIv}, {OSEG, AES, }, {ODAA, },
{OSUB, AEb, AGb}, {OSUB, AEv, AGv}, {OSUB, AGb, AEb}, {OSUB, AGv, AEv},
{OSUB, AAL, AIb}, {OSUB, AAX, AIv}, {OSEG, ACS, }, {ODAS, },
//30
{OXOR, AEb, AGb}, {OXOR, AEv, AGv}, {OXOR, AGb, AEb}, {OXOR, AGv, AEv},
{OXOR, AAL, AIb}, {OXOR, AAX, AIv}, {OSEG, ASS, }, {OAAA, },
{OCMP, AEb, AGb}, {OCMP, AEv, AGv}, {OCMP, AGb, AEb}, {OCMP, AGv, AEv},
{OCMP, AAL, AIb}, {OCMP, AAX, AIv}, {OSEG, ADS, }, {OAAS, },
//40
{OINC, AAX, }, {OINC, ACX, }, {OINC, ADX, }, {OINC, ABX, },
{OINC, ASP, }, {OINC, ABP, }, {OINC, ASI, }, {OINC, ADI, },
{ODEC, AAX, }, {ODEC, ACX, }, {ODEC, ADX, }, {ODEC, ABX, },
{ODEC, ASP, }, {ODEC, ABP, }, {ODEC, ASI, }, {ODEC, ADI, },
//50
{OPUSH, AAX, }, {OPUSH, ACX, }, {OPUSH, ADX, }, {OPUSH, ABX, },
{OPUSH, ASP, }, {OPUSH, ABP, }, {OPUSH, ASI, }, {OPUSH, ADI, },
{OPOP, AAX, }, {OPOP, ACX, }, {OPOP, ADX, }, {OPOP, ABX, },
{OPOP, ASP, }, {OPOP, ABP, }, {OPOP, ASI, }, {OPOP, ADI, },
//60
{OPUSHA, }, {OPOPA, }, {OBOUND,AGv,AMa,AMa2}, {OARPL, AEw, AGw},
{OSEG, AFS, }, {OSEG, AGS, }, {OOSIZE, }, {OASIZE, },
{OPUSH, AIv, }, {OIMUL,AGv,AEv,AIv},{OPUSH, AIb, }, {OIMUL,AGv,AEv,AIb},
{OINS, AYb, ADX}, {OINS, AYv, ADX}, {OOUTS, ADX, AXb}, {OOUTS, ADX, AXv},
//70
{OJOS, AJb, }, {OJOC, AJb, }, {OJCS, AJb, }, {OJCC, AJb, },
{OJEQ, AJb, }, {OJNE, AJb, }, {OJLS, AJb, }, {OJHI, AJb, },
{OJMI, AJb, }, {OJPL, AJb, }, {OJPS, AJb, }, {OJPC, AJb, },
{OJLT, AJb, }, {OJGE, AJb, }, {OJLE, AJb, }, {OJGT, AJb, },
//80
{OGP1, AEb, AIb}, {OGP1, AEv, AIv}, {OGP1, AEv, AIc}, {OGP1, AEv, AIc},
{OTEST, AEb, AGb}, {OTEST, AEv, AGv}, {OXCHG, AEb, AGb}, {OXCHG, AEv, AGv},
{OMOV, AEb, AGb}, {OMOV, AEv, AGv}, {OMOV, AGb, AEb}, {OMOV, AGv, AEv},
{OMOV, AEw, ASw}, {OLEA, AGv, AM }, {OMOV, ASw, AEw}, {OPOP, AEv, },
//90
{ONOP, }, {OXCHG, AAX, ACX}, {OXCHG, AAX, ADX}, {OXCHG, AAX, ABX},
{OXCHG, AAX, ASP}, {OXCHG, AAX, ABP}, {OXCHG, AAX, ASI}, {OXCHG, AAX, ADI},
{OCBW, }, {OCWD, }, {OCALL, AAp, }, {OWAIT, },
{OPUSHF,AFv, }, {OPOPF, AFv, }, {OSAHF, AAH, }, {OLAHF, AAH, },
//A0
{OMOV, AAL, AOb}, {OMOV, AAX, AOv}, {OMOV, AOb, AAL}, {OMOV, AOv, AAX},
{OMOVS, AXb, AYb}, {OMOVS, AXv, AYv}, {OCMPS, AXb, AYb}, {OCMPS, AXv, AYv},
{OTEST, AAL, AIb}, {OTEST, AAX, AIv}, {OSTOS, AYb, AAL}, {OSTOS, AYv, AAX},
{OLODS, AAL, AXb}, {OLODS, AAX, AXv}, {OSCAS, AAL, AYb}, {OSCAS, AAX, AYv},
//B0
{OMOV, AAL, AIb}, {OMOV, ACL, AIb}, {OMOV, ADL, AIb}, {OMOV, ABL, AIb},
{OMOV, AAH, AIb}, {OMOV, ACH, AIb}, {OMOV, ADH, AIb}, {OMOV, ABH, AIb},
{OMOV, AAX, AIv}, {OMOV, ACX, AIv}, {OMOV, ADX, AIv}, {OMOV, ABX, AIv},
{OMOV, ASP, AIv}, {OMOV, ABP, AIv}, {OMOV, ASI, AIv}, {OMOV, ADI, AIv},
//C0
{OGP2, AEb, AIb}, {OGP2, AEv, AIb}, {ORET, AIw, }, {ORET, A0, },
{OLFP,AES,AGv,AMp},{OLFP,ADS,AGv,AMp},{OMOV, AEb, AIb}, {OMOV, AEv, AIv},
{OENTER,AIw, AIb}, {OLEAVE, }, {ORETF, AIw, }, {ORETF, A0, },
{OINT, A3, }, {OINT, AIb, }, {OINT, A4, }, {OIRET, },
//D0
{OGP2, AEb, A1 }, {OGP2, AEv, A1 }, {OGP2, AEb, ACL}, {OGP2, AEv, ACL},
{OAAM, AIb, }, {OAAD, AIb, }, {OBAD, }, {OXLAT, AAL, ABX},
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//E0
{OLOOPNZ,AJb,ACX}, {OLOOPZ,AJb, ACX}, {OLOOP, AJb, ACX}, {OJCXZ, AJb, },
{OIN, AAL, AIb}, {OIN, AAX, AIb}, {OOUT, AIb, AAL}, {OOUT, AIb, AAX},
{OCALL, AJv, }, {OJMP, AJv, }, {OJMP, AAp, }, {OJMP, AJb, },
{OIN, AAL, ADX}, {OIN, AAX, ADX}, {OOUT, ADX, AAL}, {OOUT, ADX, AAX},
//F0
{OLOCK, }, {OBAD, }, {OREPNZ, }, {OREPZ, },
{OHLT, }, {OCMC, }, {OGP3b, }, {OGP3v, },
{OCLC, }, {OSTC, }, {OCLI, }, {OSTI, },
{OCLD, }, {OSTD, }, {OGP4, }, {OGP5, },
};
static Optab optab0F[256] = {
//00
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//10 - mostly floating point and quadword moves
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//20 - doubleword <-> control register moves, other arcana
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//30 - wrmsr, rdtsc, rdmsr, rdpmc, sysenter, sysexit
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//40 - conditional moves
{OCMOVOS,AGv,AEv}, {OCMOVOC,AGv,AEv}, {OCMOVCS,AGv,AEv}, {OCMOVCC,AGv,AEv},
{OCMOVEQ,AGv,AEv}, {OCMOVNE,AGv,AEv}, {OCMOVLS,AGv,AEv}, {OCMOVHI,AGv,AEv},
{OCMOVMI,AGv,AEv}, {OCMOVPL,AGv,AEv}, {OCMOVPS,AGv,AEv}, {OCMOVPC,AGv,AEv},
{OCMOVLT,AGv,AEv}, {OCMOVGE,AGv,AEv}, {OCMOVLE,AGv,AEv}, {OCMOVGT,AGv,AEv},
//50 - floating point, mmx stuff
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//60 - floating point, mmx stuff
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//70 - floating point, mmx stuff
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//80 - long-displacement jumps
{OJOS, AJv, }, {OJOC, AJv, }, {OJCS, AJv, }, {OJCC, AJv, },
{OJEQ, AJv, }, {OJNE, AJv, }, {OJLS, AJv, }, {OJHI, AJv, },
{OJMI, AJv, }, {OJPL, AJv, }, {OJPS, AJv, }, {OJPC, AJv, },
{OJLT, AJv, }, {OJGE, AJv, }, {OJLE, AJv, }, {OJGT, AJv, },
//90 - conditional byte set
{OSETOS,AEb, }, {OSETOC,AEb, }, {OSETCS,AEb, }, {OSETCC,AEb, },
{OSETEQ,AEb, }, {OSETNE,AEb, }, {OSETLS,AEb, }, {OSETHI,AEb, },
{OSETMI,AEb, }, {OSETPL,AEb, }, {OSETPS,AEb, }, {OSETPC,AEb, },
{OSETLT,AEb, }, {OSETGE,AEb, }, {OSETLE,AEb, }, {OSETGT,AEb, },
//A0
{OPUSH, AFS, }, {OPOP, AFS, }, {OBAD, }, {OBT, AEv, AGv},
{OSHLD,AEv,AGv,AIb}, {OSHLD,AEv,AGv,ACL}, {OBAD, }, {OBAD, },
{OPUSH, AGS, }, {OPOP, AGS, }, {OBAD, }, {OBTS, AEv, AGv},
{OSHRD,AEv,AGv,AIb}, {OSHRD,AEv,AGv,ACL}, {OBAD, }, {OIMUL, AGv,AGv,AEv},
//B0 - mostly arcana
{OBAD, }, {OBAD, }, {OLFP,ASS,AGv,AMp},{OBAD, },
{OLFP,AFS,AGv,AMp},{OLFP,AGS,AGv,AMp},{OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//C0 - more arcana
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//D0 - mmx
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//E0 - mmx
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
//F0 - mmx
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
};
/* some operands map to whole groups; group numbers from intel opcode map */
/* args filled in already (in OGP1 entries) */
static Optab optabgp1[8] = {
{OADD, }, {OOR, }, {OADC, }, {OSBB, },
{OAND, }, {OSUB, }, {OXOR, }, {OCMP, },
};
/* args filled in already (in OGP2 entries) */
static Optab optabgp2[8] = {
{OROL, }, {OROR, }, {ORCL, }, {ORCR, },
{OSHL, }, {OSHR, }, {OBAD, }, {OSAR, },
};
static Optab optabgp3b[8] = {
{OTEST, AEb, AIb}, {OBAD, }, {ONOT, AEb, }, {ONEG, AEb, },
{OMUL,AAX,AAL,AEb},{OIMUL,AAX,AAL,AEb},{ODIV, AEb, }, {OIDIV, AEb, },
};
static Optab optabgp3v[8] = {
{OTEST, AEv, AIv}, {OBAD, }, {ONOT, AEv, }, {ONEG, AEv, },
{OMUL,AAX,AAX,AEv},{OIMUL,AAX,AAX,AEv},{ODIV, AEv, }, {OIDIV, AEv, },
};
static Optab optabgp4[8] = {
{OINC, AEb, }, {ODEC, AEb, }, {OBAD, }, {OBAD, },
{OBAD, }, {OBAD, }, {OBAD, }, {OBAD, },
};
static Optab optabgp5[8] = {
{OINC, AEv, }, {ODEC, AEv, }, {OCALL, AEv, }, {OCALL, AEp },
{OJMP, AEv, }, {OJMP, AEp, }, {OPUSH, AEv, }, {OBAD, },
};
/* optabg6 unimplemented - mostly segment manipulation */
/* optabg7 unimplemented - more segment manipulation */
/* optabg8 unimplemented - bit tests */
/*
* most of optabg9 - optabg16 decode differently depending on the mod value of
* the modrm byte. they're mostly arcane instructions so they're not
* implemented.
*/
/*
* the above tables are in intel order, in which data moves right to left.
* change to plan9, left to right.
*/
static void
revtab(Optab *o, int n)
{
int i, t;
for(i=0; i<n; i++){
if(o[i].arg1!=ANONE && o[i].arg2!=ANONE && o[i].arg3==ANONE){
t = o[i].arg1;
o[i].arg1 = o[i].arg2;
o[i].arg2 = t;
}
}
}
void
plan9order(void)
{
revtab(optab, nelem(optab));
revtab(optab0F, nelem(optab0F));
/* revtab gp3b and gp3v? */
}
static Optab *optabgp[NUMOP] = {
[OGP1] optabgp1,
[OGP2] optabgp2,
[OGP3b] optabgp3b,
[OGP3v] optabgp3v,
[OGP4] optabgp4,
[OGP5] optabgp5,
};
static int
matchmodrm(Expr *e, Istate *is)
{
/* various memory references unimplemented */
return 0;
}
static int
isconst(Expr *e)
{
if(e == nil)
return 0;
switch(e->op){
case ENAME:
return 1;
case ECONST:
return 1;
case EMUL:
case EADD:
case ESUB:
return isconst(e->arg[0]) && isconst(e->arg[1]);
default:
return 0;
}
}
static int
matcharg(int a, Expr *e, Istate *is)
{
int seg;
int off;
if(a==ANONE && e==nil)
return 1;
if(a==ANONE || e==nil)
return 0;
switch(a){
case AAp: /* seg:off immediate address */
if(e->op==ESEG && isconst(e->arg[0]) && isconst(e->arg[1])){
seg = e->arg[0]->con;
is->byte[is->nbyte++] = seg;
is->byte[is->nbyte++] = seg>>8;
off = e->arg[0]->con;
is->byte[is->nbyte++] = off;
is->byte[is->nbyte++] = off>>8;
return 1;
}
return 0;
case AEb: /* r/m8 from modrm byte */
if(e->op==EREG && e->sz==8 && e->reg<8){
is->mod = 3;
is->rm = e->reg;
is->needmodrm = 1;
return 1;
}
if(e->op==EBYTE && matchmodrm(e, is))
return 1;
return 0;
case AEp: /* call indirect through memory */
if(e->op==EADDR && matchmodrm(e, is))
return 1;
return 0;
case AEw:
case AEv: /* r/m16 or r/m32 from modrm byte */
if(e->op==EREG && e->sz==16 && e->reg<8){
is->mod = 3;
is->rm = e->reg;
is->needmodrm = 1;
return 1;
}
if(e->op==EWORD && matchmodrm(e, is))
return 1;
return 0;
case AGb: /* r8 from modrm byte */
if(e->op==EREG && e->sz==8 && e->reg<8){
is->rop = e->reg;
is->needmodrm = 1;
return 1;
}
return 0;
case AGv: /* r16 or r32 from modrm byte */
if(e->op==EREG && e->sz==16 && e->reg<8){
is->rop = e->reg;
is->needmodrm = 1;
return 1;
}
return 0;
case AGw: /* r/m 16 */
if(e->op==EREG && e->sz==16 && e->reg<8){
is->rop = e->reg;
is->needmodrm = 1;
return 1;
}
return 0;
case AIb: /* immediate byte */
if(isconst(e) && 0x00 <= e->con && e->con <= 0xFF){
is->consz = 1;
is->conoff = is->nbyte;
is->byte[is->nbyte++] = e->con;
return 1;
}
return 0;
case AIc: /* immediate byte sign-extended */
if(isconst(e) && -0x80 <= e->con && e->con <= 0x7F){
is->consz = 1;
is->conoff = is->nbyte;
is->byte[is->nbyte++] = e->con;
return 1;
}
return 0;
case AIw: /* immediate 16-bit word */
if(isconst(e)){
is->consz = 2;
is->conoff = is->nbyte;
is->byte[is->nbyte++] = e->con;
is->byte[is->nbyte++] = e->con>>8;
return 1;
}
return 0;
case AIv: /* immediate 16-bit or 32-bit word */
if(isconst(e)){
is->consz = 2;
is->conoff = is->nbyte;
is->byte[is->nbyte++] = e->con;
is->byte[is->nbyte++] = e->con>>8;
return 1;
}
return 0;
case AJb: /* relative offset byte */
if(e->sz==1){
is->jmpoff = is->nbyte++;
return 1;
}
return 0;
case AJv: /* relative offset 16-bit or 32-bit word */
if(e->sz==2){
is->jmpoff = is->nbyte;
is->nbyte += 2;
return 1;
}
return 0;
case AJr: /* r/m16 or r/m32 register */
if(e->op==EREG && e->sz==16 && e->reg<8){
is->needmodrm = 1;
is->mod = 3;
is->rm = e->reg;
return 1;
}
return 0;
case AM: /* memory address from modrm */
if(e->op==EADDR && matchmodrm(e, is))
return 1;
return 0;
case AMa: /* something for bound? */
if(e->op==EADDR && matchmodrm(e, is))
return 1;
return 0;
case AMp: /* 32-bit or 48-bit memory address */
return e->op==EADDR && matchmodrm(e, is);
case AOb: /* immediate word-sized offset to a byte */
return 0;
case AOv: /* immediate word-sized offset to a word */
return 0;
case ASw: /* segment register selected by field of modrm */
if(e->op==EREG && e->reg >= RES && e->reg <= RDS){
is->needmodrm = 1;
is->rop = e->reg - RES;
return 1;
}
return 0;
case AAL:
return e->op==EREG && e->sz==8 && e->reg==RAL;
case ACL:
return e->op==EREG && e->sz==8 && e->reg==RCL;
case ADL:
return e->op==EREG && e->sz==8 && e->reg==RDL;
case ABL:
return e->op==EREG && e->sz==8 && e->reg==RBL;
case AAH:
return e->op==EREG && e->sz==8 && e->reg==RAH;
case ACH:
return e->op==EREG && e->sz==8 && e->reg==RCH;
case ADH:
return e->op==EREG && e->sz==8 && e->reg==RDH;
case ABH:
return e->op==EREG && e->sz==8 && e->reg==RBH;
case AAX:
return e->op==EREG && e->sz==16 && e->reg==RAX;
case ACX:
return e->op==EREG && e->sz==16 && e->reg==RCX;
case ADX:
return e->op==EREG && e->sz==16 && e->reg==RDX;
case ABX:
return e->op==EREG && e->sz==16 && e->reg==RBX;
case ASP:
return e->op==EREG && e->sz==16 && e->reg==RSP;
case ABP:
return e->op==EREG && e->sz==16 && e->reg==RBP;
case ASI:
return e->op==EREG && e->sz==16 && e->reg==RSI;
case ADI:
return e->op==EREG && e->sz==16 && e->reg==RDI;
case AES:
return e->op==EREG && e->sz==16 && e->reg==RES;
case ACS:
return e->op==EREG && e->sz==16 && e->reg==RCS;
case ASS:
return e->op==EREG && e->sz==16 && e->reg==RSS;
case ADS:
return e->op==EREG && e->sz==16 && e->reg==RDS;
case AFS:
return e->op==EREG && e->sz==16 && e->reg==RFS;
case AGS:
return e->op==EREG && e->sz==16 && e->reg==RGS;
default:
return 0;
}
}
static void
match(Optab *o, int b, Inst *inst, Istate *is)
{
uchar xb[16];
int nxb;
int i, modrmoff;
Istate ts, ots;
Optab *og;
switch(o->op){
case O0F:
ots = *is;
ots.byte[ots.nbyte++] = 0x0F;
for(i=0; i<nelem(optab0F); i++){
ts = ots;
match(&optab0F[i], i, inst, &ts);
}
return;
case OGP1:
case OGP2:
case OGP3b:
case OGP3v:
case OGP4:
case OGP5:
ots = *is;
og = optabgp[o->op];
for(i=0; i<8; i++){
if(o->arg1!=ANONE)
og[i].arg1 = o->arg1;
if(o->arg2!=ANONE)
og[i].arg2 = o->arg2;
if(o->arg3!=ANONE)
og[i].arg3 = o->arg3;
ts = ots;
ts.rop = i;
ts.needmodrm = 1;
match(&og[i], b, inst, &ts);
}
return;
}
if(o->op != inst->op)
return;
ts = *is;
ts.byte[ts.nbyte++] = b;
modrmoff = ts.nbyte;
if(!matcharg(o->arg1, inst->arg[0], &ts))
return;
if(!matcharg(o->arg2, inst->arg[1], &ts))
return;
if(!matcharg(o->arg3, inst->arg[2], &ts))
return;
if(ts.needmodrm){
nxb = ts.nbyte - modrmoff;
memmove(xb, ts.byte+modrmoff, nxb);
ts.nbyte = modrmoff;
ts.byte[ts.nbyte++] = (ts.mod<<6) | (ts.rop<<3) | ts.rm;
if(ts.mod==1)
ts.byte[ts.nbyte++] = ts.disp;
if((ts.mod==0 && ts.rm==6) || ts.mod==2){
ts.byte[ts.nbyte++] = ts.disp;
ts.byte[ts.nbyte++] = ts.disp>>8;
}
memmove(ts.byte+ts.nbyte, xb, nxb);
ts.nbyte += nxb;
}
if(ts.nbyte < inst->nbyte)
inst->Istate = ts;
}
static int isjmp[NUMOP] =
{
[OJCXZ] 1,
[OJOS] 1,
[OJOC] 1,
[OJCS] 1,
[OJCC] 1,
[OJEQ] 1,
[OJNE] 1,
[OJLS] 1,
[OJHI] 1,
[OJMI] 1,
[OJPL] 1,
[OJPS] 1,
[OJPC] 1,
[OJLT] 1,
[OJGE] 1,
[OJLE] 1,
[OJGT] 1,
[OJMP] 1,
};
static uchar prefix[] = { 0xF0, 0xF2, 0xF3, 0x26, 0x2E, 0x36, 0x3E, 0x64, 0x65 };
static int
domatch(Inst *inst)
{
int i;
Istate ts;
memset(&ts, 0, sizeof ts);
for(i=0; i<inst->npref; i++)
ts.byte[ts.nbyte++] = prefix[inst->pref[i]];
inst->nbyte = 1000;
for(i=0; i<nelem(optab); i++)
match(&optab[i], i, inst, &ts);
if(inst->nbyte == 1000)
return -1;
return 0;
}
int
assinst(Inst *inst)
{
/* calc both spans
if(isjmp[inst->op] && inst->arg[0] && inst->arg[0]->op != EREG){
if(inst->arg[0]==nil)
return -1;
inst->arg[0]->sz = 1;
if(domatch(inst) < 0)
return -1;
inst->span1 = inst->Istate;
inst->arg[0]->sz = 2;
if(domatch(inst) < 0)
return -1;
inst->span2 = inst->Istate;
inst->isspan = 1;
return 0;
}
*/
/* punt on spans for now: */
if(isjmp[inst->op] && isconst(inst->arg[0]))
inst->arg[0]->sz = 2;
if(inst->op == OLABEL){
inst->nbyte = 0;
return 0;
}
return domatch(inst);
}
|
