Skip to content
Snippets Groups Projects
STARS_IRDB_Instruction.cpp 76.8 KiB
Newer Older

#include "SMPDataFlowAnalysis.h"
#include "interfaces/abstract/STARSInterface.h"
#include "interfaces/irdb/STARSInstruction.h"
#include "interfaces/irdb/STARSOp.h"
#include "interfaces/STARSTypes.h"

// #include <bea_deprecated.hpp>
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; }	\
jdh8d's avatar
jdh8d committed
#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);                 
jdh8d's avatar
jdh8d committed
	CHECK_FOR_INSN_RENAME(cmps, "cmpsb");                
jdh8d's avatar
 
jdh8d committed
	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);                 
jdh8d's avatar
 
jdh8d committed
	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);                 
jdh8d's avatar
 
jdh8d committed
	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);                
jdh8d's avatar
 
jdh8d committed
	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);                 
jdh8d's avatar
 
jdh8d committed
	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);               
jdh8d's avatar
jdh8d committed
	CHECK_FOR_INSN_RENAME(retn,"ret");                
jdh8d's avatar
 
jdh8d committed
	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);                 
jdh8d's avatar
 
jdh8d committed
	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);                 
jdh8d's avatar
jdh8d committed
	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);                
jdh8d's avatar
 
jdh8d committed
	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);
jdh8d's avatar
jdh8d committed
	CHECK_FOR_INSN_RENAME(cmova, "cmovnbe");               
	CHECK_FOR_INSN_RENAME(cmovb, "cmovb");               
	CHECK_FOR_INSN_RENAME(cmovbe, "cmovbe");              
jdh8d's avatar
jdh8d committed
	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");              
jdh8d's avatar
jdh8d committed
	CHECK_FOR_INSN_RENAME(cmovnz, "cmovne");              
	CHECK_FOR_INSN_RENAME(cmovo, "cmovo");               
	CHECK_FOR_INSN_RENAME(cmovp, "cmovp");               
	CHECK_FOR_INSN_RENAME(cmovs, "cmovs");               
jdh8d's avatar
jdh8d committed
	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);                
jdh8d's avatar
 
jdh8d committed
	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);            
jdh8d's avatar
 
jdh8d committed
	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 
jdh8d's avatar
jdh8d committed
	uint32_t my_features=0;
jdh8d's avatar
jdh8d committed

#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;	\
		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);
jdh8d's avatar
jdh8d committed

	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.
		//
jdh8d's avatar
jdh8d committed
		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));	
jdh8d's avatar
jdh8d committed
			// reset the features of this insn to say we use op 1.
			features=STARS_CF_USE1;			
			do_default=false;
jdh8d's avatar
jdh8d committed
			break;
		}
		//
		// push and pop -- beaengine makes an operand for the stack pointer that ida doesn't need.
		//
jdh8d's avatar
jdh8d committed
		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));	
jdh8d's avatar
jdh8d committed
			// reset the features of this insn to say we use op 1.
			features=STARS_CF_CHG1;			
			do_default=false;
jdh8d's avatar
jdh8d committed
			break;
		}
		//
		// these opcodes have a bea engine operand that ida doesn't need. 
		//
		case STARS_NN_clts:                // Clear Task-Switched Flag in CR0
jdh8d's avatar
 
jdh8d committed
		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);
		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));
						Operands[i+1] = this->MakeVoidOpnd();
				features=GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG1 | STARS_CF_USE1);
		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()));
			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));
					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);
				features = GetInitialInstFeatures(true,my_disasm) | (STARS_CF_CHG2 | STARS_CF_USE1);
				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));
					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));
				p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
			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);
			if(my_disasm.hasOperand(0))
				Operands[1]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(0),length));
				p->MakeFloatingPointRegOpnd(STARS_x86_R_st1);
			features=GetInitialInstFeatures(true,my_disasm) 
			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))
			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());
					if(my_disasm.hasOperand(i))
						Operands[i+1]=(std::make_shared<STARS_IRDB_op_t>(my_disasm,0,my_disasm.getOperand(i),length));
						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);
				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);
			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
			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);
			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);
			features=GetInitialInstFeatures(false,my_disasm) | (STARS_CF_CHG2 | STARS_CF_USE1 | STARS_CF_USE2);
		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));
				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);
	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;
}
jdh8d's avatar
jdh8d committed

STARSOpndTypePtr STARS_IRDB_Instruction_t::MakeNearPointerOpnd(STARS_uval_t value) const 
{
	STARSIRDBOpndTypePtr p=std::make_shared<STARS_IRDB_op_t>();
	p->MakeNearPointerOpnd(disasm.getAddress() /*Instruction.AddrValue*/);
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;
		}
	}
Loading
Loading full blame...