#include <iostream>
#include "interfaces/irdb/STARSInstruction.h"
#include "interfaces/irdb/STARSOp.h"
#include "interfaces/STARSTypes.h"
using namespace std;
using namespace libIRDB;
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};
static string remove_rep(string s)
{
if(s.compare(0,4,"rep ")==0)
return string(&s.c_str()[4]);
if(s.compare(0,5,"repe ")==0)
return string(&s.c_str()[5]);
if(s.compare(0,6,"repne ")==0)
return string(&s.c_str()[6]);
return s;
}
uint16_t STARS_IRDB_Instruction_t::GetIDAOpcode(void) const
{
#define CHECK_FOR_INSN(token) \
if(string(disasm.Instruction.Mnemonic)==string( #token )+" " ) \
return STARS_NN_##token; \
#define CHECK_FOR_INSN_RENAME(token,str) \
if(string(disasm.Instruction.Mnemonic)==string( str )+" " ) \
return STARS_NN_##token; \
if(string(disasm.Instruction.Mnemonic)==string("jmp")+" " )
{
if(irdb_insn->GetTarget())
return STARS_NN_jmp;
return STARS_NN_jmpni;
}
else if(string(disasm.Instruction.Mnemonic)==string("call")+" " )
{
if(irdb_insn->GetTarget())
return STARS_NN_call;
return STARS_NN_callni;
}
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_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(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(prefetcht1);
CHECK_FOR_INSN(prefetcht2);
CHECK_FOR_INSN(prefetchnta);
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(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);
CHECK_FOR_INSN(vmovntsd);
CHECK_FOR_INSN(vmovntss);
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);
cerr<<"Cannot match opcode Mneumonic ("<<
disasm.Instruction.Mnemonic <<") 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(void) const
{
uint32_t my_features=0;
// nervous that bea isn't marking operands as both read and write. May need to update.
#define CHECK_ARG(arg,use,def) \
if(arg.ArgType!=NO_ARGUMENT && (arg.AccessMode&READ)==READ) my_features|=use; \
if(arg.ArgType!=NO_ARGUMENT && (arg.AccessMode&WRITE)==WRITE) my_features|=def; \
CHECK_ARG(disasm.Argument1, STARS_CF_USE1, STARS_CF_CHG1);
CHECK_ARG(disasm.Argument2, STARS_CF_USE2, STARS_CF_CHG2);
CHECK_ARG(disasm.Argument3, STARS_CF_USE3, STARS_CF_CHG3);
CHECK_ARG(disasm.Argument4, STARS_CF_USE4, STARS_CF_CHG4);
return my_features;
}
bool STARS_IRDB_Instruction_t::STARS_GetCmd(void)
{
bool do_default=true;
int length=irdb_insn->Disassemble(disasm);
for(int i=0;i< STARS_UA_MAXOP; i++) // all operands are void to start.
Operands.push_back(MakeVoidOpnd());
switch(this->GetIDAOpcode())
{
//
// 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)
{
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>(disasm,1,disasm.Argument2));
// 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>(disasm,1,disasm.Argument1));
// 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_clc: // Clear Carry Flag
case STARS_NN_cld: // Clear Direction Flag
case STARS_NN_cli: // Clear Interrupt Flag
case STARS_NN_clts: // Clear Task-Switched Flag in CR0
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
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;
}
default:
do_default=true;
}
if(do_default)
{
Operands[0]=(std::make_shared<STARS_IRDB_op_t>(disasm,0,disasm.Argument1));
Operands[1]=(std::make_shared<STARS_IRDB_op_t>(disasm,1,disasm.Argument2));
Operands[2]=(std::make_shared<STARS_IRDB_op_t>(disasm,2,disasm.Argument3));
Operands[3]=(std::make_shared<STARS_IRDB_op_t>(disasm,3,disasm.Argument4));
features=GetInitialInstFeatures();
}
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]);
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeVoidOpnd(void) const
{
ARGTYPE the_arg;
memset(&the_arg,0,sizeof(the_arg));
the_arg.ArgType=NO_ARGUMENT;
STARSOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>(disasm,0,the_arg);
return p;
}
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::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeImmediateOpnd(value);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeRegOpnd(uint16_t RegNum) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeRegOpnd(RegNum);
// default to 8-byte if stars wants 8-byte registers?
if (Has64BitOperands())
p->SetByteWidth(8);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeFloatingPointRegOpnd(uint16_t RegNum) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeFloatingPointRegOpnd(RegNum);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeMMXRegOpnd(uint16_t RegNum) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeMMXRegOpnd(RegNum);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeXMMRegOpnd(uint16_t RegNum) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeXMMRegOpnd(RegNum);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeYMMRegOpnd(uint16_t RegNum) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeYMMRegOpnd(RegNum);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeNearPointerOpnd(STARS_uval_t value) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeNearPointerOpnd(disasm.Instruction.AddrValue);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeMemDisplacementOpnd
(uint16_t BaseRegNum, uint16_t IndexRegNum, uint16_t ScaleFactor, STARS_ea_t offset) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeMemDisplacementOpnd(BaseRegNum, IndexRegNum, ScaleFactor, offset);
return p;
}
STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeMemPhraseOpnd
(uint16_t BaseRegNum, uint16_t IndexRegNum, uint16_t ScaleFactor) const
{
STARSIRDBOpndTypePtr p=std::dynamic_pointer_cast<STARS_IRDB_op_t>(MakeVoidOpnd());
assert(p);
p->MakeMemPhraseOpnd(BaseRegNum, IndexRegNum, ScaleFactor);
return p;
}
bool STARS_IRDB_Instruction_t::IsPushFromFixedCall(void) const
{
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("32-bit") || reloc->GetType()==string("push64"))
{
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)
{
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());
}
}
success=true;
return ret;
}