#include <iostream>
#include "SMPDataFlowAnalysis.h"
#include "interfaces/abstract/STARSInterface.h"
#include "interfaces/irdb/STARSInstruction.h"
#include "interfaces/irdb/STARSOp.h"
#include "interfaces/STARSTypes.h"
#include <libIRDB-core.hpp>
// #include <bea_deprecated.hpp>
using namespace std;
using namespace libIRDB;
#ifndef ALLOF
#define ALLOF(a) begin(a),end(a)
#endif
STARSOpndTypePtr STARS_IRDB_Instruction_t::VoidOpndsPtr=dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IRDB_op_t>());
static uint32_t UseMacros[STARS_UA_MAXOP] = {STARS_CF_USE1, STARS_CF_USE2, STARS_CF_USE3, STARS_CF_USE4, STARS_CF_USE5, STARS_CF_USE6};
static uint32_t DefMacros[STARS_UA_MAXOP] = {STARS_CF_CHG1, STARS_CF_CHG2, STARS_CF_CHG3, STARS_CF_CHG4, STARS_CF_CHG5, STARS_CF_CHG6};
STARS_InstructionID_t STARS_IRDB_Instruction_t::GetNextInstructionID(void) const
{
Instruction_t *FallthroughID = irdb_insn->GetFallthrough();
if (nullptr == FallthroughID) {
// For robustness, permit a no-op to have no fall through inst.
cerr << "ERROR: No fallthrough inst in GetNextInstructionID()" << endl;
return STARS_InstructionID_t(STARS_BADADDR);
}
else {
return STARS_InstructionID_t(FallthroughID->GetBaseID());
}
}
uint16_t STARS_IRDB_Instruction_t::GetIDAOpcode(void)
{
if (this->IDAOpcodeCached) {
return this->IDAOpcode; // optimization
}
#define CHECK_FOR_INSN(token) \
if (disasm.getMnemonic() == string(#token) ) { /*string(disasm.Instruction.Mnemonic) == string(#token) + " ") */ \
this->IDAOpcode = STARS_NN_##token; \
this->IDAOpcodeCached = true; \
return this->IDAOpcode; } \
#define CHECK_FOR_INSN_RENAME(token,str) \
if (disasm.getMnemonic() == string(str) ) { /*if (string(disasm.Instruction.Mnemonic) == string(str) + " ") */ \
this->IDAOpcode = STARS_NN_##token; \
this->IDAOpcodeCached = true; \
return this->IDAOpcode; } \
if(disasm.isUnconditionalBranch() /*string(disasm.Instruction.Mnemonic)==string("jmp")+" "*/ )
{
if (irdb_insn->GetTarget()) {
this->IDAOpcode = STARS_NN_jmp;
}
else {
this->IDAOpcode = STARS_NN_jmpni;
}
this->IDAOpcodeCached = true;
return this->IDAOpcode;
}
else if(disasm.isCall() /*string(disasm.Instruction.Mnemonic)==string("call")+" "*/ )
{
if (irdb_insn->GetTarget()) {
this->IDAOpcode = STARS_NN_call;
}
else {
this->IDAOpcode = STARS_NN_callni;
}
this->IDAOpcodeCached = true;
return this->IDAOpcode;
}
CHECK_FOR_INSN(aaa);
CHECK_FOR_INSN(aad);
CHECK_FOR_INSN(aam);
CHECK_FOR_INSN(aas);
CHECK_FOR_INSN(adc);
CHECK_FOR_INSN(add);
CHECK_FOR_INSN(and);
CHECK_FOR_INSN(arpl);
CHECK_FOR_INSN(bound);
CHECK_FOR_INSN(bsf);
CHECK_FOR_INSN(bsr);
CHECK_FOR_INSN(bt);
CHECK_FOR_INSN(btc);
CHECK_FOR_INSN(btr);
CHECK_FOR_INSN(bts);
CHECK_FOR_INSN(call);
CHECK_FOR_INSN(callfi);
CHECK_FOR_INSN(callni);
CHECK_FOR_INSN(cbw);
CHECK_FOR_INSN(cwde);
CHECK_FOR_INSN(cdqe);
CHECK_FOR_INSN(clc);
CHECK_FOR_INSN(cld);
CHECK_FOR_INSN(cli);
CHECK_FOR_INSN(clts);
CHECK_FOR_INSN(cmc);
CHECK_FOR_INSN(cmp);
CHECK_FOR_INSN_RENAME(cmps, "cmpsb");
CHECK_FOR_INSN_RENAME(cmps, "cmpsd");
CHECK_FOR_INSN_RENAME(cmps, "cmpsw");
CHECK_FOR_INSN_RENAME(cmps, "cmpsq");
CHECK_FOR_INSN_RENAME(cmps, "cmps");
CHECK_FOR_INSN(cwd);
CHECK_FOR_INSN(cdq);
CHECK_FOR_INSN(cqo);
CHECK_FOR_INSN(daa);
CHECK_FOR_INSN(das);
CHECK_FOR_INSN(dec);
CHECK_FOR_INSN(div);
CHECK_FOR_INSN(enterw);
CHECK_FOR_INSN(enter);
CHECK_FOR_INSN(enterd);
CHECK_FOR_INSN(enterq);
CHECK_FOR_INSN(hlt);
CHECK_FOR_INSN(idiv);
CHECK_FOR_INSN(imul);
CHECK_FOR_INSN(in);
CHECK_FOR_INSN(inc);
CHECK_FOR_INSN_RENAME(ins, "insb");
CHECK_FOR_INSN_RENAME(ins, "insw");
CHECK_FOR_INSN_RENAME(ins, "insd");
CHECK_FOR_INSN_RENAME(ins, "insq");
CHECK_FOR_INSN(ins);
CHECK_FOR_INSN(int);
CHECK_FOR_INSN(into);
CHECK_FOR_INSN(int3);
CHECK_FOR_INSN(iretw);
CHECK_FOR_INSN(iret);
CHECK_FOR_INSN(iretd);
CHECK_FOR_INSN(iretq);
CHECK_FOR_INSN(ja);
CHECK_FOR_INSN(jae);
CHECK_FOR_INSN(jb);
CHECK_FOR_INSN(jbe);
CHECK_FOR_INSN(jc);
CHECK_FOR_INSN(jcxz);
CHECK_FOR_INSN(jecxz);
CHECK_FOR_INSN(jrcxz);
CHECK_FOR_INSN(je);
CHECK_FOR_INSN(jg);
CHECK_FOR_INSN(jge);
CHECK_FOR_INSN(jl);
CHECK_FOR_INSN(jle);
CHECK_FOR_INSN(jna);
CHECK_FOR_INSN(jnae);
CHECK_FOR_INSN(jnb);
CHECK_FOR_INSN(jnbe);
CHECK_FOR_INSN(jnc);
CHECK_FOR_INSN(jne);
CHECK_FOR_INSN(jng);
CHECK_FOR_INSN(jnge);
CHECK_FOR_INSN(jnl);
CHECK_FOR_INSN(jnle);
CHECK_FOR_INSN(jno);
CHECK_FOR_INSN(jnp);
CHECK_FOR_INSN(jns);
CHECK_FOR_INSN(jnz);
CHECK_FOR_INSN(jo);
CHECK_FOR_INSN(jp);
CHECK_FOR_INSN(jpe);
CHECK_FOR_INSN(jpo);
CHECK_FOR_INSN(js);
CHECK_FOR_INSN(jz);
CHECK_FOR_INSN(jmp);
CHECK_FOR_INSN_RENAME(jmpfi, "jmp far");
CHECK_FOR_INSN(jmpfi);
CHECK_FOR_INSN(jmpni);
CHECK_FOR_INSN(jmpshort);
CHECK_FOR_INSN(lahf);
CHECK_FOR_INSN(lar);
CHECK_FOR_INSN(lea);
CHECK_FOR_INSN(leavew);
CHECK_FOR_INSN(leave);
CHECK_FOR_INSN(leaved);
CHECK_FOR_INSN(leaveq);
CHECK_FOR_INSN(lgdt);
CHECK_FOR_INSN(lidt);
CHECK_FOR_INSN(lgs);
CHECK_FOR_INSN(lss);
CHECK_FOR_INSN(lds);
CHECK_FOR_INSN(les);
CHECK_FOR_INSN(lfs);
CHECK_FOR_INSN(lldt);
CHECK_FOR_INSN(lmsw);
CHECK_FOR_INSN(lock);
CHECK_FOR_INSN_RENAME(lods, "lodsb");
CHECK_FOR_INSN_RENAME(lods, "lodsw");
CHECK_FOR_INSN_RENAME(lods, "lodsd");
CHECK_FOR_INSN_RENAME(lods, "lodsq");
CHECK_FOR_INSN(lods);
CHECK_FOR_INSN(loopw);
CHECK_FOR_INSN(loop);
CHECK_FOR_INSN(loopd);
CHECK_FOR_INSN(loopq);
CHECK_FOR_INSN(loopwe);
CHECK_FOR_INSN(loope);
CHECK_FOR_INSN(loopde);
CHECK_FOR_INSN(loopqe);
CHECK_FOR_INSN(loopwne);
CHECK_FOR_INSN(loopne);
CHECK_FOR_INSN(loopdne);
CHECK_FOR_INSN(loopqne);
CHECK_FOR_INSN(lsl);
CHECK_FOR_INSN(ltr);
CHECK_FOR_INSN(mov);
CHECK_FOR_INSN(movsp);
CHECK_FOR_INSN_RENAME(movs, "movsb");
CHECK_FOR_INSN_RENAME(movs, "movsw");
CHECK_FOR_INSN_RENAME(movs, "movsd");
CHECK_FOR_INSN_RENAME(movs, "movsq");
CHECK_FOR_INSN(movs);
CHECK_FOR_INSN(movsx);
CHECK_FOR_INSN(movzx);
CHECK_FOR_INSN(mul);
CHECK_FOR_INSN(neg);
CHECK_FOR_INSN(nop);
CHECK_FOR_INSN(not);
CHECK_FOR_INSN(or);
CHECK_FOR_INSN(out);
CHECK_FOR_INSN_RENAME(outs, "outsb");
CHECK_FOR_INSN_RENAME(outs, "outsw");
CHECK_FOR_INSN_RENAME(outs, "outsd");
CHECK_FOR_INSN_RENAME(outs, "outsq");
CHECK_FOR_INSN(outs);
CHECK_FOR_INSN(pop);
CHECK_FOR_INSN(popaw);
CHECK_FOR_INSN(popa);
CHECK_FOR_INSN(popad);
CHECK_FOR_INSN(popaq);
CHECK_FOR_INSN(popfw);
CHECK_FOR_INSN(popf);
CHECK_FOR_INSN(popfd);
CHECK_FOR_INSN(popfq);
CHECK_FOR_INSN(push);
CHECK_FOR_INSN(pushaw);
CHECK_FOR_INSN(pusha);
CHECK_FOR_INSN(pushad);
CHECK_FOR_INSN(pushaq);
CHECK_FOR_INSN(pushfw);
CHECK_FOR_INSN(pushf);
CHECK_FOR_INSN(pushfd);
CHECK_FOR_INSN(pushfq);
CHECK_FOR_INSN(rcl);
CHECK_FOR_INSN(rcr);
CHECK_FOR_INSN(rol);
CHECK_FOR_INSN(ror);
CHECK_FOR_INSN(rep);
CHECK_FOR_INSN(repe);
CHECK_FOR_INSN(repne);
CHECK_FOR_INSN_RENAME(retn,"ret");
CHECK_FOR_INSN_RENAME(retn,"retn");
CHECK_FOR_INSN(retf);
CHECK_FOR_INSN(sahf);
CHECK_FOR_INSN(sal);
CHECK_FOR_INSN(sar);
CHECK_FOR_INSN(shl);
CHECK_FOR_INSN(shr);
CHECK_FOR_INSN(sbb);
CHECK_FOR_INSN_RENAME(scas, "scasb");
CHECK_FOR_INSN_RENAME(scas, "scasw");
CHECK_FOR_INSN_RENAME(scas, "scasd");
CHECK_FOR_INSN_RENAME(scas, "scasq");
CHECK_FOR_INSN(scas);
CHECK_FOR_INSN(seta);
CHECK_FOR_INSN(setae);
CHECK_FOR_INSN(setb);
CHECK_FOR_INSN(setbe);
CHECK_FOR_INSN(setc);
CHECK_FOR_INSN(sete);
CHECK_FOR_INSN(setg);
CHECK_FOR_INSN(setge);
CHECK_FOR_INSN(setl);
CHECK_FOR_INSN(setle);
CHECK_FOR_INSN(setna);
CHECK_FOR_INSN(setnae);
CHECK_FOR_INSN(setnb);
CHECK_FOR_INSN(setnbe);
CHECK_FOR_INSN(setnc);
CHECK_FOR_INSN(setne);
CHECK_FOR_INSN(setng);
CHECK_FOR_INSN(setnge);
CHECK_FOR_INSN(setnl);
CHECK_FOR_INSN(setnle);
CHECK_FOR_INSN(setno);
CHECK_FOR_INSN(setnp);
CHECK_FOR_INSN(setns);
CHECK_FOR_INSN(setnz);
CHECK_FOR_INSN(seto);
CHECK_FOR_INSN(setp);
CHECK_FOR_INSN(setpe);
CHECK_FOR_INSN(setpo);
CHECK_FOR_INSN(sets);
CHECK_FOR_INSN(setz);
CHECK_FOR_INSN(sgdt);
CHECK_FOR_INSN(sidt);
CHECK_FOR_INSN(shld);
CHECK_FOR_INSN(shrd);
CHECK_FOR_INSN(sldt);
CHECK_FOR_INSN(smsw);
CHECK_FOR_INSN(stc);
CHECK_FOR_INSN(std);
CHECK_FOR_INSN(sti);
CHECK_FOR_INSN_RENAME(stos, "stosq");
CHECK_FOR_INSN_RENAME(stos, "stosd");
CHECK_FOR_INSN_RENAME(stos, "stosw");
CHECK_FOR_INSN_RENAME(stos, "stosb");
CHECK_FOR_INSN(stos);
CHECK_FOR_INSN(str);
CHECK_FOR_INSN(sub);
CHECK_FOR_INSN(test);
CHECK_FOR_INSN(verr);
CHECK_FOR_INSN(verw);
CHECK_FOR_INSN(wait);
CHECK_FOR_INSN(xchg);
CHECK_FOR_INSN_RENAME(xlat,"xlatb");
CHECK_FOR_INSN_RENAME(xlat,"xlatw");
CHECK_FOR_INSN_RENAME(xlat,"xlatd");
CHECK_FOR_INSN_RENAME(xlat,"xlatq");
CHECK_FOR_INSN(xlat);
CHECK_FOR_INSN(xor);
CHECK_FOR_INSN(cmpxchg);
CHECK_FOR_INSN(bswap);
CHECK_FOR_INSN(xadd);
CHECK_FOR_INSN(invd);
CHECK_FOR_INSN(wbinvd);
CHECK_FOR_INSN(invlpg);
CHECK_FOR_INSN(rdmsr);
CHECK_FOR_INSN(wrmsr);
CHECK_FOR_INSN(cpuid);
CHECK_FOR_INSN(cmpxchg8b);
CHECK_FOR_INSN(rdtsc);
CHECK_FOR_INSN(rsm);
CHECK_FOR_INSN(cmova);
CHECK_FOR_INSN(cmova);
CHECK_FOR_INSN(cmovb);
CHECK_FOR_INSN(cmovbe);
CHECK_FOR_INSN(cmovg);
CHECK_FOR_INSN(cmovge);
CHECK_FOR_INSN(cmovl);
CHECK_FOR_INSN(cmovle);
CHECK_FOR_INSN(cmovnb);
CHECK_FOR_INSN(cmovnb);
CHECK_FOR_INSN(cmovno);
CHECK_FOR_INSN(cmovnp);
CHECK_FOR_INSN(cmovns);
CHECK_FOR_INSN(cmovnz);
CHECK_FOR_INSN(cmovo);
CHECK_FOR_INSN(cmovp);
CHECK_FOR_INSN(cmovs);
CHECK_FOR_INSN(cmovz);
CHECK_FOR_INSN_RENAME(cmova, "cmovnbe");
CHECK_FOR_INSN_RENAME(cmovb, "cmovb");
CHECK_FOR_INSN_RENAME(cmovbe, "cmovbe");
CHECK_FOR_INSN_RENAME(cmovg, "cmovnle");
CHECK_FOR_INSN_RENAME(cmovge, "cmovnl");
CHECK_FOR_INSN_RENAME(cmovl, "cmovl");
CHECK_FOR_INSN_RENAME(cmovle, "cmovle");
CHECK_FOR_INSN_RENAME(cmovnb, "cmovnb");
CHECK_FOR_INSN_RENAME(cmovnb, "cmovae");
CHECK_FOR_INSN_RENAME(cmovno, "cmovno");
CHECK_FOR_INSN_RENAME(cmovnp, "cmovnp");
CHECK_FOR_INSN_RENAME(cmovns, "cmovns");
CHECK_FOR_INSN_RENAME(cmovnz, "cmovne");
CHECK_FOR_INSN_RENAME(cmovo, "cmovo");
CHECK_FOR_INSN_RENAME(cmovp, "cmovp");
CHECK_FOR_INSN_RENAME(cmovs, "cmovs");
CHECK_FOR_INSN_RENAME(cmovz, "cmove");
CHECK_FOR_INSN(fcmovb);
CHECK_FOR_INSN(fcmove);
CHECK_FOR_INSN(fcmovbe);
CHECK_FOR_INSN(fcmovu);
CHECK_FOR_INSN(fcmovnb);
CHECK_FOR_INSN(fcmovne);
CHECK_FOR_INSN(fcmovnbe);
CHECK_FOR_INSN(fcmovnu);
CHECK_FOR_INSN(fcomi);
CHECK_FOR_INSN(fucomi);
CHECK_FOR_INSN(fcomip);
CHECK_FOR_INSN(fucomip);
CHECK_FOR_INSN(rdpmc);
CHECK_FOR_INSN(fld);
CHECK_FOR_INSN(fst);
CHECK_FOR_INSN(fstp);
CHECK_FOR_INSN(fxch);
CHECK_FOR_INSN(fild);
CHECK_FOR_INSN(fist);
CHECK_FOR_INSN(fistp);
CHECK_FOR_INSN(fbld);
CHECK_FOR_INSN(fbstp);
CHECK_FOR_INSN(fadd);
CHECK_FOR_INSN(faddp);
CHECK_FOR_INSN(fiadd);
CHECK_FOR_INSN(fsub);
CHECK_FOR_INSN(fsubp);
CHECK_FOR_INSN(fisub);
CHECK_FOR_INSN(fsubr);
CHECK_FOR_INSN(fsubrp);
CHECK_FOR_INSN(fisubr);
CHECK_FOR_INSN(fmul);
CHECK_FOR_INSN(fmulp);
CHECK_FOR_INSN(fimul);
CHECK_FOR_INSN(fdiv);
CHECK_FOR_INSN(fdivp);
CHECK_FOR_INSN(fidiv);
CHECK_FOR_INSN(fdivr);
CHECK_FOR_INSN(fdivrp);
CHECK_FOR_INSN(fidivr);
CHECK_FOR_INSN(fsqrt);
CHECK_FOR_INSN(fscale);
CHECK_FOR_INSN(fprem);
CHECK_FOR_INSN(frndint);
CHECK_FOR_INSN(fxtract);
CHECK_FOR_INSN(fabs);
CHECK_FOR_INSN(fchs);
CHECK_FOR_INSN(fcom);
CHECK_FOR_INSN(fcomp);
CHECK_FOR_INSN(fcompp);
CHECK_FOR_INSN(ficom);
CHECK_FOR_INSN(ficomp);
CHECK_FOR_INSN(ftst);
CHECK_FOR_INSN(fxam);
CHECK_FOR_INSN(fptan);
CHECK_FOR_INSN(fpatan);
CHECK_FOR_INSN(f2xm1);
CHECK_FOR_INSN(fyl2x);
CHECK_FOR_INSN(fyl2xp1);
CHECK_FOR_INSN(fldz);
CHECK_FOR_INSN(fld1);
CHECK_FOR_INSN(fldpi);
CHECK_FOR_INSN(fldl2t);
CHECK_FOR_INSN(fldl2e);
CHECK_FOR_INSN(fldlg2);
CHECK_FOR_INSN(fldln2);
CHECK_FOR_INSN(finit);
CHECK_FOR_INSN(fninit);
CHECK_FOR_INSN(fsetpm);
CHECK_FOR_INSN(fldcw);
CHECK_FOR_INSN(fstcw);
CHECK_FOR_INSN(fnstcw);
CHECK_FOR_INSN(fstsw);
CHECK_FOR_INSN(fnstsw);
CHECK_FOR_INSN(fclex);
CHECK_FOR_INSN(fnclex);
CHECK_FOR_INSN(fstenv);
CHECK_FOR_INSN(fnstenv);
CHECK_FOR_INSN(fldenv);
CHECK_FOR_INSN(fsave);
CHECK_FOR_INSN(fnsave);
CHECK_FOR_INSN(frstor);
CHECK_FOR_INSN(fincstp);
CHECK_FOR_INSN(fdecstp);
CHECK_FOR_INSN(ffree);
CHECK_FOR_INSN(fnop);
CHECK_FOR_INSN(feni);
CHECK_FOR_INSN(fneni);
CHECK_FOR_INSN(fdisi);
CHECK_FOR_INSN(fndisi);
CHECK_FOR_INSN(fprem1);
CHECK_FOR_INSN(fsincos);
CHECK_FOR_INSN(fsin);
CHECK_FOR_INSN(fcos);
CHECK_FOR_INSN(fucom);
CHECK_FOR_INSN(fucomp);
CHECK_FOR_INSN(fucompp);
CHECK_FOR_INSN(setalc);
CHECK_FOR_INSN(svdc);
CHECK_FOR_INSN(rsdc);
CHECK_FOR_INSN(svldt);
CHECK_FOR_INSN(rsldt);
CHECK_FOR_INSN(svts);
CHECK_FOR_INSN(rsts);
CHECK_FOR_INSN_RENAME(icebp, "int1");
CHECK_FOR_INSN(icebp);
CHECK_FOR_INSN(loadall);
CHECK_FOR_INSN(emms);
CHECK_FOR_INSN(movd);
CHECK_FOR_INSN(movq);
CHECK_FOR_INSN(packsswb);
CHECK_FOR_INSN(packssdw);
CHECK_FOR_INSN(packuswb);
CHECK_FOR_INSN(paddb);
CHECK_FOR_INSN(paddw);
CHECK_FOR_INSN(paddd);
CHECK_FOR_INSN(paddsb);
CHECK_FOR_INSN(paddsw);
CHECK_FOR_INSN(paddusb);
CHECK_FOR_INSN(paddusw);
CHECK_FOR_INSN(pand);
CHECK_FOR_INSN(pandn);
CHECK_FOR_INSN(pcmpeqb);
CHECK_FOR_INSN(pcmpeqw);
CHECK_FOR_INSN(pcmpeqd);
CHECK_FOR_INSN(pcmpgtb);
CHECK_FOR_INSN(pcmpgtw);
CHECK_FOR_INSN(pcmpgtd);
CHECK_FOR_INSN(pmaddwd);
CHECK_FOR_INSN(pmulhw);
CHECK_FOR_INSN(pmullw);
CHECK_FOR_INSN(por);
CHECK_FOR_INSN(psllw);
CHECK_FOR_INSN(pslld);
CHECK_FOR_INSN(psllq);
CHECK_FOR_INSN(psraw);
CHECK_FOR_INSN(psrad);
CHECK_FOR_INSN(psrlw);
CHECK_FOR_INSN(psrld);
CHECK_FOR_INSN(psrlq);
CHECK_FOR_INSN(psubb);
CHECK_FOR_INSN(psubw);
CHECK_FOR_INSN(psubd);
CHECK_FOR_INSN(psubsb);
CHECK_FOR_INSN(psubsw);
CHECK_FOR_INSN(psubusb);
CHECK_FOR_INSN(psubusw);
CHECK_FOR_INSN(punpckhbw);
CHECK_FOR_INSN(punpckhwd);
CHECK_FOR_INSN(punpckhdq);
CHECK_FOR_INSN(punpcklbw);
CHECK_FOR_INSN(punpcklwd);
CHECK_FOR_INSN(punpckldq);
CHECK_FOR_INSN(pxor);
CHECK_FOR_INSN(fxsave);
CHECK_FOR_INSN(fxrstor);
CHECK_FOR_INSN(sysenter);
CHECK_FOR_INSN(sysexit);
CHECK_FOR_INSN(pavgusb);
CHECK_FOR_INSN(pfadd);
CHECK_FOR_INSN(pfsub);
CHECK_FOR_INSN(pfsubr);
CHECK_FOR_INSN(pfacc);
CHECK_FOR_INSN(pfcmpge);
CHECK_FOR_INSN(pfcmpgt);
CHECK_FOR_INSN(pfcmpeq);
CHECK_FOR_INSN(pfmin);
CHECK_FOR_INSN(pfmax);
CHECK_FOR_INSN(pi2fd);
CHECK_FOR_INSN(pf2id);
CHECK_FOR_INSN(pfrcp);
CHECK_FOR_INSN(pfrsqrt);
CHECK_FOR_INSN(pfmul);
CHECK_FOR_INSN(pfrcpit1);
CHECK_FOR_INSN(pfrsqit1);
CHECK_FOR_INSN(pfrcpit2);
CHECK_FOR_INSN(pmulhrw);
CHECK_FOR_INSN(femms);
CHECK_FOR_INSN(prefetch);
CHECK_FOR_INSN(prefetchw);
CHECK_FOR_INSN(addps);
CHECK_FOR_INSN(addss);
CHECK_FOR_INSN(andnps);
CHECK_FOR_INSN(andps);
CHECK_FOR_INSN(cmpps);
CHECK_FOR_INSN(cmpss);
CHECK_FOR_INSN(comiss);
CHECK_FOR_INSN(cvtpi2ps);
CHECK_FOR_INSN(cvtps2pi);
CHECK_FOR_INSN(cvtsi2ss);
CHECK_FOR_INSN(cvtss2si);
CHECK_FOR_INSN(cvttps2pi);
CHECK_FOR_INSN(cvttss2si);
CHECK_FOR_INSN(divps);
CHECK_FOR_INSN(divss);
CHECK_FOR_INSN(ldmxcsr);
CHECK_FOR_INSN(maxps);
CHECK_FOR_INSN(maxss);
CHECK_FOR_INSN(minps);
CHECK_FOR_INSN(minss);
CHECK_FOR_INSN(movaps);
CHECK_FOR_INSN(movhlps);
CHECK_FOR_INSN(movhps);
CHECK_FOR_INSN(movlhps);
CHECK_FOR_INSN(movlps);
CHECK_FOR_INSN(movmskps);
CHECK_FOR_INSN(movss);
CHECK_FOR_INSN(movups);
CHECK_FOR_INSN(mulps);
CHECK_FOR_INSN(mulss);
CHECK_FOR_INSN(orps);
CHECK_FOR_INSN(rcpps);
CHECK_FOR_INSN(rcpss);
CHECK_FOR_INSN(rsqrtps);
CHECK_FOR_INSN(rsqrtss);
CHECK_FOR_INSN(shufps);
CHECK_FOR_INSN(sqrtps);
CHECK_FOR_INSN(sqrtss);
CHECK_FOR_INSN(stmxcsr);
CHECK_FOR_INSN(subps);
CHECK_FOR_INSN(subss);
CHECK_FOR_INSN(ucomiss);
CHECK_FOR_INSN(unpckhps);
CHECK_FOR_INSN(unpcklps);
CHECK_FOR_INSN(xorps);
CHECK_FOR_INSN(pavgb);
CHECK_FOR_INSN(pavgw);
CHECK_FOR_INSN(pextrw);
CHECK_FOR_INSN(pinsrw);
CHECK_FOR_INSN(pmaxsw);
CHECK_FOR_INSN(pmaxub);
CHECK_FOR_INSN(pminsw);
CHECK_FOR_INSN(pminub);
CHECK_FOR_INSN(pmovmskb);
CHECK_FOR_INSN(pmulhuw);
CHECK_FOR_INSN(psadbw);
CHECK_FOR_INSN(pshufw);
CHECK_FOR_INSN(maskmovq);
CHECK_FOR_INSN(movntps);
CHECK_FOR_INSN(movntq);
CHECK_FOR_INSN(prefetcht0);
CHECK_FOR_INSN_RENAME(prefetcht0, "prefetchT0");
CHECK_FOR_INSN(prefetcht1);
CHECK_FOR_INSN_RENAME(prefetcht1, "prefetchT1");
CHECK_FOR_INSN(prefetcht2);
CHECK_FOR_INSN_RENAME(prefetcht2, "prefetchT2");
CHECK_FOR_INSN_RENAME(prefetchnta, "prefetchNTA"); // beaengine rename
CHECK_FOR_INSN(prefetchnta); // capstone needs no rename
CHECK_FOR_INSN(sfence);
CHECK_FOR_INSN(cmpeqps);
CHECK_FOR_INSN(cmpltps);
CHECK_FOR_INSN(cmpleps);
CHECK_FOR_INSN(cmpunordps);
CHECK_FOR_INSN(cmpneqps);
CHECK_FOR_INSN(cmpnltps);
CHECK_FOR_INSN(cmpnleps);
CHECK_FOR_INSN(cmpordps);
CHECK_FOR_INSN(cmpeqss);
CHECK_FOR_INSN(cmpltss);
CHECK_FOR_INSN(cmpless);
CHECK_FOR_INSN(cmpunordss);
CHECK_FOR_INSN(cmpneqss);
CHECK_FOR_INSN(cmpnltss);
CHECK_FOR_INSN(cmpnless);
CHECK_FOR_INSN(cmpordss);
CHECK_FOR_INSN(pf2iw);
CHECK_FOR_INSN(pfnacc);
CHECK_FOR_INSN(pfpnacc);
CHECK_FOR_INSN(pi2fw);
CHECK_FOR_INSN(pswapd);
CHECK_FOR_INSN(fstp1);
CHECK_FOR_INSN(fcom2);
CHECK_FOR_INSN(fcomp3);
CHECK_FOR_INSN(fxch4);
CHECK_FOR_INSN(fcomp5);
CHECK_FOR_INSN(ffreep);
CHECK_FOR_INSN(fxch7);
CHECK_FOR_INSN(fstp8);
CHECK_FOR_INSN(fstp9);
CHECK_FOR_INSN(addpd);
CHECK_FOR_INSN(addsd);
CHECK_FOR_INSN(andnpd);
CHECK_FOR_INSN(andpd);
CHECK_FOR_INSN(clflush);
CHECK_FOR_INSN(cmppd);
CHECK_FOR_INSN(cmpsd);
CHECK_FOR_INSN(comisd);
CHECK_FOR_INSN(cvtdq2pd);
CHECK_FOR_INSN(cvtdq2ps);
CHECK_FOR_INSN(cvtpd2dq);
CHECK_FOR_INSN(cvtpd2pi);
CHECK_FOR_INSN(cvtpd2ps);
CHECK_FOR_INSN(cvtpi2pd);
CHECK_FOR_INSN(cvtps2dq);
CHECK_FOR_INSN(cvtps2pd);
CHECK_FOR_INSN(cvtsd2si);
CHECK_FOR_INSN(cvtsd2ss);
CHECK_FOR_INSN(cvtsi2sd);
CHECK_FOR_INSN(cvtss2sd);
CHECK_FOR_INSN(cvttpd2dq);
CHECK_FOR_INSN(cvttpd2pi);
CHECK_FOR_INSN(cvttps2dq);
CHECK_FOR_INSN(cvttsd2si);
CHECK_FOR_INSN(divpd);
CHECK_FOR_INSN(divsd);
CHECK_FOR_INSN(lfence);
CHECK_FOR_INSN(maskmovdqu);
CHECK_FOR_INSN(maxpd);
CHECK_FOR_INSN(maxsd);
CHECK_FOR_INSN(mfence);
CHECK_FOR_INSN(minpd);
CHECK_FOR_INSN(minsd);
CHECK_FOR_INSN(movapd);
CHECK_FOR_INSN(movdq2q);
CHECK_FOR_INSN(movdqa);
CHECK_FOR_INSN(movdqu);
CHECK_FOR_INSN(movhpd);
CHECK_FOR_INSN(movlpd);
CHECK_FOR_INSN(movmskpd);
CHECK_FOR_INSN(movntdq);
CHECK_FOR_INSN(movnti);
CHECK_FOR_INSN(movntpd);
CHECK_FOR_INSN(movq2dq);
CHECK_FOR_INSN(movsd);
CHECK_FOR_INSN(movupd);
CHECK_FOR_INSN(mulpd);
CHECK_FOR_INSN(mulsd);
CHECK_FOR_INSN(orpd);
CHECK_FOR_INSN(paddq);
CHECK_FOR_INSN(pause);
CHECK_FOR_INSN(pmuludq);
CHECK_FOR_INSN(pshufd);
CHECK_FOR_INSN(pshufhw);
CHECK_FOR_INSN(pshuflw);
CHECK_FOR_INSN(pslldq);
CHECK_FOR_INSN(psrldq);
CHECK_FOR_INSN(psubq);
CHECK_FOR_INSN(punpckhqdq);
CHECK_FOR_INSN(punpcklqdq);
CHECK_FOR_INSN(shufpd);
CHECK_FOR_INSN(sqrtpd);
CHECK_FOR_INSN(sqrtsd);
CHECK_FOR_INSN(subpd);
CHECK_FOR_INSN(subsd);
CHECK_FOR_INSN(ucomisd);
CHECK_FOR_INSN(unpckhpd);
CHECK_FOR_INSN(unpcklpd);
CHECK_FOR_INSN(xorpd);
CHECK_FOR_INSN(syscall);
CHECK_FOR_INSN(sysret);
CHECK_FOR_INSN(swapgs);
CHECK_FOR_INSN(movddup);
CHECK_FOR_INSN(movshdup);
CHECK_FOR_INSN(movsldup);
CHECK_FOR_INSN(movsxd);
CHECK_FOR_INSN(cmpxchg16b);
CHECK_FOR_INSN(addsubpd);
CHECK_FOR_INSN(addsubps);
CHECK_FOR_INSN(haddpd);
CHECK_FOR_INSN(haddps);
CHECK_FOR_INSN(hsubpd);
CHECK_FOR_INSN(hsubps);
CHECK_FOR_INSN(monitor);
CHECK_FOR_INSN(mwait);
CHECK_FOR_INSN(fisttp);
CHECK_FOR_INSN(lddqu);
CHECK_FOR_INSN(psignb);
CHECK_FOR_INSN(psignw);
CHECK_FOR_INSN(psignd);
CHECK_FOR_INSN(pshufb);
CHECK_FOR_INSN(pmulhrsw);
CHECK_FOR_INSN(pmaddubsw);
CHECK_FOR_INSN(phsubsw);
CHECK_FOR_INSN(phaddsw);
CHECK_FOR_INSN(phaddw);
CHECK_FOR_INSN(phaddd);
CHECK_FOR_INSN(phsubw);
CHECK_FOR_INSN(phsubd);
CHECK_FOR_INSN(palignr);
CHECK_FOR_INSN(pabsb);
CHECK_FOR_INSN(pabsw);
CHECK_FOR_INSN(pabsd);
CHECK_FOR_INSN(vmcall);
CHECK_FOR_INSN(vmclear);
CHECK_FOR_INSN(vmlaunch);
CHECK_FOR_INSN(vmresume);
CHECK_FOR_INSN(vmptrld);
CHECK_FOR_INSN(vmptrst);
CHECK_FOR_INSN(vmread);
CHECK_FOR_INSN(vmwrite);
CHECK_FOR_INSN(vmxoff);
CHECK_FOR_INSN(vmxon);
CHECK_FOR_INSN(ud2);
CHECK_FOR_INSN(rdtscp);
CHECK_FOR_INSN(pfrcpv);
CHECK_FOR_INSN(pfrsqrtv);
CHECK_FOR_INSN(cmpeqpd);
CHECK_FOR_INSN(cmpltpd);
CHECK_FOR_INSN(cmplepd);
CHECK_FOR_INSN(cmpunordpd);
CHECK_FOR_INSN(cmpneqpd);
CHECK_FOR_INSN(cmpnltpd);
CHECK_FOR_INSN(cmpnlepd);
CHECK_FOR_INSN(cmpordpd);
CHECK_FOR_INSN(cmpeqsd);
CHECK_FOR_INSN(cmpltsd);
CHECK_FOR_INSN(cmplesd);
CHECK_FOR_INSN(cmpunordsd);
CHECK_FOR_INSN(cmpneqsd);
CHECK_FOR_INSN(cmpnltsd);
CHECK_FOR_INSN(cmpnlesd);
CHECK_FOR_INSN(cmpordsd);
CHECK_FOR_INSN(blendpd);
CHECK_FOR_INSN(blendps);
CHECK_FOR_INSN(blendvpd);
CHECK_FOR_INSN(blendvps);
CHECK_FOR_INSN(dppd);
CHECK_FOR_INSN(dpps);
CHECK_FOR_INSN(extractps);
CHECK_FOR_INSN(insertps);
CHECK_FOR_INSN(movntdqa);
CHECK_FOR_INSN(mpsadbw);
CHECK_FOR_INSN(packusdw);
CHECK_FOR_INSN(pblendvb);
CHECK_FOR_INSN(pblendw);
CHECK_FOR_INSN(pcmpeqq);
CHECK_FOR_INSN(pextrb);
CHECK_FOR_INSN(pextrd);
CHECK_FOR_INSN(pextrq);
CHECK_FOR_INSN(phminposuw);
CHECK_FOR_INSN(pinsrb);
CHECK_FOR_INSN(pinsrd);
CHECK_FOR_INSN(pinsrq);
CHECK_FOR_INSN(pmaxsb);
CHECK_FOR_INSN(pmaxsd);
CHECK_FOR_INSN(pmaxud);
CHECK_FOR_INSN(pmaxuw);
CHECK_FOR_INSN(pminsb);
CHECK_FOR_INSN(pminsd);
CHECK_FOR_INSN(pminud);
CHECK_FOR_INSN(pminuw);
CHECK_FOR_INSN(pmovsxbw);
CHECK_FOR_INSN(pmovsxbd);
CHECK_FOR_INSN(pmovsxbq);
CHECK_FOR_INSN(pmovsxwd);
CHECK_FOR_INSN(pmovsxwq);
CHECK_FOR_INSN(pmovsxdq);
CHECK_FOR_INSN(pmovzxbw);
CHECK_FOR_INSN(pmovzxbd);
CHECK_FOR_INSN(pmovzxbq);
CHECK_FOR_INSN(pmovzxwd);
CHECK_FOR_INSN(pmovzxwq);
CHECK_FOR_INSN(pmovzxdq);
CHECK_FOR_INSN(pmuldq);
CHECK_FOR_INSN(pmulld);
CHECK_FOR_INSN(ptest);
CHECK_FOR_INSN(roundpd);
CHECK_FOR_INSN(roundps);
CHECK_FOR_INSN(roundsd);
CHECK_FOR_INSN(roundss);
CHECK_FOR_INSN(crc32);
CHECK_FOR_INSN(pcmpestri);
CHECK_FOR_INSN(pcmpestrm);
CHECK_FOR_INSN(pcmpistri);
CHECK_FOR_INSN(pcmpistrm);
CHECK_FOR_INSN(pcmpgtq);
CHECK_FOR_INSN(popcnt);
CHECK_FOR_INSN(extrq);
CHECK_FOR_INSN(insertq);
CHECK_FOR_INSN(movntsd);
CHECK_FOR_INSN(movntss);
CHECK_FOR_INSN(lzcnt);
CHECK_FOR_INSN(xgetbv);
CHECK_FOR_INSN(xrstor);
CHECK_FOR_INSN(xsave);
CHECK_FOR_INSN(xsetbv);
CHECK_FOR_INSN(getsec);
CHECK_FOR_INSN(clgi);
CHECK_FOR_INSN(invlpga);
CHECK_FOR_INSN(skinit);
CHECK_FOR_INSN(stgi);
CHECK_FOR_INSN(vmexit);
CHECK_FOR_INSN(vmload);
CHECK_FOR_INSN(vmmcall);
CHECK_FOR_INSN(vmrun);
CHECK_FOR_INSN(vmsave);
CHECK_FOR_INSN(invept);
CHECK_FOR_INSN(invvpid);
CHECK_FOR_INSN(movbe);
CHECK_FOR_INSN(aesenc);
CHECK_FOR_INSN(aesenclast);
CHECK_FOR_INSN(aesdec);
CHECK_FOR_INSN(aesdeclast);
CHECK_FOR_INSN(aesimc);
CHECK_FOR_INSN(aeskeygenassist);
CHECK_FOR_INSN(pclmulqdq);
CHECK_FOR_INSN_RENAME(pclmulqdq, "pclmulqdq");
CHECK_FOR_INSN_RENAME(pclmulqdq, "pclmullqlqdq");
CHECK_FOR_INSN_RENAME(pclmulqdq, "pclmulhqlqdq");
CHECK_FOR_INSN_RENAME(pclmulqdq, "pclmullqhqdq");
CHECK_FOR_INSN_RENAME(pclmulqdq, "pclmulhqhqdq");
CHECK_FOR_INSN(retnw);
CHECK_FOR_INSN(retnd);
CHECK_FOR_INSN(retnq);
CHECK_FOR_INSN(retfw);
CHECK_FOR_INSN(retfd);
CHECK_FOR_INSN(retfq);
CHECK_FOR_INSN(rdrand);
CHECK_FOR_INSN(adcx);
CHECK_FOR_INSN(adox);
CHECK_FOR_INSN(andn);
CHECK_FOR_INSN(bextr);
CHECK_FOR_INSN(blsi);
CHECK_FOR_INSN(blsmsk);
CHECK_FOR_INSN(blsr);
CHECK_FOR_INSN(bzhi);
CHECK_FOR_INSN(clac);
CHECK_FOR_INSN(mulx);
CHECK_FOR_INSN(pdep);
CHECK_FOR_INSN(pext);
CHECK_FOR_INSN(rorx);
CHECK_FOR_INSN(sarx);
CHECK_FOR_INSN(shlx);
CHECK_FOR_INSN(shrx);
CHECK_FOR_INSN(stac);
CHECK_FOR_INSN(tzcnt);
CHECK_FOR_INSN(xsaveopt);
CHECK_FOR_INSN(invpcid);
CHECK_FOR_INSN(rdseed);
CHECK_FOR_INSN(rdfsbase);
CHECK_FOR_INSN(rdgsbase);
CHECK_FOR_INSN(wrfsbase);
CHECK_FOR_INSN(wrgsbase);
CHECK_FOR_INSN(vaddpd);
CHECK_FOR_INSN(vaddps);
CHECK_FOR_INSN(vaddsd);
CHECK_FOR_INSN(vaddss);
CHECK_FOR_INSN(vaddsubpd);
CHECK_FOR_INSN(vaddsubps);
CHECK_FOR_INSN(vaesdec);
CHECK_FOR_INSN(vaesdeclast);
CHECK_FOR_INSN(vaesenc);
CHECK_FOR_INSN(vaesenclast);
CHECK_FOR_INSN(vaesimc);
CHECK_FOR_INSN(vaeskeygenassist);
CHECK_FOR_INSN(vandnpd);
CHECK_FOR_INSN(vandnps);
CHECK_FOR_INSN(vandpd);
CHECK_FOR_INSN(vandps);
CHECK_FOR_INSN(vblendpd);
CHECK_FOR_INSN(vblendps);
CHECK_FOR_INSN(vblendvpd);
CHECK_FOR_INSN(vblendvps);
CHECK_FOR_INSN(vbroadcastf128);
CHECK_FOR_INSN(vbroadcasti128);
CHECK_FOR_INSN(vbroadcastsd);
CHECK_FOR_INSN(vbroadcastss);
CHECK_FOR_INSN(vcmppd);
CHECK_FOR_INSN(vcmpps);
CHECK_FOR_INSN(vcmpsd);
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpeqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpltsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmplesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpunordsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpneqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpnltsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpnlesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpordsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpeq_uqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpngesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpngtsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpfalsesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpneq_oqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpgesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpeqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpltsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmplesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpunordsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpneqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpnltsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpnlesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpordsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpeq_uqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpngesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpngtsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpfalsesd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpneq_oqsd");
CHECK_FOR_INSN_RENAME(vcmpsd,"vcmpgesd");
CHECK_FOR_INSN(vcmpss);
CHECK_FOR_INSN(vcomisd);
CHECK_FOR_INSN(vcomiss);
CHECK_FOR_INSN(vcvtdq2pd);
CHECK_FOR_INSN(vcvtdq2ps);
CHECK_FOR_INSN(vcvtpd2dq);
CHECK_FOR_INSN(vcvtpd2ps);
CHECK_FOR_INSN(vcvtph2ps);
CHECK_FOR_INSN(vcvtps2dq);
CHECK_FOR_INSN(vcvtps2pd);
CHECK_FOR_INSN(vcvtps2ph);
CHECK_FOR_INSN(vcvtsd2si);
CHECK_FOR_INSN(vcvtsd2ss);
CHECK_FOR_INSN(vcvtsi2sd);
CHECK_FOR_INSN(vcvtsi2ss);
CHECK_FOR_INSN(vcvtss2sd);
CHECK_FOR_INSN(vcvtss2si);
CHECK_FOR_INSN(vcvttpd2dq);
CHECK_FOR_INSN(vcvttps2dq);
CHECK_FOR_INSN(vcvttsd2si);
CHECK_FOR_INSN(vcvttss2si);
CHECK_FOR_INSN(vdivpd);
CHECK_FOR_INSN(vdivps);
CHECK_FOR_INSN(vdivsd);
CHECK_FOR_INSN(vdivss);
CHECK_FOR_INSN(vdppd);
CHECK_FOR_INSN(vdpps);
CHECK_FOR_INSN(vextractf128);
CHECK_FOR_INSN(vextracti128);
CHECK_FOR_INSN(vextractps);
CHECK_FOR_INSN(vfmadd132pd);
CHECK_FOR_INSN(vfmadd132ps);
CHECK_FOR_INSN(vfmadd132sd);
CHECK_FOR_INSN(vfmadd132ss);
CHECK_FOR_INSN(vfmadd213pd);
CHECK_FOR_INSN(vfmadd213ps);
CHECK_FOR_INSN(vfmadd213sd);
CHECK_FOR_INSN(vfmadd213ss);
CHECK_FOR_INSN(vfmadd231pd);
CHECK_FOR_INSN(vfmadd231ps);
CHECK_FOR_INSN(vfmadd231sd);
CHECK_FOR_INSN(vfmadd231ss);
CHECK_FOR_INSN(vfmaddsub132pd);
CHECK_FOR_INSN(vfmaddsub132ps);
CHECK_FOR_INSN(vfmaddsub213pd);
CHECK_FOR_INSN(vfmaddsub213ps);
CHECK_FOR_INSN(vfmaddsub231pd);
CHECK_FOR_INSN(vfmaddsub231ps);
CHECK_FOR_INSN(vfmsub132pd);
CHECK_FOR_INSN(vfmsub132ps);
CHECK_FOR_INSN(vfmsub132sd);
CHECK_FOR_INSN(vfmsub132ss);
CHECK_FOR_INSN(vfmsub213pd);
CHECK_FOR_INSN(vfmsub213ps);
CHECK_FOR_INSN(vfmsub213sd);
CHECK_FOR_INSN(vfmsub213ss);
CHECK_FOR_INSN(vfmsub231pd);
CHECK_FOR_INSN(vfmsub231ps);
CHECK_FOR_INSN(vfmsub231sd);
CHECK_FOR_INSN(vfmsub231ss);
CHECK_FOR_INSN(vfmsubadd132pd);
CHECK_FOR_INSN(vfmsubadd132ps);
CHECK_FOR_INSN(vfmsubadd213pd);
CHECK_FOR_INSN(vfmsubadd213ps);
CHECK_FOR_INSN(vfmsubadd231pd);
CHECK_FOR_INSN(vfmsubadd231ps);
CHECK_FOR_INSN(vfnmadd132pd);
CHECK_FOR_INSN(vfnmadd132ps);
CHECK_FOR_INSN(vfnmadd132sd);
CHECK_FOR_INSN(vfnmadd132ss);
CHECK_FOR_INSN(vfnmadd213pd);
CHECK_FOR_INSN(vfnmadd213ps);
CHECK_FOR_INSN(vfnmadd213sd);
CHECK_FOR_INSN(vfnmadd213ss);
CHECK_FOR_INSN(vfnmadd231pd);
CHECK_FOR_INSN(vfnmadd231ps);
CHECK_FOR_INSN(vfnmadd231sd);
CHECK_FOR_INSN(vfnmadd231ss);
CHECK_FOR_INSN(vfnmsub132pd);
CHECK_FOR_INSN(vfnmsub132ps);
CHECK_FOR_INSN(vfnmsub132sd);
CHECK_FOR_INSN(vfnmsub132ss);
CHECK_FOR_INSN(vfnmsub213pd);
CHECK_FOR_INSN(vfnmsub213ps);
CHECK_FOR_INSN(vfnmsub213sd);
CHECK_FOR_INSN(vfnmsub213ss);
CHECK_FOR_INSN(vfnmsub231pd);
CHECK_FOR_INSN(vfnmsub231ps);
CHECK_FOR_INSN(vfnmsub231sd);
CHECK_FOR_INSN(vfnmsub231ss);
CHECK_FOR_INSN(vgatherdps);
CHECK_FOR_INSN(vgatherdpd);
CHECK_FOR_INSN(vgatherqps);
CHECK_FOR_INSN(vgatherqpd);
CHECK_FOR_INSN(vhaddpd);
CHECK_FOR_INSN(vhaddps);
CHECK_FOR_INSN(vhsubpd);
CHECK_FOR_INSN(vhsubps);
CHECK_FOR_INSN(vinsertf128);
CHECK_FOR_INSN(vinserti128);
CHECK_FOR_INSN(vinsertps);
CHECK_FOR_INSN(vlddqu);
CHECK_FOR_INSN(vldmxcsr);
CHECK_FOR_INSN(vmaskmovdqu);
CHECK_FOR_INSN(vmaskmovpd);
CHECK_FOR_INSN(vmaskmovps);
CHECK_FOR_INSN(vmaxpd);
CHECK_FOR_INSN(vmaxps);
CHECK_FOR_INSN(vmaxsd);
CHECK_FOR_INSN(vmaxss);
CHECK_FOR_INSN(vminpd);
CHECK_FOR_INSN(vminps);
CHECK_FOR_INSN(vminsd);
CHECK_FOR_INSN(vminss);
CHECK_FOR_INSN(vmovapd);
CHECK_FOR_INSN(vmovaps);
CHECK_FOR_INSN(vmovd);
CHECK_FOR_INSN(vmovddup);
CHECK_FOR_INSN(vmovdqa);
CHECK_FOR_INSN(vmovdqu);
CHECK_FOR_INSN(vmovhlps);
CHECK_FOR_INSN(vmovhpd);
CHECK_FOR_INSN(vmovhps);
CHECK_FOR_INSN(vmovlhps);
CHECK_FOR_INSN(vmovlpd);
CHECK_FOR_INSN(vmovlps);
CHECK_FOR_INSN(vmovmskpd);
CHECK_FOR_INSN(vmovmskps);
CHECK_FOR_INSN(vmovntdq);
CHECK_FOR_INSN(vmovntdqa);
CHECK_FOR_INSN(vmovntpd);
CHECK_FOR_INSN(vmovntps);
#if (IDA_SDK_VERSION < 700) // Incredibly, these opcodes were removed in IDA Pro 7.0
CHECK_FOR_INSN(vmovntsd);
CHECK_FOR_INSN(vmovntss);
#endif
CHECK_FOR_INSN(vmovq);
CHECK_FOR_INSN(vmovsd);
CHECK_FOR_INSN(vmovshdup);
CHECK_FOR_INSN(vmovsldup);
CHECK_FOR_INSN(vmovss);
CHECK_FOR_INSN(vmovupd);
CHECK_FOR_INSN(vmovups);
CHECK_FOR_INSN(vmpsadbw);
CHECK_FOR_INSN(vmulpd);
CHECK_FOR_INSN(vmulps);
CHECK_FOR_INSN(vmulsd);
CHECK_FOR_INSN(vmulss);
CHECK_FOR_INSN(vorpd);
CHECK_FOR_INSN(vorps);
CHECK_FOR_INSN(vpabsb);
CHECK_FOR_INSN(vpabsd);
CHECK_FOR_INSN(vpabsw);
CHECK_FOR_INSN(vpackssdw);
CHECK_FOR_INSN(vpacksswb);
CHECK_FOR_INSN(vpackusdw);
CHECK_FOR_INSN(vpackuswb);
CHECK_FOR_INSN(vpaddb);
CHECK_FOR_INSN(vpaddd);
CHECK_FOR_INSN(vpaddq);
CHECK_FOR_INSN(vpaddsb);
CHECK_FOR_INSN(vpaddsw);
CHECK_FOR_INSN(vpaddusb);
CHECK_FOR_INSN(vpaddusw);
CHECK_FOR_INSN(vpaddw);
CHECK_FOR_INSN(vpalignr);
CHECK_FOR_INSN(vpand);
CHECK_FOR_INSN(vpandn);
CHECK_FOR_INSN(vpavgb);
CHECK_FOR_INSN(vpavgw);
CHECK_FOR_INSN(vpblendd);
CHECK_FOR_INSN(vpblendvb);
CHECK_FOR_INSN(vpblendw);
CHECK_FOR_INSN(vpbroadcastb);
CHECK_FOR_INSN(vpbroadcastd);
CHECK_FOR_INSN(vpbroadcastq);
CHECK_FOR_INSN(vpbroadcastw);
CHECK_FOR_INSN(vpclmulqdq);
CHECK_FOR_INSN(vpcmpeqb);
CHECK_FOR_INSN(vpcmpeqd);
CHECK_FOR_INSN(vpcmpeqq);
CHECK_FOR_INSN(vpcmpeqw);
CHECK_FOR_INSN(vpcmpestri);
CHECK_FOR_INSN(vpcmpestrm);
CHECK_FOR_INSN(vpcmpgtb);
CHECK_FOR_INSN(vpcmpgtd);
CHECK_FOR_INSN(vpcmpgtq);
CHECK_FOR_INSN(vpcmpgtw);
CHECK_FOR_INSN(vpcmpistri);
CHECK_FOR_INSN(vpcmpistrm);
CHECK_FOR_INSN(vperm2f128);
CHECK_FOR_INSN(vperm2i128);
CHECK_FOR_INSN(vpermd);
CHECK_FOR_INSN(vpermilpd);
CHECK_FOR_INSN(vpermilps);
CHECK_FOR_INSN(vpermpd);
CHECK_FOR_INSN(vpermps);
CHECK_FOR_INSN(vpermq);
CHECK_FOR_INSN(vpextrb);
CHECK_FOR_INSN(vpextrd);
CHECK_FOR_INSN(vpextrq);
CHECK_FOR_INSN(vpextrw);
CHECK_FOR_INSN(vpgatherdd);
CHECK_FOR_INSN(vpgatherdq);
CHECK_FOR_INSN(vpgatherqd);
CHECK_FOR_INSN(vpgatherqq);
CHECK_FOR_INSN(vphaddd);
CHECK_FOR_INSN(vphaddsw);
CHECK_FOR_INSN(vphaddw);
CHECK_FOR_INSN(vphminposuw);
CHECK_FOR_INSN(vphsubd);
CHECK_FOR_INSN(vphsubsw);
CHECK_FOR_INSN(vphsubw);
CHECK_FOR_INSN(vpinsrb);
CHECK_FOR_INSN(vpinsrd);
CHECK_FOR_INSN(vpinsrq);
CHECK_FOR_INSN(vpinsrw);
CHECK_FOR_INSN(vpmaddubsw);
CHECK_FOR_INSN(vpmaddwd);
CHECK_FOR_INSN(vpmaskmovd);
CHECK_FOR_INSN(vpmaskmovq);
CHECK_FOR_INSN(vpmaxsb);
CHECK_FOR_INSN(vpmaxsd);
CHECK_FOR_INSN(vpmaxsw);
CHECK_FOR_INSN(vpmaxub);
CHECK_FOR_INSN(vpmaxud);
CHECK_FOR_INSN(vpmaxuw);
CHECK_FOR_INSN(vpminsb);
CHECK_FOR_INSN(vpminsd);
CHECK_FOR_INSN(vpminsw);
CHECK_FOR_INSN(vpminub);
CHECK_FOR_INSN(vpminud);
CHECK_FOR_INSN(vpminuw);
CHECK_FOR_INSN(vpmovmskb);
CHECK_FOR_INSN(vpmovsxbd);
CHECK_FOR_INSN(vpmovsxbq);
CHECK_FOR_INSN(vpmovsxbw);
CHECK_FOR_INSN(vpmovsxdq);
CHECK_FOR_INSN(vpmovsxwd);
CHECK_FOR_INSN(vpmovsxwq);
CHECK_FOR_INSN(vpmovzxbd);
CHECK_FOR_INSN(vpmovzxbq);
CHECK_FOR_INSN(vpmovzxbw);
CHECK_FOR_INSN(vpmovzxdq);
CHECK_FOR_INSN(vpmovzxwd);
CHECK_FOR_INSN(vpmovzxwq);
CHECK_FOR_INSN(vpmuldq);
CHECK_FOR_INSN(vpmulhrsw);
CHECK_FOR_INSN(vpmulhuw);
CHECK_FOR_INSN(vpmulhw);
CHECK_FOR_INSN(vpmulld);
CHECK_FOR_INSN(vpmullw);
CHECK_FOR_INSN(vpmuludq);
CHECK_FOR_INSN(vpor);
CHECK_FOR_INSN(vpsadbw);
CHECK_FOR_INSN(vpshufb);
CHECK_FOR_INSN(vpshufd);
CHECK_FOR_INSN(vpshufhw);
CHECK_FOR_INSN(vpshuflw);
CHECK_FOR_INSN(vpsignb);
CHECK_FOR_INSN(vpsignd);
CHECK_FOR_INSN(vpsignw);
CHECK_FOR_INSN(vpslld);
CHECK_FOR_INSN(vpslldq);
CHECK_FOR_INSN(vpsllq);
CHECK_FOR_INSN(vpsllvd);
CHECK_FOR_INSN(vpsllvq);
CHECK_FOR_INSN(vpsllw);
CHECK_FOR_INSN(vpsrad);
CHECK_FOR_INSN(vpsravd);
CHECK_FOR_INSN(vpsraw);
CHECK_FOR_INSN(vpsrld);
CHECK_FOR_INSN(vpsrldq);
CHECK_FOR_INSN(vpsrlq);
CHECK_FOR_INSN(vpsrlvd);
CHECK_FOR_INSN(vpsrlvq);
CHECK_FOR_INSN(vpsrlw);
CHECK_FOR_INSN(vpsubb);
CHECK_FOR_INSN(vpsubd);
CHECK_FOR_INSN(vpsubq);
CHECK_FOR_INSN(vpsubsb);
CHECK_FOR_INSN(vpsubsw);
CHECK_FOR_INSN(vpsubusb);
CHECK_FOR_INSN(vpsubusw);
CHECK_FOR_INSN(vpsubw);
CHECK_FOR_INSN(vptest);
CHECK_FOR_INSN(vpunpckhbw);
CHECK_FOR_INSN(vpunpckhdq);
CHECK_FOR_INSN(vpunpckhqdq);
CHECK_FOR_INSN(vpunpckhwd);
CHECK_FOR_INSN(vpunpcklbw);
CHECK_FOR_INSN(vpunpckldq);
CHECK_FOR_INSN(vpunpcklqdq);
CHECK_FOR_INSN(vpunpcklwd);
CHECK_FOR_INSN(vpxor);
CHECK_FOR_INSN(vrcpps);
CHECK_FOR_INSN(vrcpss);
CHECK_FOR_INSN(vroundpd);
CHECK_FOR_INSN(vroundps);
CHECK_FOR_INSN(vroundsd);
CHECK_FOR_INSN(vroundss);
CHECK_FOR_INSN(vrsqrtps);
CHECK_FOR_INSN(vrsqrtss);
CHECK_FOR_INSN(vshufpd);
CHECK_FOR_INSN(vshufps);
CHECK_FOR_INSN(vsqrtpd);
CHECK_FOR_INSN(vsqrtps);
CHECK_FOR_INSN(vsqrtsd);
CHECK_FOR_INSN(vsqrtss);
CHECK_FOR_INSN(vstmxcsr);
CHECK_FOR_INSN(vsubpd);
CHECK_FOR_INSN(vsubps);
CHECK_FOR_INSN(vsubsd);
CHECK_FOR_INSN(vsubss);
CHECK_FOR_INSN(vtestpd);
CHECK_FOR_INSN(vtestps);
CHECK_FOR_INSN(vucomisd);
CHECK_FOR_INSN(vucomiss);
CHECK_FOR_INSN(vunpckhpd);
CHECK_FOR_INSN(vunpckhps);
CHECK_FOR_INSN(vunpcklpd);
CHECK_FOR_INSN(vunpcklps);
CHECK_FOR_INSN(vxorpd);
CHECK_FOR_INSN(vxorps);
CHECK_FOR_INSN(vzeroall);
CHECK_FOR_INSN(vzeroupper);
CHECK_FOR_INSN(xabort);
CHECK_FOR_INSN(xbegin);
CHECK_FOR_INSN(xend);
CHECK_FOR_INSN(xtest);
CHECK_FOR_INSN(vmgetinfo);
CHECK_FOR_INSN(vmsetinfo);
CHECK_FOR_INSN(vmdxdsbl);
CHECK_FOR_INSN(vmdxenbl);
CHECK_FOR_INSN(vmcpuid);
CHECK_FOR_INSN(vmhlt);
CHECK_FOR_INSN(vmsplaf);
CHECK_FOR_INSN(vmpushfd);
CHECK_FOR_INSN(vmpopfd);
CHECK_FOR_INSN(vmcli);
CHECK_FOR_INSN(vmsti);
CHECK_FOR_INSN(vmiretd);
CHECK_FOR_INSN(vmsgdt);
CHECK_FOR_INSN(vmsidt);
CHECK_FOR_INSN(vmsldt);
CHECK_FOR_INSN(vmstr);
CHECK_FOR_INSN(vmsdte);
CHECK_FOR_INSN(vpcext);
CHECK_FOR_INSN(vfmaddsubps); // Multiply with Alternating Add/Subtract of Packed Single-Precision Floating-Point
CHECK_FOR_INSN(vfmaddsubpd); // Multiply with Alternating Add/Subtract of Packed Double-Precision Floating-Point
CHECK_FOR_INSN(vfmsubaddps); // Multiply with Alternating Subtract/Add of Packed Single-Precision Floating-Point
CHECK_FOR_INSN(vfmsubaddpd); // Multiply with Alternating Subtract/Add of Packed Double-Precision Floating-Point
CHECK_FOR_INSN(vfmaddps); // Multiply and Add Packed Single-Precision Floating-Point
CHECK_FOR_INSN(vfmaddpd); // Multiply and Add Packed Double-Precision Floating-Point
CHECK_FOR_INSN(vfmaddss); // Multiply and Add Scalar Single-Precision Floating-Point
CHECK_FOR_INSN(vfmaddsd); // Multiply and Add Scalar Double-Precision Floating-Point
CHECK_FOR_INSN(vfmsubps); // Multiply and Subtract Packed Single-Precision Floating-Point
CHECK_FOR_INSN(vfmsubpd); // Multiply and Subtract Packed Double-Precision Floating-Point
CHECK_FOR_INSN(vfmsubss); // Multiply and Subtract Scalar Single-Precision Floating-Point
CHECK_FOR_INSN(vfmsubsd); // Multiply and Subtract Scalar Double-Precision Floating-Point
CHECK_FOR_INSN(vfnmaddps); // Negative Multiply and Add Packed Single-Precision Floating-Point
CHECK_FOR_INSN(vfnmaddpd); // Negative Multiply and Add Packed Double-Precision Floating-Point
CHECK_FOR_INSN(vfnmaddss); // Negative Multiply and Add Scalar Single-Precision Floating-Point
CHECK_FOR_INSN(vfnmaddsd); // Negative Multiply and Add Double Single-Precision Floating-Point
CHECK_FOR_INSN(vfnmsubps); // Negative Multiply and Subtract Packed Single-Precision Floating-Point
CHECK_FOR_INSN(vfnmsubpd); // Negative Multiply and Subtract Packed Double-Precision Floating-Point
CHECK_FOR_INSN(vfnmsubss); // Negative Multiply and Subtract Scalar Single-Precision Floating-Point
CHECK_FOR_INSN(vfnmsubsd); // Negative Multiply and Subtract Double Single-Precision Floating-Point
cerr<<"Cannot match opcode Mnemonic ("<< disasm.getMnemonic() <<") to stars insn."<<endl;
assert(0);
exit(1);
}
// jdh: what are features?
// what bits are used and what're their meanings?
// ANSWER: Bit map identifying whether an operand is a DEF or USE, and of course some operands are both.
// STARSIDAInstruction.cpp has:
// static uint32_t UseMacros[STARS_UA_MAXOP] = {STARS_CF_USE1, STARS_CF_USE2, STARS_CF_USE3, STARS_CF_USE4, STARS_CF_USE5, STARS_CF_USE6};
// static uint32_t DefMacros[STARS_UA_MAXOP] = { STARS_CF_CHG1, STARS_CF_CHG2, STARS_CF_CHG3, STARS_CF_CHG4, STARS_CF_CHG5, STARS_CF_CHG6 };
// Each of these macro values is #defined and commented in STARSTypes.h.
// example:
// add rax, rdx (intel) means rax=rax+rdx;
// features = STARS_CF_USE1 | STARS_CF_USE2 | STARS_CF_CHG1
inline uint32_t STARS_IRDB_Instruction_t::GetInitialInstFeatures(bool ShiftOperands, const DecodedInstruction_t& p_disasm) const
{
uint32_t my_features=0;
#define CHECK_ARG(p_disasm,num,use,def) \
if(p_disasm.hasOperand(num) && p_disasm.getOperand(num).isRead()) my_features|=use; \
if(p_disasm.hasOperand(num) && p_disasm.getOperand(num).isWritten()) my_features|=def; \
if (!ShiftOperands) {
CHECK_ARG(p_disasm, 0, STARS_CF_USE1, STARS_CF_CHG1);
CHECK_ARG(p_disasm, 1, STARS_CF_USE2, STARS_CF_CHG2);
CHECK_ARG(p_disasm, 2, STARS_CF_USE3, STARS_CF_CHG3);
CHECK_ARG(p_disasm, 3, STARS_CF_USE4, STARS_CF_CHG4);
}
else {
// An invisible operands has been inserted, e.g. "div rsi" has rax
// as an invisible operand inserted as the first operand. So, RSI
// gets shifted to the second operand, but the disasm still has it
// as the first operand. Shift the bit masks used in the CHECK_ARG macro.
CHECK_ARG(p_disasm, 0, STARS_CF_USE2, STARS_CF_CHG2);
CHECK_ARG(p_disasm, 1, STARS_CF_USE3, STARS_CF_CHG3);
CHECK_ARG(p_disasm, 2, STARS_CF_USE4, STARS_CF_CHG4);
}
return my_features;
}
bool STARS_IRDB_Instruction_t::STARS_GetCmd(void)
{
// Save memory by having all void operands use a shared_ptr to a single void operand.
// this->VoidOpndsPtr = nullptr;
// this->VoidOpndsPtr = dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IRDB_op_t>());
bool do_default = true;
// disasm = DecodedInstruction_t(irdb_insn);
const auto my_disasm = DecodedInstruction_t(irdb_insn);
disasm = DecodedInstructionMicro_t(irdb_insn);
int length = my_disasm.length(); /*Disassemble(irdb_insn, disasm); */
for (int i = 0; i < STARS_UA_MAXOP; ++i) // all operands are void to start.
Operands.push_back(this->MakeVoidOpnd());
uint16_t IDAOpcode = this->GetIDAOpcode();
switch (IDAOpcode)
{
//
// calls and jumps have one operand, and the GetAddr() on that operand has to return the ID of the target instruction.
//
case STARS_NN_ja:
case STARS_NN_jae:
case STARS_NN_jb:
case STARS_NN_jbe:
case STARS_NN_jc:
case STARS_NN_jcxz:
case STARS_NN_jecxz:
case STARS_NN_jrcxz:
case STARS_NN_je:
case STARS_NN_jg:
case STARS_NN_jge:
case STARS_NN_jl:
case STARS_NN_jle:
case STARS_NN_jna:
case STARS_NN_jnae:
case STARS_NN_jnb:
case STARS_NN_jnbe:
case STARS_NN_jnc:
case STARS_NN_jne:
case STARS_NN_jng:
case STARS_NN_jnge:
case STARS_NN_jnl:
case STARS_NN_jnle:
case STARS_NN_jno:
case STARS_NN_jnp:
case STARS_NN_jns:
case STARS_NN_jnz:
case STARS_NN_jo:
case STARS_NN_jp:
case STARS_NN_jpe:
case STARS_NN_jpo:
case STARS_NN_js:
case STARS_NN_jz:
case STARS_NN_jmp:
case STARS_NN_jmpfi:
case STARS_NN_jmpni:
case STARS_NN_jmpshort:
case STARS_NN_call:
{
//if((disasm.Argument1.ArgType & 0xffff0000 & CONSTANT_TYPE)==CONSTANT_TYPE)
if(my_disasm.getOperand(0).isConstant())
{
shared_ptr<STARS_IRDB_op_t> p=(std::make_shared<STARS_IRDB_op_t>());
if(irdb_insn->GetTarget())
p->MakeNearPointerOpnd(irdb_insn->GetTarget()->GetBaseID());
else
p->MakeNearPointerOpnd(0);
Operands[0]=p;
features=STARS_CF_USE1;
do_default=false;
}
break;
}
//
// push and pop -- beaengine makes an operand for the stack pointer that ida doesn't need.
//
case STARS_NN_push:
{
// make op[0] from reg/imm in Argument2
Operands[0]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,1,my_disasm.getOperand(0),length));
// reset the features of this insn to say we use op 1.
features=STARS_CF_USE1;
do_default=false;
break;
}
//
// push and pop -- beaengine makes an operand for the stack pointer that ida doesn't need.
//
case STARS_NN_pop:
{
// make op[0] from reg/imm in Argument2
Operands[0]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,1,my_disasm.getOperand(0),length));
// reset the features of this insn to say we use op 1.
features=STARS_CF_CHG1;
do_default=false;
break;
}
//
// these opcodes have a bea engine operand that ida doesn't need.
//
case STARS_NN_retn: // return (near).
case STARS_NN_clts: // Clear Task-Switched Flag in CR0
case STARS_NN_pushf: // push flags
case STARS_NN_pushfw: // push flags as word.
case STARS_NN_pushfd: // push flags as double word.
case STARS_NN_pushfq: // push flags as quad word.
case STARS_NN_popf: // pop flags
case STARS_NN_popfw: // pop flags as word.
case STARS_NN_popfd: // pop flags as double word.
case STARS_NN_popfq: // pop flags as quad word.
case STARS_NN_sahf: // store flags
case STARS_NN_lahf: // load flags
case STARS_NN_str: // load flags
case STARS_NN_ltr: // load flags
case STARS_NN_sldt: // load flags
{
features=0;
do_default=false;
break;
}
// These opcodes alter a bit within the EFLAGS register.
case STARS_NN_clc: // Clear Carry Flag
case STARS_NN_cld: // Clear Direction Flag
case STARS_NN_cli: // Clear Interrupt Flag
case STARS_NN_cmc: // Complement Carry Flag
case STARS_NN_stc: // Set Carry Flag
case STARS_NN_std: // Set Direction Flag
case STARS_NN_sti: // Set Interrupt Flag
{
do_default = false;
shared_ptr<STARS_IRDB_op_t> p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeRegOpnd(STARS_x86_R_efl);
Operands[0]=p;
features = (STARS_CF_CHG1 | STARS_CF_USE1);
break;
}
case STARS_NN_cbw:
case STARS_NN_cwde:
case STARS_NN_cdqe:
{
do_default=false;
const auto p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeRegOpnd(STARS_x86_R_ax);
switch(this->GetIDAOpcode())
{
case STARS_NN_cbw: p->SetByteWidth(1); break;
case STARS_NN_cwde: p->SetByteWidth(2); break;
case STARS_NN_cdqe: p->SetByteWidth(4); break;
default: assert(0);
}
Operands[0]=p;
features = (STARS_CF_CHG1 | STARS_CF_USE1);
break;
}
case STARS_NN_cwd: // AX -> DX:AX (with sign)
case STARS_NN_cdq: // EAX -> EDX:EAX (with sign)
case STARS_NN_cqo: // RAX -> RDX:RAX (with sign)
{
if (!my_disasm.hasOperand(0)) { // all operands are implicit; create them to match IDA
do_default = false;
const auto p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeRegOpnd(STARS_x86_R_ax);
const auto q = (std::make_shared<STARS_IRDB_op_t>());
q->MakeRegOpnd(STARS_x86_R_dx);
switch (this->GetIDAOpcode())
{
case STARS_NN_cwd: p->SetByteWidth(2); q->SetByteWidth(2); break;
case STARS_NN_cdq: p->SetByteWidth(4); q->SetByteWidth(4); break;
case STARS_NN_cqo: p->SetByteWidth(8); q->SetByteWidth(8); break;
default: assert(0);
}
// IDA Pro puts the source RAX first, destination RDX second, for some reason.
// STARS can build the RTL regardless of order, but might as well match.
Operands[0] = p;
Operands[1] = q;
features = (STARS_CF_CHG2 | STARS_CF_USE1);
break;
}
else {
do_default = true;
}
}
case STARS_NN_div:
case STARS_NN_idiv:
case STARS_NN_mul:
case STARS_NN_imul:
{
// If beaEngine has EAX+EDX as arg1, make it just EAX like IDA Pro.
//if (this->disasm.Argument1.ArgType == REGISTER_TYPE + GENERAL_REG + REG0 + REG2)
// this->disasm.Argument1.ArgType = REGISTER_TYPE + GENERAL_REG + REG0;
// get reg num of reg0+reg2 now returns reg0.
if(!my_disasm.hasOperand(1)) // e.g. div rsi or mul rcx; RAX is hidden operand
{
shared_ptr<STARS_IRDB_op_t> p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeRegOpnd(STARS_x86_R_ax);
p->SetByteWidth(my_disasm.getOperand(0).getArgumentSizeInBytes());
Operands[0]=p;
do_default = false;
for(auto i=0;i<3;i++)
{
if(my_disasm.hasOperand(i))
Operands[i+1]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(i),length));
else
Operands[i+1] = this->MakeVoidOpnd();
}
features=GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG1 | STARS_CF_USE1);
}
else
do_default=true;
break;
}
case STARS_NN_f2xm1: // implicit floating-point register write
case STARS_NN_fabs:
case STARS_NN_fbld:
case STARS_NN_fchs:
case STARS_NN_fiadd:
case STARS_NN_fidiv:
case STARS_NN_fidivr:
case STARS_NN_fild:
case STARS_NN_fimul:
case STARS_NN_fisub:
case STARS_NN_fisubr:
case STARS_NN_fld:
case STARS_NN_frndint:
case STARS_NN_fsqrt:
case STARS_NN_fxtract:
case STARS_NN_fcos:
case STARS_NN_fld1:
case STARS_NN_fldcw:
case STARS_NN_fstcw: // Store Control Word
case STARS_NN_fnstcw: // Store Control Word (no wait)
case STARS_NN_fstsw: // Store Status Word
case STARS_NN_fnstsw: // Store Status Word (no wait)
case STARS_NN_fldl2e:
case STARS_NN_fldl2t:
case STARS_NN_fldlg2:
case STARS_NN_fldln2:
case STARS_NN_fldpi:
case STARS_NN_fldz:
case STARS_NN_fsin:
case STARS_NN_fsincos:
case STARS_NN_ftst:
{
shared_ptr<STARS_IRDB_op_t> p = (std::make_shared<STARS_IRDB_op_t>());
bool FloatingStackLoad = ((IDAOpcode == STARS_NN_fld) || (STARS_NN_fldcw == IDAOpcode));
// Immediate operands are implicit, not represented by IDA, bea, or capstone.
bool FloatingImmediateLoad = ((IDAOpcode == STARS_NN_fld1) || (STARS_NN_fldl2e == IDAOpcode)
|| (STARS_NN_fldl2t == IDAOpcode) || (STARS_NN_fldlg2 == IDAOpcode)
|| (STARS_NN_fldln2 == IDAOpcode) || (STARS_NN_fldpi == IDAOpcode)
|| (STARS_NN_fldz == IDAOpcode));
bool FPStore = false;
if ((STARS_NN_fldcw == IDAOpcode) || (STARS_NN_fstcw == IDAOpcode) || (STARS_NN_fnstcw == IDAOpcode)) {
p->MakeRegOpnd(STARS_x86_R_fpctrl);
FPStore = (STARS_NN_fldcw != IDAOpcode);
}
else if ((STARS_NN_fstsw == IDAOpcode) || (STARS_NN_fnstsw == IDAOpcode)) {
p->MakeRegOpnd(STARS_x86_R_fpstat);
FPStore = true;
}
else
p->MakeFloatingPointRegOpnd(STARS_x86_R_st0);
p->SetByteWidth(this->DetermineRegByteWidth(p->GetReg()));
Operands[0] = p;
do_default = false;
for (auto i = 0; i < 3; ++i)
{
if (my_disasm.hasOperand(i))
Operands[i + 1] = (std::make_shared<STARS_IRDB_op_t>(my_disasm, 0, my_disasm.getOperand(i),length));
else
Operands[i + 1] = this->MakeVoidOpnd();
}
if (FloatingStackLoad)
features = GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG1 | STARS_CF_USE2);
else if (FloatingImmediateLoad) // e.g. ST0 := 0.0 or ST0 := pi;
features = GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG1);
else if (FPStore)
features = GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG2 | STARS_CF_USE1);
else
features = GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG1 | STARS_CF_USE1);
break;
}
case STARS_NN_fbstp: // implict st0 read
case STARS_NN_fist:
case STARS_NN_fistp:
case STARS_NN_fst:
case STARS_NN_fstp:
case STARS_NN_ficom:
case STARS_NN_ficomp:
case STARS_NN_fxam:
{
auto p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeRegOpnd(STARS_x86_R_st0);
Operands[0]=p;
do_default = false;
for(auto i=0;i<3;i++)
{
if(my_disasm.hasOperand(i))
Operands[i+1]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(i),length));
else
Operands[i+1] = this->MakeVoidOpnd();
}
features=GetInitialInstFeatures(true,my_disasm) | (STARS_CF_USE1);
break;
}
case STARS_NN_fxch: // implicit read/write of st0. possible implicit read of st1.
{
auto p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeRegOpnd(STARS_x86_R_st0);
Operands[0]=p;
if(my_disasm.hasOperand(0))
Operands[1]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(0),length));
else
{
p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
Operands[1]=p;
}
features=GetInitialInstFeatures(true,my_disasm)
| (STARS_CF_CHG1 | STARS_CF_USE1)
| (STARS_CF_CHG2 | STARS_CF_USE2);
break;
}
case STARS_NN_fcom: // implicit st0 read, possible implicit st1 read
case STARS_NN_fcomp:
case STARS_NN_fucom:
case STARS_NN_fucomp:
{
auto p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st0);
Operands[0]=p;
if(my_disasm.hasOperand(0))
Operands[1]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(0),length));
else
{
p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
Operands[1]=p;
}
features=GetInitialInstFeatures(true,my_disasm)
| (STARS_CF_USE1)
| (STARS_CF_USE2);
break;
}
case STARS_NN_fadd: // possible implicit st0 write
case STARS_NN_fdiv:
case STARS_NN_fdivr:
case STARS_NN_fmul:
case STARS_NN_fsub:
case STARS_NN_fsubr:
case STARS_NN_faddp: // possible implicit st0 write, st1 read
case STARS_NN_fdivp:
case STARS_NN_fdivrp:
case STARS_NN_fmulp:
case STARS_NN_fsubp:
case STARS_NN_fsubrp:
{
if(my_disasm.hasOperand(1))
{
do_default=true;
}
else if(my_disasm.hasOperand(0)) // missing st0
{
do_default=false;
shared_ptr<STARS_IRDB_op_t> p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st0);
p->SetByteWidth(my_disasm.getOperand(0).getArgumentSizeInBytes());
Operands[0]=p;
for(auto i=0;i<3;i++)
{
if(my_disasm.hasOperand(i))
Operands[i+1]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(i),length));
else
Operands[i+1] = this->MakeVoidOpnd();
}
features=GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG1 | STARS_CF_USE1);
}
else /// missing st0 and st1
{
do_default=false;
shared_ptr<STARS_IRDB_op_t> p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st0);
Operands[0]=p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
Operands[1]=p;
features=GetInitialInstFeatures(false,my_disasm) | (STARS_CF_CHG1 | STARS_CF_USE1 | STARS_CF_USE2);
}
break;
}
case STARS_NN_fprem:
case STARS_NN_fscale: // implicit write st0, implicit read st1
case STARS_NN_fprem1:
case STARS_NN_fptan:
{
do_default=false;
shared_ptr<STARS_IRDB_op_t> p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st0);
Operands[0]=p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
Operands[1]=p;
features=GetInitialInstFeatures(false,my_disasm) | (STARS_CF_CHG1 | STARS_CF_USE1 | STARS_CF_USE2);
break;
}
case STARS_NN_fclex: // no operands
case STARS_NN_fdecstp:
case STARS_NN_fdisi:
case STARS_NN_feni:
case STARS_NN_fincstp:
case STARS_NN_finit:
case STARS_NN_fldenv:
case STARS_NN_fnclex:
case STARS_NN_fndisi:
case STARS_NN_fneni:
case STARS_NN_fninit:
case STARS_NN_fnop:
case STARS_NN_fnsave:
case STARS_NN_fnstenv:
case STARS_NN_frstor:
case STARS_NN_fsave:
case STARS_NN_fsetpm:
case STARS_NN_fstenv:
{
do_default=0;
break;
}
case STARS_NN_ffree: // operands should be right.
{
do_default=true;
break;
}
case STARS_NN_fcompp: // implicit st0 read, implicit st1 read
case STARS_NN_fucompp:
{
do_default=false;
shared_ptr<STARS_IRDB_op_t> p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st0);
Operands[0]=p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
Operands[1]=p;
features=GetInitialInstFeatures(false,my_disasm) | (STARS_CF_USE1 | STARS_CF_USE2);
break;
}
case STARS_NN_fpatan: // implicit st1!! write. implicit st0 read.
case STARS_NN_fyl2x:
case STARS_NN_fyl2xp1:
{
do_default=false;
shared_ptr<STARS_IRDB_op_t> p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st0);
Operands[0]=p;
p = (std::make_shared<STARS_IRDB_op_t>());
p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
Operands[1]=p;
features=GetInitialInstFeatures(false,my_disasm) | (STARS_CF_CHG2 | STARS_CF_USE1 | STARS_CF_USE2);
break;
}
default:
do_default=true;
}
if(do_default)
{
for(auto i=0;i<4;i++)
{
if(my_disasm.hasOperand(i))
Operands[i]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(i),length));
else
Operands[i] = this->MakeVoidOpnd();
}
features=GetInitialInstFeatures(false,my_disasm);
}
// Simplify the operand encoding so that identical operands don't appear to be different.
for (std::size_t i = 0; i < STARS_UA_MAXOP; ++i) {
this->GetOpnd(i)->CleanOpndEncoding();
}
return length > 0;
}
bool STARS_IRDB_Instruction_t::IsUseOpnd(std::size_t OpndNum) const {
return (this->GetInstFeatures() & UseMacros[OpndNum]);
}
bool STARS_IRDB_Instruction_t::IsDefOpnd(std::size_t OpndNum) const {
return (this->GetInstFeatures() & DefMacros[OpndNum]);
}
// Based on RegNum, determine byte width to set for new operand.
std::size_t STARS_IRDB_Instruction_t::DetermineRegByteWidth(STARS_regnum_t RegNum) {
std::size_t ByteWidth = RegSizes[RegNum];
if ((global_STARS_program->GetSTARS_ISA_Bytewidth() == 8) && this->Has64BitOperands() && (RegNum <= STARS_x86_R_ip)) {
ByteWidth = 8;
}
return ByteWidth;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeVoidOpnd(void) const
{
return this->VoidOpndsPtr; // shared for memory reduction
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeImmediateOpnd(STARS_uval_t value) const
{
// bad syntax:
// shared_ptr<STARS_IRDB_op_t> p = dynamic_cast<shared_ptr<STARS_IRDB_op_t> >(MakeVoidOpnd());
// p not of right type.
// STARSOpndTypePtr p=MakeVoidOpnd();
// not using shared poitners.
// STARS_IRDB_op_t* p = (STARS_IRDB_op_t*)MakeVoidOpnd();
// shared_ptr use_count goes to 0 and is erased before p can be deref.
// auto p=MakeVoidOpnd().get();
// STARSIRDBOpndTypePtr p=std::dynamic_cast<STARSIRDBOpndTypePtr>(p);
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeImmediateOpnd(value);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeRegOpnd(STARS_regnum_t RegNum, bool DefaultToMachineWidth)
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
uint16_t ByteWidth = this->DetermineRegByteWidth(RegNum);
p->MakeRegOpnd(RegNum);
p->SetByteWidth(ByteWidth);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeFloatingPointRegOpnd(STARS_regnum_t RegNum)
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeFloatingPointRegOpnd(RegNum);
p->SetByteWidth(this->DetermineRegByteWidth(RegNum));
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeMMXRegOpnd(STARS_regnum_t RegNum)
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeMMXRegOpnd(RegNum);
p->SetByteWidth(this->DetermineRegByteWidth(RegNum));
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeXMMRegOpnd(STARS_regnum_t RegNum)
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeXMMRegOpnd(RegNum);
p->SetByteWidth(this->DetermineRegByteWidth(RegNum));
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeYMMRegOpnd(STARS_regnum_t RegNum)
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeYMMRegOpnd(RegNum);
p->SetByteWidth(this->DetermineRegByteWidth(RegNum));
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeNearPointerOpnd(STARS_uval_t value) const
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeNearPointerOpnd(disasm.getAddress() /*Instruction.AddrValue*/);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeMemDisplacementOpnd
(STARS_regnum_t BaseRegNum, STARS_regnum_t IndexRegNum, uint16_t ScaleFactor, STARS_ea_t offset)
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeMemDisplacementOpnd(BaseRegNum, IndexRegNum, ScaleFactor, offset);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeMemPhraseOpnd
(STARS_regnum_t BaseRegNum, STARS_regnum_t IndexRegNum, uint16_t ScaleFactor)
{
STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
assert(p);
p->MakeMemPhraseOpnd(BaseRegNum, IndexRegNum, ScaleFactor);
return p;
}
bool STARS_IRDB_Instruction_t::IsPushFromFixedCall(void) const
{
const auto insn = const_cast<Instruction_t*>(GetIRDBInstruction());
if (insn == nullptr)
return false;
const auto &all_relocs = insn->GetRelocations();
const auto reloc_it = find_if(ALLOF(all_relocs), [](const Relocation_t* reloc)
{
return (reloc->GetType() == string("32-bit")) || (reloc->GetType() == string("push64"));
});
return (reloc_it != all_relocs.end());
}
#if 0
bool STARS_IRDB_Instruction_t::IsPushFromFixedCall(void) const
{
Instruction_t* insn=const_cast<Instruction_t*>(GetIRDBInstruction());
if(!insn)
return false;
RelocationSet_t::iterator rit;
for( rit=insn->GetRelocations().begin();
rit!=insn->GetRelocations().end();
++rit
)
{
Relocation_t* reloc=*rit;
if(reloc->GetType()==string("32-bit") || reloc->GetType()==string("push64"))
{
return true;
}
}
return false;
}
#endif
bool STARS_IRDB_Instruction_t::IsJumpFromFixedCall(void) const
{
Instruction_t* insn=const_cast<Instruction_t*>(GetIRDBInstruction());
if(!insn)
return false;
RelocationSet_t::iterator rit;
for( rit=insn->GetRelocations().begin();
rit!=insn->GetRelocations().end();
++rit
)
{
Relocation_t* reloc=*rit;
if(reloc->GetType()==string("fix_call_fallthrough"))
{
return true;
}
}
return false;
}
STARS_InstructionID_Set_t STARS_IRDB_Instruction_t::GetReferencedInstructionIDs(bool &success)
{
extern STARS_Interface_t* global_stars_interface;
STARS_IRDB_Interface_t* gsi=dynamic_cast<STARS_IRDB_Interface_t*>(global_stars_interface);
success=false;
STARS_InstructionID_Set_t ret;
assert(irdb_insn);
if(irdb_insn->GetTarget())
ret.insert(irdb_insn->GetTarget()->GetBaseID());
if (this->GetIDAOpcode() == STARS_NN_push)
{
RelocationSet_t::iterator rit;
for (rit = irdb_insn->GetRelocations().begin();
rit != irdb_insn->GetRelocations().end();
++rit
)
{
Relocation_t* reloc = *rit;
if (reloc->GetType() == string("fix_call_fallthrough"))
{
assert(nullptr != reloc->GetWRT());
ret.insert(reloc->GetWRT()->GetBaseID());
}
}
#if 0
libIRDB::virtual_offset_t ibta = GetOpnd(0)->GetAddr();
AddressID_t aid(libIRDB::BaseObj_t::NOT_IN_DATABASE, irdb_insn->GetAddress()->GetFileID(), ibta);
bool found_insn=false;
Instruction_t* targ_insn=gsi->GetIBT(aid,found_insn);
if(found_insn)
{
assert(targ_insn);
ret.insert(targ_insn->GetBaseID());
}
#endif
}
else if(IsJumpFromFixedCall())
{
Instruction_t* insn=const_cast<Instruction_t*>(GetIRDBInstruction());
RelocationSet_t::iterator rit;
for( rit=insn->GetRelocations().begin();
rit!=insn->GetRelocations().end();
++rit
)
{
Relocation_t* reloc=*rit;
if(reloc->GetType()==string("fix_call_fallthrough"))
{
Instruction_t* insn=dynamic_cast<Instruction_t*>(reloc->GetWRT());
if(insn)
ret.insert(insn->GetBaseID());
}
}
}
success=true;
return ret;
}
// return inst ID addr for fall-through from this inst
STARS_ea_t STARS_IRDB_Instruction_t::GetFallThroughInstID(void) {
STARS_ea_t FallThroughID = STARS_BADADDR;
const libIRDB::Instruction_t* irdb_inst = this->GetIRDBInstruction();
assert(nullptr != irdb_inst);
libIRDB::Instruction_t* FallThroughInst = irdb_inst->GetFallthrough();
if (nullptr != FallThroughInst) {
FallThroughID = (STARS_ea_t) FallThroughInst->GetAddress()->GetVirtualOffset();
}
return FallThroughID;
}