Skip to content
Snippets Groups Projects
STARS_IRDB_Instruction.cpp 76.8 KiB
Newer Older
jdh8d's avatar
 
jdh8d committed
	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;                 
		//
		// 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);