LLVM API Documentation

X86GenFastISel.inc

Go to the documentation of this file.
00001 //===- TableGen'erated file -------------------------------------*- C++ -*-===//
00002 //
00003 // "Fast" Instruction Selector for the X86 target
00004 //
00005 // Automatically generated file, do not edit!
00006 //
00007 //===----------------------------------------------------------------------===//
00008 
00009 // FastEmit functions for ISD::Constant.
00010 
00011 unsigned FastEmit_ISD_Constant_MVT_i8_i(MVT RetVT, uint64_t imm0) {
00012   if (RetVT.SimpleTy != MVT::i8)
00013     return 0;
00014   return FastEmitInst_i(X86::MOV8ri, X86::GR8RegisterClass, imm0);
00015 }
00016 
00017 unsigned FastEmit_ISD_Constant_MVT_i16_i(MVT RetVT, uint64_t imm0) {
00018   if (RetVT.SimpleTy != MVT::i16)
00019     return 0;
00020   return FastEmitInst_i(X86::MOV16ri, X86::GR16RegisterClass, imm0);
00021 }
00022 
00023 unsigned FastEmit_ISD_Constant_MVT_i32_i(MVT RetVT, uint64_t imm0) {
00024   if (RetVT.SimpleTy != MVT::i32)
00025     return 0;
00026   return FastEmitInst_i(X86::MOV32ri, X86::GR32RegisterClass, imm0);
00027 }
00028 
00029 unsigned FastEmit_ISD_Constant_MVT_i64_i(MVT RetVT, uint64_t imm0) {
00030   if (RetVT.SimpleTy != MVT::i64)
00031     return 0;
00032   return FastEmitInst_i(X86::MOV64ri, X86::GR64RegisterClass, imm0);
00033 }
00034 
00035 unsigned FastEmit_ISD_Constant_i(MVT VT, MVT RetVT, uint64_t imm0) {
00036   switch (VT.SimpleTy) {
00037   case MVT::i8: return FastEmit_ISD_Constant_MVT_i8_i(RetVT, imm0);
00038   case MVT::i16: return FastEmit_ISD_Constant_MVT_i16_i(RetVT, imm0);
00039   case MVT::i32: return FastEmit_ISD_Constant_MVT_i32_i(RetVT, imm0);
00040   case MVT::i64: return FastEmit_ISD_Constant_MVT_i64_i(RetVT, imm0);
00041   default: return 0;
00042   }
00043 }
00044 
00045 // Top-level FastEmit function.
00046 
00047 unsigned FastEmit_i(MVT VT, MVT RetVT, ISD::NodeType Opcode, uint64_t imm0) {
00048   switch (Opcode) {
00049   case ISD::Constant: return FastEmit_ISD_Constant_i(VT, RetVT, imm0);
00050   default: return 0;
00051   }
00052 }
00053 
00054 // FastEmit functions for ISD::ANY_EXTEND.
00055 
00056 unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i16_r(unsigned Op0) {
00057   if ((!Subtarget->is64Bit())) {
00058     return FastEmitInst_r(X86::MOVZX16rr8, X86::GR16RegisterClass, Op0);
00059   }
00060   return 0;
00061 }
00062 
00063 unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0) {
00064   if ((!Subtarget->is64Bit())) {
00065     return FastEmitInst_r(X86::MOVZX32rr8, X86::GR32RegisterClass, Op0);
00066   }
00067   return 0;
00068 }
00069 
00070 unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0) {
00071 switch (RetVT.SimpleTy) {
00072   case MVT::i16: return FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i16_r(Op0);
00073   case MVT::i32: return FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i32_r(Op0);
00074   default: return 0;
00075 }
00076 }
00077 
00078 unsigned FastEmit_ISD_ANY_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
00079   switch (VT.SimpleTy) {
00080   case MVT::i8: return FastEmit_ISD_ANY_EXTEND_MVT_i8_r(RetVT, Op0);
00081   default: return 0;
00082   }
00083 }
00084 
00085 // FastEmit functions for ISD::BIT_CONVERT.
00086 
00087 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i32_r(MVT RetVT, unsigned Op0) {
00088   if (RetVT.SimpleTy != MVT::f32)
00089     return 0;
00090   if ((Subtarget->hasSSE2())) {
00091     return FastEmitInst_r(X86::MOVDI2SSrr, X86::FR32RegisterClass, Op0);
00092   }
00093   return 0;
00094 }
00095 
00096 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_f64_r(unsigned Op0) {
00097   if ((Subtarget->hasSSE2())) {
00098     return FastEmitInst_r(X86::MOV64toSDrr, X86::FR64RegisterClass, Op0);
00099   }
00100   return 0;
00101 }
00102 
00103 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v8i8_r(unsigned Op0) {
00104   return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
00105 }
00106 
00107 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v4i16_r(unsigned Op0) {
00108   return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
00109 }
00110 
00111 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2i32_r(unsigned Op0) {
00112   return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
00113 }
00114 
00115 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v1i64_r(unsigned Op0) {
00116   return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
00117 }
00118 
00119 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2f32_r(unsigned Op0) {
00120   return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
00121 }
00122 
00123 unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_r(MVT RetVT, unsigned Op0) {
00124 switch (RetVT.SimpleTy) {
00125   case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_f64_r(Op0);
00126   case MVT::v8i8: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v8i8_r(Op0);
00127   case MVT::v4i16: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v4i16_r(Op0);
00128   case MVT::v2i32: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2i32_r(Op0);
00129   case MVT::v1i64: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v1i64_r(Op0);
00130   case MVT::v2f32: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2f32_r(Op0);
00131   default: return 0;
00132 }
00133 }
00134 
00135 unsigned FastEmit_ISD_BIT_CONVERT_MVT_f32_r(MVT RetVT, unsigned Op0) {
00136   if (RetVT.SimpleTy != MVT::i32)
00137     return 0;
00138   if ((Subtarget->hasSSE2())) {
00139     return FastEmitInst_r(X86::MOVSS2DIrr, X86::GR32RegisterClass, Op0);
00140   }
00141   return 0;
00142 }
00143 
00144 unsigned FastEmit_ISD_BIT_CONVERT_MVT_f64_r(MVT RetVT, unsigned Op0) {
00145   if (RetVT.SimpleTy != MVT::i64)
00146     return 0;
00147   if ((Subtarget->hasSSE2())) {
00148     return FastEmitInst_r(X86::MOVSDto64rr, X86::GR64RegisterClass, Op0);
00149   }
00150   return 0;
00151 }
00152 
00153 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_i64_r(unsigned Op0) {
00154   return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
00155 }
00156 
00157 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_f64_r(unsigned Op0) {
00158   return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
00159 }
00160 
00161 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v8i8_r(MVT RetVT, unsigned Op0) {
00162 switch (RetVT.SimpleTy) {
00163   case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_i64_r(Op0);
00164   case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_f64_r(Op0);
00165   default: return 0;
00166 }
00167 }
00168 
00169 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_i64_r(unsigned Op0) {
00170   return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
00171 }
00172 
00173 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_f64_r(unsigned Op0) {
00174   return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
00175 }
00176 
00177 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v4i16_r(MVT RetVT, unsigned Op0) {
00178 switch (RetVT.SimpleTy) {
00179   case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_i64_r(Op0);
00180   case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_f64_r(Op0);
00181   default: return 0;
00182 }
00183 }
00184 
00185 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_i64_r(unsigned Op0) {
00186   return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
00187 }
00188 
00189 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_f64_r(unsigned Op0) {
00190   return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
00191 }
00192 
00193 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2i32_r(MVT RetVT, unsigned Op0) {
00194 switch (RetVT.SimpleTy) {
00195   case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_i64_r(Op0);
00196   case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_f64_r(Op0);
00197   default: return 0;
00198 }
00199 }
00200 
00201 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_i64_r(unsigned Op0) {
00202   return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
00203 }
00204 
00205 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_f64_r(unsigned Op0) {
00206   return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
00207 }
00208 
00209 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v1i64_r(MVT RetVT, unsigned Op0) {
00210 switch (RetVT.SimpleTy) {
00211   case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_i64_r(Op0);
00212   case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_f64_r(Op0);
00213   default: return 0;
00214 }
00215 }
00216 
00217 unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2f32_r(MVT RetVT, unsigned Op0) {
00218   if (RetVT.SimpleTy != MVT::i64)
00219     return 0;
00220   return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
00221 }
00222 
00223 unsigned FastEmit_ISD_BIT_CONVERT_r(MVT VT, MVT RetVT, unsigned Op0) {
00224   switch (VT.SimpleTy) {
00225   case MVT::i32: return FastEmit_ISD_BIT_CONVERT_MVT_i32_r(RetVT, Op0);
00226   case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_i64_r(RetVT, Op0);
00227   case MVT::f32: return FastEmit_ISD_BIT_CONVERT_MVT_f32_r(RetVT, Op0);
00228   case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_f64_r(RetVT, Op0);
00229   case MVT::v8i8: return FastEmit_ISD_BIT_CONVERT_MVT_v8i8_r(RetVT, Op0);
00230   case MVT::v4i16: return FastEmit_ISD_BIT_CONVERT_MVT_v4i16_r(RetVT, Op0);
00231   case MVT::v2i32: return FastEmit_ISD_BIT_CONVERT_MVT_v2i32_r(RetVT, Op0);
00232   case MVT::v1i64: return FastEmit_ISD_BIT_CONVERT_MVT_v1i64_r(RetVT, Op0);
00233   case MVT::v2f32: return FastEmit_ISD_BIT_CONVERT_MVT_v2f32_r(RetVT, Op0);
00234   default: return 0;
00235   }
00236 }
00237 
00238 // FastEmit functions for ISD::BRIND.
00239 
00240 unsigned FastEmit_ISD_BRIND_MVT_i32_r(MVT RetVT, unsigned Op0) {
00241   if (RetVT.SimpleTy != MVT::isVoid)
00242     return 0;
00243   return FastEmitInst_r(X86::JMP32r, X86::GR32RegisterClass, Op0);
00244 }
00245 
00246 unsigned FastEmit_ISD_BRIND_MVT_i64_r(MVT RetVT, unsigned Op0) {
00247   if (RetVT.SimpleTy != MVT::isVoid)
00248     return 0;
00249   return FastEmitInst_r(X86::JMP64r, X86::GR64RegisterClass, Op0);
00250 }
00251 
00252 unsigned FastEmit_ISD_BRIND_r(MVT VT, MVT RetVT, unsigned Op0) {
00253   switch (VT.SimpleTy) {
00254   case MVT::i32: return FastEmit_ISD_BRIND_MVT_i32_r(RetVT, Op0);
00255   case MVT::i64: return FastEmit_ISD_BRIND_MVT_i64_r(RetVT, Op0);
00256   default: return 0;
00257   }
00258 }
00259 
00260 // FastEmit functions for ISD::BSWAP.
00261 
00262 unsigned FastEmit_ISD_BSWAP_MVT_i32_r(MVT RetVT, unsigned Op0) {
00263   if (RetVT.SimpleTy != MVT::i32)
00264     return 0;
00265   return FastEmitInst_r(X86::BSWAP32r, X86::GR32RegisterClass, Op0);
00266 }
00267 
00268 unsigned FastEmit_ISD_BSWAP_MVT_i64_r(MVT RetVT, unsigned Op0) {
00269   if (RetVT.SimpleTy != MVT::i64)
00270     return 0;
00271   return FastEmitInst_r(X86::BSWAP64r, X86::GR64RegisterClass, Op0);
00272 }
00273 
00274 unsigned FastEmit_ISD_BSWAP_r(MVT VT, MVT RetVT, unsigned Op0) {
00275   switch (VT.SimpleTy) {
00276   case MVT::i32: return FastEmit_ISD_BSWAP_MVT_i32_r(RetVT, Op0);
00277   case MVT::i64: return FastEmit_ISD_BSWAP_MVT_i64_r(RetVT, Op0);
00278   default: return 0;
00279   }
00280 }
00281 
00282 // FastEmit functions for ISD::FABS.
00283 
00284 unsigned FastEmit_ISD_FABS_MVT_f32_r(MVT RetVT, unsigned Op0) {
00285   if (RetVT.SimpleTy != MVT::f32)
00286     return 0;
00287   if ((!Subtarget->hasSSE1())) {
00288     return FastEmitInst_r(X86::ABS_Fp32, X86::RFP32RegisterClass, Op0);
00289   }
00290   return 0;
00291 }
00292 
00293 unsigned FastEmit_ISD_FABS_MVT_f64_r(MVT RetVT, unsigned Op0) {
00294   if (RetVT.SimpleTy != MVT::f64)
00295     return 0;
00296   if ((!Subtarget->hasSSE2())) {
00297     return FastEmitInst_r(X86::ABS_Fp64, X86::RFP64RegisterClass, Op0);
00298   }
00299   return 0;
00300 }
00301 
00302 unsigned FastEmit_ISD_FABS_MVT_f80_r(MVT RetVT, unsigned Op0) {
00303   if (RetVT.SimpleTy != MVT::f80)
00304     return 0;
00305   return FastEmitInst_r(X86::ABS_Fp80, X86::RFP80RegisterClass, Op0);
00306 }
00307 
00308 unsigned FastEmit_ISD_FABS_r(MVT VT, MVT RetVT, unsigned Op0) {
00309   switch (VT.SimpleTy) {
00310   case MVT::f32: return FastEmit_ISD_FABS_MVT_f32_r(RetVT, Op0);
00311   case MVT::f64: return FastEmit_ISD_FABS_MVT_f64_r(RetVT, Op0);
00312   case MVT::f80: return FastEmit_ISD_FABS_MVT_f80_r(RetVT, Op0);
00313   default: return 0;
00314   }
00315 }
00316 
00317 // FastEmit functions for ISD::FCOS.
00318 
00319 unsigned FastEmit_ISD_FCOS_MVT_f32_r(MVT RetVT, unsigned Op0) {
00320   if (RetVT.SimpleTy != MVT::f32)
00321     return 0;
00322   if ((!Subtarget->hasSSE1())) {
00323     return FastEmitInst_r(X86::COS_Fp32, X86::RFP32RegisterClass, Op0);
00324   }
00325   return 0;
00326 }
00327 
00328 unsigned FastEmit_ISD_FCOS_MVT_f64_r(MVT RetVT, unsigned Op0) {
00329   if (RetVT.SimpleTy != MVT::f64)
00330     return 0;
00331   if ((!Subtarget->hasSSE2())) {
00332     return FastEmitInst_r(X86::COS_Fp64, X86::RFP64RegisterClass, Op0);
00333   }
00334   return 0;
00335 }
00336 
00337 unsigned FastEmit_ISD_FCOS_MVT_f80_r(MVT RetVT, unsigned Op0) {
00338   if (RetVT.SimpleTy != MVT::f80)
00339     return 0;
00340   return FastEmitInst_r(X86::COS_Fp80, X86::RFP80RegisterClass, Op0);
00341 }
00342 
00343 unsigned FastEmit_ISD_FCOS_r(MVT VT, MVT RetVT, unsigned Op0) {
00344   switch (VT.SimpleTy) {
00345   case MVT::f32: return FastEmit_ISD_FCOS_MVT_f32_r(RetVT, Op0);
00346   case MVT::f64: return FastEmit_ISD_FCOS_MVT_f64_r(RetVT, Op0);
00347   case MVT::f80: return FastEmit_ISD_FCOS_MVT_f80_r(RetVT, Op0);
00348   default: return 0;
00349   }
00350 }
00351 
00352 // FastEmit functions for ISD::FNEG.
00353 
00354 unsigned FastEmit_ISD_FNEG_MVT_f32_r(MVT RetVT, unsigned Op0) {
00355   if (RetVT.SimpleTy != MVT::f32)
00356     return 0;
00357   if ((!Subtarget->hasSSE1())) {
00358     return FastEmitInst_r(X86::CHS_Fp32, X86::RFP32RegisterClass, Op0);
00359   }
00360   return 0;
00361 }
00362 
00363 unsigned FastEmit_ISD_FNEG_MVT_f64_r(MVT RetVT, unsigned Op0) {
00364   if (RetVT.SimpleTy != MVT::f64)
00365     return 0;
00366   if ((!Subtarget->hasSSE2())) {
00367     return FastEmitInst_r(X86::CHS_Fp64, X86::RFP64RegisterClass, Op0);
00368   }
00369   return 0;
00370 }
00371 
00372 unsigned FastEmit_ISD_FNEG_MVT_f80_r(MVT RetVT, unsigned Op0) {
00373   if (RetVT.SimpleTy != MVT::f80)
00374     return 0;
00375   return FastEmitInst_r(X86::CHS_Fp80, X86::RFP80RegisterClass, Op0);
00376 }
00377 
00378 unsigned FastEmit_ISD_FNEG_r(MVT VT, MVT RetVT, unsigned Op0) {
00379   switch (VT.SimpleTy) {
00380   case MVT::f32: return FastEmit_ISD_FNEG_MVT_f32_r(RetVT, Op0);
00381   case MVT::f64: return FastEmit_ISD_FNEG_MVT_f64_r(RetVT, Op0);
00382   case MVT::f80: return FastEmit_ISD_FNEG_MVT_f80_r(RetVT, Op0);
00383   default: return 0;
00384   }
00385 }
00386 
00387 // FastEmit functions for ISD::FP_EXTEND.
00388 
00389 unsigned FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f64_r(unsigned Op0) {
00390   if ((!Subtarget->hasSSE1())) {
00391     return FastEmitInst_r(X86::MOV_Fp3264, X86::RFP64RegisterClass, Op0);
00392   }
00393   if ((Subtarget->hasSSE2())) {
00394     return FastEmitInst_r(X86::CVTSS2SDrr, X86::FR64RegisterClass, Op0);
00395   }
00396   return 0;
00397 }
00398 
00399 unsigned FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f80_r(unsigned Op0) {
00400   if ((!Subtarget->hasSSE1())) {
00401     return FastEmitInst_r(X86::MOV_Fp3280, X86::RFP80RegisterClass, Op0);
00402   }
00403   return 0;
00404 }
00405 
00406 unsigned FastEmit_ISD_FP_EXTEND_MVT_f32_r(MVT RetVT, unsigned Op0) {
00407 switch (RetVT.SimpleTy) {
00408   case MVT::f64: return FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f64_r(Op0);
00409   case MVT::f80: return FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f80_r(Op0);
00410   default: return 0;
00411 }
00412 }
00413 
00414 unsigned FastEmit_ISD_FP_EXTEND_MVT_f64_r(MVT RetVT, unsigned Op0) {
00415   if (RetVT.SimpleTy != MVT::f80)
00416     return 0;
00417   if ((!Subtarget->hasSSE2())) {
00418     return FastEmitInst_r(X86::MOV_Fp6480, X86::RFP80RegisterClass, Op0);
00419   }
00420   return 0;
00421 }
00422 
00423 unsigned FastEmit_ISD_FP_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
00424   switch (VT.SimpleTy) {
00425   case MVT::f32: return FastEmit_ISD_FP_EXTEND_MVT_f32_r(RetVT, Op0);
00426   case MVT::f64: return FastEmit_ISD_FP_EXTEND_MVT_f64_r(RetVT, Op0);
00427   default: return 0;
00428   }
00429 }
00430 
00431 // FastEmit functions for ISD::FP_ROUND.
00432 
00433 unsigned FastEmit_ISD_FP_ROUND_MVT_f64_r(MVT RetVT, unsigned Op0) {
00434   if (RetVT.SimpleTy != MVT::f32)
00435     return 0;
00436   if ((!Subtarget->hasSSE1())) {
00437     return FastEmitInst_r(X86::MOV_Fp6432, X86::RFP32RegisterClass, Op0);
00438   }
00439   if ((Subtarget->hasSSE2())) {
00440     return FastEmitInst_r(X86::CVTSD2SSrr, X86::FR32RegisterClass, Op0);
00441   }
00442   return 0;
00443 }
00444 
00445 unsigned FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f32_r(unsigned Op0) {
00446   if ((!Subtarget->hasSSE1())) {
00447     return FastEmitInst_r(X86::MOV_Fp8032, X86::RFP32RegisterClass, Op0);
00448   }
00449   return 0;
00450 }
00451 
00452 unsigned FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f64_r(unsigned Op0) {
00453   if ((!Subtarget->hasSSE2())) {
00454     return FastEmitInst_r(X86::MOV_Fp8064, X86::RFP64RegisterClass, Op0);
00455   }
00456   return 0;
00457 }
00458 
00459 unsigned FastEmit_ISD_FP_ROUND_MVT_f80_r(MVT RetVT, unsigned Op0) {
00460 switch (RetVT.SimpleTy) {
00461   case MVT::f32: return FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f32_r(Op0);
00462   case MVT::f64: return FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f64_r(Op0);
00463   default: return 0;
00464 }
00465 }
00466 
00467 unsigned FastEmit_ISD_FP_ROUND_r(MVT VT, MVT RetVT, unsigned Op0) {
00468   switch (VT.SimpleTy) {
00469   case MVT::f64: return FastEmit_ISD_FP_ROUND_MVT_f64_r(RetVT, Op0);
00470   case MVT::f80: return FastEmit_ISD_FP_ROUND_MVT_f80_r(RetVT, Op0);
00471   default: return 0;
00472   }
00473 }
00474 
00475 // FastEmit functions for ISD::FP_TO_SINT.
00476 
00477 unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(unsigned Op0) {
00478   if ((Subtarget->hasSSE1())) {
00479     return FastEmitInst_r(X86::CVTTSS2SIrr, X86::GR32RegisterClass, Op0);
00480   }
00481   return 0;
00482 }
00483 
00484 unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(unsigned Op0) {
00485   if ((Subtarget->hasSSE1())) {
00486     return FastEmitInst_r(X86::CVTTSS2SI64rr, X86::GR64RegisterClass, Op0);
00487   }
00488   return 0;
00489 }
00490 
00491 unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_r(MVT RetVT, unsigned Op0) {
00492 switch (RetVT.SimpleTy) {
00493   case MVT::i32: return FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(Op0);
00494   case MVT::i64: return FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(Op0);
00495   default: return 0;
00496 }
00497 }
00498 
00499 unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(unsigned Op0) {
00500   if ((Subtarget->hasSSE2())) {
00501     return FastEmitInst_r(X86::CVTTSD2SIrr, X86::GR32RegisterClass, Op0);
00502   }
00503   return 0;
00504 }
00505 
00506 unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(unsigned Op0) {
00507   if ((Subtarget->hasSSE2())) {
00508     return FastEmitInst_r(X86::CVTTSD2SI64rr, X86::GR64RegisterClass, Op0);
00509   }
00510   return 0;
00511 }
00512 
00513 unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_r(MVT RetVT, unsigned Op0) {
00514 switch (RetVT.SimpleTy) {
00515   case MVT::i32: return FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(Op0);
00516   case MVT::i64: return FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(Op0);
00517   default: return 0;
00518 }
00519 }
00520 
00521 unsigned FastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
00522   if (RetVT.SimpleTy != MVT::v4i32)
00523     return 0;
00524   if ((Subtarget->hasSSE2())) {
00525     return FastEmitInst_r(X86::Int_CVTTPS2DQrr, X86::VR128RegisterClass, Op0);
00526   }
00527   return 0;
00528 }
00529 
00530 unsigned FastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(MVT RetVT, unsigned Op0) {
00531   if (RetVT.SimpleTy != MVT::v2i32)
00532     return 0;
00533   if ((Subtarget->hasSSE2())) {
00534     return FastEmitInst_r(X86::Int_CVTTPD2PIrr, X86::VR64RegisterClass, Op0);
00535   }
00536   return 0;
00537 }
00538 
00539 unsigned FastEmit_ISD_FP_TO_SINT_r(MVT VT, MVT RetVT, unsigned Op0) {
00540   switch (VT.SimpleTy) {
00541   case MVT::f32: return FastEmit_ISD_FP_TO_SINT_MVT_f32_r(RetVT, Op0);
00542   case MVT::f64: return FastEmit_ISD_FP_TO_SINT_MVT_f64_r(RetVT, Op0);
00543   case MVT::v4f32: return FastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(RetVT, Op0);
00544   case MVT::v2f64: return FastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(RetVT, Op0);
00545   default: return 0;
00546   }
00547 }
00548 
00549 // FastEmit functions for ISD::FSIN.
00550 
00551 unsigned FastEmit_ISD_FSIN_MVT_f32_r(MVT RetVT, unsigned Op0) {
00552   if (RetVT.SimpleTy != MVT::f32)
00553     return 0;
00554   if ((!Subtarget->hasSSE1())) {
00555     return FastEmitInst_r(X86::SIN_Fp32, X86::RFP32RegisterClass, Op0);
00556   }
00557   return 0;
00558 }
00559 
00560 unsigned FastEmit_ISD_FSIN_MVT_f64_r(MVT RetVT, unsigned Op0) {
00561   if (RetVT.SimpleTy != MVT::f64)
00562     return 0;
00563   if ((!Subtarget->hasSSE2())) {
00564     return FastEmitInst_r(X86::SIN_Fp64, X86::RFP64RegisterClass, Op0);
00565   }
00566   return 0;
00567 }
00568 
00569 unsigned FastEmit_ISD_FSIN_MVT_f80_r(MVT RetVT, unsigned Op0) {
00570   if (RetVT.SimpleTy != MVT::f80)
00571     return 0;
00572   return FastEmitInst_r(X86::SIN_Fp80, X86::RFP80RegisterClass, Op0);
00573 }
00574 
00575 unsigned FastEmit_ISD_FSIN_r(MVT VT, MVT RetVT, unsigned Op0) {
00576   switch (VT.SimpleTy) {
00577   case MVT::f32: return FastEmit_ISD_FSIN_MVT_f32_r(RetVT, Op0);
00578   case MVT::f64: return FastEmit_ISD_FSIN_MVT_f64_r(RetVT, Op0);
00579   case MVT::f80: return FastEmit_ISD_FSIN_MVT_f80_r(RetVT, Op0);
00580   default: return 0;
00581   }
00582 }
00583 
00584 // FastEmit functions for ISD::FSQRT.
00585 
00586 unsigned FastEmit_ISD_FSQRT_MVT_f32_r(MVT RetVT, unsigned Op0) {
00587   if (RetVT.SimpleTy != MVT::f32)
00588     return 0;
00589   if ((!Subtarget->hasSSE1())) {
00590     return FastEmitInst_r(X86::SQRT_Fp32, X86::RFP32RegisterClass, Op0);
00591   }
00592   if ((Subtarget->hasSSE1())) {
00593     return FastEmitInst_r(X86::SQRTSSr, X86::FR32RegisterClass, Op0);
00594   }
00595   return 0;
00596 }
00597 
00598 unsigned FastEmit_ISD_FSQRT_MVT_f64_r(MVT RetVT, unsigned Op0) {
00599   if (RetVT.SimpleTy != MVT::f64)
00600     return 0;
00601   if ((!Subtarget->hasSSE2())) {
00602     return FastEmitInst_r(X86::SQRT_Fp64, X86::RFP64RegisterClass, Op0);
00603   }
00604   if ((Subtarget->hasSSE2())) {
00605     return FastEmitInst_r(X86::SQRTSDr, X86::FR64RegisterClass, Op0);
00606   }
00607   return 0;
00608 }
00609 
00610 unsigned FastEmit_ISD_FSQRT_MVT_f80_r(MVT RetVT, unsigned Op0) {
00611   if (RetVT.SimpleTy != MVT::f80)
00612     return 0;
00613   return FastEmitInst_r(X86::SQRT_Fp80, X86::RFP80RegisterClass, Op0);
00614 }
00615 
00616 unsigned FastEmit_ISD_FSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
00617   if (RetVT.SimpleTy != MVT::v4f32)
00618     return 0;
00619   if ((Subtarget->hasSSE1())) {
00620     return FastEmitInst_r(X86::SQRTPSr, X86::VR128RegisterClass, Op0);
00621   }
00622   return 0;
00623 }
00624 
00625 unsigned FastEmit_ISD_FSQRT_MVT_v2f64_r(MVT RetVT, unsigned Op0) {
00626   if (RetVT.SimpleTy != MVT::v2f64)
00627     return 0;
00628   if ((Subtarget->hasSSE2())) {
00629     return FastEmitInst_r(X86::SQRTPDr, X86::VR128RegisterClass, Op0);
00630   }
00631   return 0;
00632 }
00633 
00634 unsigned FastEmit_ISD_FSQRT_r(MVT VT, MVT RetVT, unsigned Op0) {
00635   switch (VT.SimpleTy) {
00636   case MVT::f32: return FastEmit_ISD_FSQRT_MVT_f32_r(RetVT, Op0);
00637   case MVT::f64: return FastEmit_ISD_FSQRT_MVT_f64_r(RetVT, Op0);
00638   case MVT::f80: return FastEmit_ISD_FSQRT_MVT_f80_r(RetVT, Op0);
00639   case MVT::v4f32: return FastEmit_ISD_FSQRT_MVT_v4f32_r(RetVT, Op0);
00640   case MVT::v2f64: return FastEmit_ISD_FSQRT_MVT_v2f64_r(RetVT, Op0);
00641   default: return 0;
00642   }
00643 }
00644 
00645 // FastEmit functions for ISD::SCALAR_TO_VECTOR.
00646 
00647 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v2i32_r(unsigned Op0) {
00648   if ((Subtarget->hasMMX())) {
00649     return FastEmitInst_r(X86::MMX_MOVD64rr, X86::VR64RegisterClass, Op0);
00650   }
00651   return 0;
00652 }
00653 
00654 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(unsigned Op0) {
00655   if ((Subtarget->hasSSE2())) {
00656     return FastEmitInst_r(X86::MOVDI2PDIrr, X86::VR128RegisterClass, Op0);
00657   }
00658   return 0;
00659 }
00660 
00661 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(MVT RetVT, unsigned Op0) {
00662 switch (RetVT.SimpleTy) {
00663   case MVT::v2i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v2i32_r(Op0);
00664   case MVT::v4i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(Op0);
00665   default: return 0;
00666 }
00667 }
00668 
00669 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v1i64_r(unsigned Op0) {
00670   if ((Subtarget->hasMMX())) {
00671     return FastEmitInst_r(X86::MMX_MOVD64rrv164, X86::VR64RegisterClass, Op0);
00672   }
00673   return 0;
00674 }
00675 
00676 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v2i64_r(unsigned Op0) {
00677   if ((Subtarget->hasSSE2())) {
00678     return FastEmitInst_r(X86::MOV64toPQIrr, X86::VR128RegisterClass, Op0);
00679   }
00680   return 0;
00681 }
00682 
00683 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(MVT RetVT, unsigned Op0) {
00684 switch (RetVT.SimpleTy) {
00685   case MVT::v1i64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v1i64_r(Op0);
00686   case MVT::v2i64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v2i64_r(Op0);
00687   default: return 0;
00688 }
00689 }
00690 
00691 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_f32_r(MVT RetVT, unsigned Op0) {
00692   if (RetVT.SimpleTy != MVT::v4f32)
00693     return 0;
00694   if ((Subtarget->hasSSE1())) {
00695     return FastEmitInst_r(X86::MOVSS2PSrr, X86::VR128RegisterClass, Op0);
00696   }
00697   return 0;
00698 }
00699 
00700 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_f64_r(MVT RetVT, unsigned Op0) {
00701   if (RetVT.SimpleTy != MVT::v2f64)
00702     return 0;
00703   if ((Subtarget->hasSSE2())) {
00704     return FastEmitInst_r(X86::MOVSD2PDrr, X86::VR128RegisterClass, Op0);
00705   }
00706   return 0;
00707 }
00708 
00709 unsigned FastEmit_ISD_SCALAR_TO_VECTOR_r(MVT VT, MVT RetVT, unsigned Op0) {
00710   switch (VT.SimpleTy) {
00711   case MVT::i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(RetVT, Op0);
00712   case MVT::i64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(RetVT, Op0);
00713   case MVT::f32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_f32_r(RetVT, Op0);
00714   case MVT::f64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_f64_r(RetVT, Op0);
00715   default: return 0;
00716   }
00717 }
00718 
00719 // FastEmit functions for ISD::SIGN_EXTEND.
00720 
00721 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i16_r(unsigned Op0) {
00722   return FastEmitInst_r(X86::MOVSX16rr8, X86::GR16RegisterClass, Op0);
00723 }
00724 
00725 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0) {
00726   return FastEmitInst_r(X86::MOVSX32rr8, X86::GR32RegisterClass, Op0);
00727 }
00728 
00729 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0) {
00730   return FastEmitInst_r(X86::MOVSX64rr8, X86::GR64RegisterClass, Op0);
00731 }
00732 
00733 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0) {
00734 switch (RetVT.SimpleTy) {
00735   case MVT::i16: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i16_r(Op0);
00736   case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(Op0);
00737   case MVT::i64: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(Op0);
00738   default: return 0;
00739 }
00740 }
00741 
00742 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0) {
00743   return FastEmitInst_r(X86::MOVSX32rr16, X86::GR32RegisterClass, Op0);
00744 }
00745 
00746 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0) {
00747   return FastEmitInst_r(X86::MOVSX64rr16, X86::GR64RegisterClass, Op0);
00748 }
00749 
00750 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0) {
00751 switch (RetVT.SimpleTy) {
00752   case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(Op0);
00753   case MVT::i64: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(Op0);
00754   default: return 0;
00755 }
00756 }
00757 
00758 unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i32_r(MVT RetVT, unsigned Op0) {
00759   if (RetVT.SimpleTy != MVT::i64)
00760     return 0;
00761   return FastEmitInst_r(X86::MOVSX64rr32, X86::GR64RegisterClass, Op0);
00762 }
00763 
00764 unsigned FastEmit_ISD_SIGN_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
00765   switch (VT.SimpleTy) {
00766   case MVT::i8: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_r(RetVT, Op0);
00767   case MVT::i16: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_r(RetVT, Op0);
00768   case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i32_r(RetVT, Op0);
00769   default: return 0;
00770   }
00771 }
00772 
00773 // FastEmit functions for ISD::SINT_TO_FP.
00774 
00775 unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(unsigned Op0) {
00776   if ((Subtarget->hasSSE1())) {
00777     return FastEmitInst_r(X86::CVTSI2SSrr, X86::FR32RegisterClass, Op0);
00778   }
00779   return 0;
00780 }
00781 
00782 unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(unsigned Op0) {
00783   if ((Subtarget->hasSSE2())) {
00784     return FastEmitInst_r(X86::CVTSI2SDrr, X86::FR64RegisterClass, Op0);
00785   }
00786   return 0;
00787 }
00788 
00789 unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_r(MVT RetVT, unsigned Op0) {
00790 switch (RetVT.SimpleTy) {
00791   case MVT::f32: return FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
00792   case MVT::f64: return FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
00793   default: return 0;
00794 }
00795 }
00796 
00797 unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(unsigned Op0) {
00798   if ((Subtarget->hasSSE1())) {
00799     return FastEmitInst_r(X86::CVTSI2SS64rr, X86::FR32RegisterClass, Op0);
00800   }
00801   return 0;
00802 }
00803 
00804 unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(unsigned Op0) {
00805   if ((Subtarget->hasSSE2())) {
00806     return FastEmitInst_r(X86::CVTSI2SD64rr, X86::FR64RegisterClass, Op0);
00807   }
00808   return 0;
00809 }
00810 
00811 unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_r(MVT RetVT, unsigned Op0) {
00812 switch (RetVT.SimpleTy) {
00813   case MVT::f32: return FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(Op0);
00814   case MVT::f64: return FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(Op0);
00815   default: return 0;
00816 }
00817 }
00818 
00819 unsigned FastEmit_ISD_SINT_TO_FP_MVT_v2i32_r(MVT RetVT, unsigned Op0) {
00820   if (RetVT.SimpleTy != MVT::v2f64)
00821     return 0;
00822   if ((Subtarget->hasSSE2())) {
00823     return FastEmitInst_r(X86::Int_CVTPI2PDrr, X86::VR128RegisterClass, Op0);
00824   }
00825   return 0;
00826 }
00827 
00828 unsigned FastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(MVT RetVT, unsigned Op0) {
00829   if (RetVT.SimpleTy != MVT::v4f32)
00830     return 0;
00831   if ((Subtarget->hasSSE2())) {
00832     return FastEmitInst_r(X86::Int_CVTDQ2PSrr, X86::VR128RegisterClass, Op0);
00833   }
00834   return 0;
00835 }
00836 
00837 unsigned FastEmit_ISD_SINT_TO_FP_r(MVT VT, MVT RetVT, unsigned Op0) {
00838   switch (VT.SimpleTy) {
00839   case MVT::i32: return FastEmit_ISD_SINT_TO_FP_MVT_i32_r(RetVT, Op0);
00840   case MVT::i64: return FastEmit_ISD_SINT_TO_FP_MVT_i64_r(RetVT, Op0);
00841   case MVT::v2i32: return FastEmit_ISD_SINT_TO_FP_MVT_v2i32_r(RetVT, Op0);
00842   case MVT::v4i32: return FastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
00843   default: return 0;
00844   }
00845 }
00846 
00847 // FastEmit functions for ISD::TRUNCATE.
00848 
00849 unsigned FastEmit_ISD_TRUNCATE_MVT_i16_r(MVT RetVT, unsigned Op0) {
00850   if (RetVT.SimpleTy != MVT::i8)
00851     return 0;
00852   if ((Subtarget->is64Bit())) {
00853     return FastEmitInst_extractsubreg(RetVT, Op0, 1);
00854   }
00855   return 0;
00856 }
00857 
00858 unsigned FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(unsigned Op0) {
00859   if ((Subtarget->is64Bit())) {
00860     return FastEmitInst_extractsubreg(MVT::i8, Op0, 1);
00861   }
00862   return 0;
00863 }
00864 
00865 unsigned FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(unsigned Op0) {
00866   return FastEmitInst_extractsubreg(MVT::i16, Op0, 3);
00867 }
00868 
00869 unsigned FastEmit_ISD_TRUNCATE_MVT_i32_r(MVT RetVT, unsigned Op0) {
00870 switch (RetVT.SimpleTy) {
00871   case MVT::i8: return FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(Op0);
00872   case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(Op0);
00873   default: return 0;
00874 }
00875 }
00876 
00877 unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(unsigned Op0) {
00878   return FastEmitInst_extractsubreg(MVT::i8, Op0, 1);
00879 }
00880 
00881 unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(unsigned Op0) {
00882   return FastEmitInst_extractsubreg(MVT::i16, Op0, 3);
00883 }
00884 
00885 unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(unsigned Op0) {
00886   return FastEmitInst_extractsubreg(MVT::i32, Op0, 4);
00887 }
00888 
00889 unsigned FastEmit_ISD_TRUNCATE_MVT_i64_r(MVT RetVT, unsigned Op0) {
00890 switch (RetVT.SimpleTy) {
00891   case MVT::i8: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(Op0);
00892   case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(Op0);
00893   case MVT::i32: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(Op0);
00894   default: return 0;
00895 }
00896 }
00897 
00898 unsigned FastEmit_ISD_TRUNCATE_r(MVT VT, MVT RetVT, unsigned Op0) {
00899   switch (VT.SimpleTy) {
00900   case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i16_r(RetVT, Op0);
00901   case MVT::i32: return FastEmit_ISD_TRUNCATE_MVT_i32_r(RetVT, Op0);
00902   case MVT::i64: return FastEmit_ISD_TRUNCATE_MVT_i64_r(RetVT, Op0);
00903   default: return 0;
00904   }
00905 }
00906 
00907 // FastEmit functions for ISD::ZERO_EXTEND.
00908 
00909 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i16_r(unsigned Op0) {
00910   return FastEmitInst_r(X86::MOVZX16rr8, X86::GR16RegisterClass, Op0);
00911 }
00912 
00913 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0) {
00914   return FastEmitInst_r(X86::MOVZX32rr8, X86::GR32RegisterClass, Op0);
00915 }
00916 
00917 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0) {
00918   return FastEmitInst_r(X86::MOVZX64rr8, X86::GR64RegisterClass, Op0);
00919 }
00920 
00921 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0) {
00922 switch (RetVT.SimpleTy) {
00923   case MVT::i16: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i16_r(Op0);
00924   case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i32_r(Op0);
00925   case MVT::i64: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i64_r(Op0);
00926   default: return 0;
00927 }
00928 }
00929 
00930 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0) {
00931   return FastEmitInst_r(X86::MOVZX32rr16, X86::GR32RegisterClass, Op0);
00932 }
00933 
00934 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0) {
00935   return FastEmitInst_r(X86::MOVZX64rr16, X86::GR64RegisterClass, Op0);
00936 }
00937 
00938 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0) {
00939 switch (RetVT.SimpleTy) {
00940   case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i32_r(Op0);
00941   case MVT::i64: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i64_r(Op0);
00942   default: return 0;
00943 }
00944 }
00945 
00946 unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i32_r(MVT RetVT, unsigned Op0) {
00947   if (RetVT.SimpleTy != MVT::i64)
00948     return 0;
00949   return FastEmitInst_r(X86::MOVZX64rr32, X86::GR64RegisterClass, Op0);
00950 }
00951 
00952 unsigned FastEmit_ISD_ZERO_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
00953   switch (VT.SimpleTy) {
00954   case MVT::i8: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_r(RetVT, Op0);
00955   case MVT::i16: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_r(RetVT, Op0);
00956   case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i32_r(RetVT, Op0);
00957   default: return 0;
00958   }
00959 }
00960 
00961 // FastEmit functions for X86ISD::BSF.
00962 
00963 unsigned FastEmit_X86ISD_BSF_MVT_i16_r(MVT RetVT, unsigned Op0) {
00964   if (RetVT.SimpleTy != MVT::i16)
00965     return 0;
00966   return FastEmitInst_r(X86::BSF16rr, X86::GR16RegisterClass, Op0);
00967 }
00968 
00969 unsigned FastEmit_X86ISD_BSF_MVT_i32_r(MVT RetVT, unsigned Op0) {
00970   if (RetVT.SimpleTy != MVT::i32)
00971     return 0;
00972   return FastEmitInst_r(X86::BSF32rr, X86::GR32RegisterClass, Op0);
00973 }
00974 
00975 unsigned FastEmit_X86ISD_BSF_MVT_i64_r(MVT RetVT, unsigned Op0) {
00976   if (RetVT.SimpleTy != MVT::i64)
00977     return 0;
00978   return FastEmitInst_r(X86::BSF64rr, X86::GR64RegisterClass, Op0);
00979 }
00980 
00981 unsigned FastEmit_X86ISD_BSF_r(MVT VT, MVT RetVT, unsigned Op0) {
00982   switch (VT.SimpleTy) {
00983   case MVT::i16: return FastEmit_X86ISD_BSF_MVT_i16_r(RetVT, Op0);
00984   case MVT::i32: return FastEmit_X86ISD_BSF_MVT_i32_r(RetVT, Op0);
00985   case MVT::i64: return FastEmit_X86ISD_BSF_MVT_i64_r(RetVT, Op0);
00986   default: return 0;
00987   }
00988 }
00989 
00990 // FastEmit functions for X86ISD::BSR.
00991 
00992 unsigned FastEmit_X86ISD_BSR_MVT_i16_r(MVT RetVT, unsigned Op0) {
00993   if (RetVT.SimpleTy != MVT::i16)
00994     return 0;
00995   return FastEmitInst_r(X86::BSR16rr, X86::GR16RegisterClass, Op0);
00996 }
00997 
00998 unsigned FastEmit_X86ISD_BSR_MVT_i32_r(MVT RetVT, unsigned Op0) {
00999   if (RetVT.SimpleTy != MVT::i32)
01000     return 0;
01001   return FastEmitInst_r(X86::BSR32rr, X86::GR32RegisterClass, Op0);
01002 }
01003 
01004 unsigned FastEmit_X86ISD_BSR_MVT_i64_r(MVT RetVT, unsigned Op0) {
01005   if (RetVT.SimpleTy != MVT::i64)
01006     return 0;
01007   return FastEmitInst_r(X86::BSR64rr, X86::GR64RegisterClass, Op0);
01008 }
01009 
01010 unsigned FastEmit_X86ISD_BSR_r(MVT VT, MVT RetVT, unsigned Op0) {
01011   switch (VT.SimpleTy) {
01012   case MVT::i16: return FastEmit_X86ISD_BSR_MVT_i16_r(RetVT, Op0);
01013   case MVT::i32: return FastEmit_X86ISD_BSR_MVT_i32_r(RetVT, Op0);
01014   case MVT::i64: return FastEmit_X86ISD_BSR_MVT_i64_r(RetVT, Op0);
01015   default: return 0;
01016   }
01017 }
01018 
01019 // FastEmit functions for X86ISD::CALL.
01020 
01021 unsigned FastEmit_X86ISD_CALL_MVT_i32_r(MVT RetVT, unsigned Op0) {
01022   if (RetVT.SimpleTy != MVT::isVoid)
01023     return 0;
01024   return FastEmitInst_r(X86::CALL32r, X86::GR32RegisterClass, Op0);
01025 }
01026 
01027 unsigned FastEmit_X86ISD_CALL_MVT_i64_r(MVT RetVT, unsigned Op0) {
01028   if (RetVT.SimpleTy != MVT::isVoid)
01029     return 0;
01030   if ((!Subtarget->isTargetWin64())) {
01031     return FastEmitInst_r(X86::CALL64r, X86::GR64RegisterClass, Op0);
01032   }
01033   if ((Subtarget->isTargetWin64())) {
01034     return FastEmitInst_r(X86::WINCALL64r, X86::GR64RegisterClass, Op0);
01035   }
01036   return 0;
01037 }
01038 
01039 unsigned FastEmit_X86ISD_CALL_r(MVT VT, MVT RetVT, unsigned Op0) {
01040   switch (VT.SimpleTy) {
01041   case MVT::i32: return FastEmit_X86ISD_CALL_MVT_i32_r(RetVT, Op0);
01042   case MVT::i64: return FastEmit_X86ISD_CALL_MVT_i64_r(RetVT, Op0);
01043   default: return 0;
01044   }
01045 }
01046 
01047 // FastEmit functions for X86ISD::DEC.
01048 
01049 unsigned FastEmit_X86ISD_DEC_MVT_i8_r(MVT RetVT, unsigned Op0) {
01050   if (RetVT.SimpleTy != MVT::i8)
01051     return 0;
01052   return FastEmitInst_r(X86::DEC8r, X86::GR8RegisterClass, Op0);
01053 }
01054 
01055 unsigned FastEmit_X86ISD_DEC_MVT_i16_r(MVT RetVT, unsigned Op0) {
01056   if (RetVT.SimpleTy != MVT::i16)
01057     return 0;
01058   if ((!Subtarget->is64Bit())) {
01059     return FastEmitInst_r(X86::DEC16r, X86::GR16RegisterClass, Op0);
01060   }
01061   if ((Subtarget->is64Bit())) {
01062     return FastEmitInst_r(X86::DEC64_16r, X86::GR16RegisterClass, Op0);
01063   }
01064   return 0;
01065 }
01066 
01067 unsigned FastEmit_X86ISD_DEC_MVT_i32_r(MVT RetVT, unsigned Op0) {
01068   if (RetVT.SimpleTy != MVT::i32)
01069     return 0;
01070   if ((!Subtarget->is64Bit())) {
01071     return FastEmitInst_r(X86::DEC32r, X86::GR32RegisterClass, Op0);
01072   }
01073   if ((Subtarget->is64Bit())) {
01074     return FastEmitInst_r(X86::DEC64_32r, X86::GR32RegisterClass, Op0);
01075   }
01076   return 0;
01077 }
01078 
01079 unsigned FastEmit_X86ISD_DEC_MVT_i64_r(MVT RetVT, unsigned Op0) {
01080   if (RetVT.SimpleTy != MVT::i64)
01081     return 0;
01082   return FastEmitInst_r(X86::DEC64r, X86::GR64RegisterClass, Op0);
01083 }
01084 
01085 unsigned FastEmit_X86ISD_DEC_r(MVT VT, MVT RetVT, unsigned Op0) {
01086   switch (VT.SimpleTy) {
01087   case MVT::i8: return FastEmit_X86ISD_DEC_MVT_i8_r(RetVT, Op0);
01088   case MVT::i16: return FastEmit_X86ISD_DEC_MVT_i16_r(RetVT, Op0);
01089   case MVT::i32: return FastEmit_X86ISD_DEC_MVT_i32_r(RetVT, Op0);
01090   case MVT::i64: return FastEmit_X86ISD_DEC_MVT_i64_r(RetVT, Op0);
01091   default: return 0;
01092   }
01093 }
01094 
01095 // FastEmit functions for X86ISD::EH_RETURN.
01096 
01097 unsigned FastEmit_X86ISD_EH_RETURN_MVT_i32_r(MVT RetVT, unsigned Op0) {
01098   if (RetVT.SimpleTy != MVT::isVoid)
01099     return 0;
01100   return FastEmitInst_r(X86::EH_RETURN, X86::GR32RegisterClass, Op0);
01101 }
01102 
01103 unsigned FastEmit_X86ISD_EH_RETURN_MVT_i64_r(MVT RetVT, unsigned Op0) {
01104   if (RetVT.SimpleTy != MVT::isVoid)
01105     return 0;
01106   return FastEmitInst_r(X86::EH_RETURN64, X86::GR64RegisterClass, Op0);
01107 }
01108 
01109 unsigned FastEmit_X86ISD_EH_RETURN_r(MVT VT, MVT RetVT, unsigned Op0) {
01110   switch (VT.SimpleTy) {
01111   case MVT::i32: return FastEmit_X86ISD_EH_RETURN_MVT_i32_r(RetVT, Op0);
01112   case MVT::i64: return FastEmit_X86ISD_EH_RETURN_MVT_i64_r(RetVT, Op0);
01113   default: return 0;
01114   }
01115 }
01116 
01117 // FastEmit functions for X86ISD::FRCP.
01118 
01119 unsigned FastEmit_X86ISD_FRCP_MVT_f32_r(MVT RetVT, unsigned Op0) {
01120   if (RetVT.SimpleTy != MVT::f32)
01121     return 0;
01122   if ((Subtarget->hasSSE1())) {
01123     return FastEmitInst_r(X86::RCPSSr, X86::FR32RegisterClass, Op0);
01124   }
01125   return 0;
01126 }
01127 
01128 unsigned FastEmit_X86ISD_FRCP_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
01129   if (RetVT.SimpleTy != MVT::v4f32)
01130     return 0;
01131   if ((Subtarget->hasSSE1())) {
01132     return FastEmitInst_r(X86::RCPPSr, X86::VR128RegisterClass, Op0);
01133   }
01134   return 0;
01135 }
01136 
01137 unsigned FastEmit_X86ISD_FRCP_r(MVT VT, MVT RetVT, unsigned Op0) {
01138   switch (VT.SimpleTy) {
01139   case MVT::f32: return FastEmit_X86ISD_FRCP_MVT_f32_r(RetVT, Op0);
01140   case MVT::v4f32: return FastEmit_X86ISD_FRCP_MVT_v4f32_r(RetVT, Op0);
01141   default: return 0;
01142   }
01143 }
01144 
01145 // FastEmit functions for X86ISD::FRSQRT.
01146 
01147 unsigned FastEmit_X86ISD_FRSQRT_MVT_f32_r(MVT RetVT, unsigned Op0) {
01148   if (RetVT.SimpleTy != MVT::f32)
01149     return 0;
01150   if ((Subtarget->hasSSE1())) {
01151     return FastEmitInst_r(X86::RSQRTSSr, X86::FR32RegisterClass, Op0);
01152   }
01153   return 0;
01154 }
01155 
01156 unsigned FastEmit_X86ISD_FRSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
01157   if (RetVT.SimpleTy != MVT::v4f32)
01158     return 0;
01159   if ((Subtarget->hasSSE1())) {
01160     return FastEmitInst_r(X86::RSQRTPSr, X86::VR128RegisterClass, Op0);
01161   }
01162   return 0;
01163 }
01164 
01165 unsigned FastEmit_X86ISD_FRSQRT_r(MVT VT, MVT RetVT, unsigned Op0) {
01166   switch (VT.SimpleTy) {
01167   case MVT::f32: return FastEmit_X86ISD_FRSQRT_MVT_f32_r(RetVT, Op0);
01168   case MVT::v4f32: return FastEmit_X86ISD_FRSQRT_MVT_v4f32_r(RetVT, Op0);
01169   default: return 0;
01170   }
01171 }
01172 
01173 // FastEmit functions for X86ISD::INC.
01174 
01175 unsigned FastEmit_X86ISD_INC_MVT_i8_r(MVT RetVT, unsigned Op0) {
01176   if (RetVT.SimpleTy != MVT::i8)
01177     return 0;
01178   return FastEmitInst_r(X86::INC8r, X86::GR8RegisterClass, Op0);
01179 }
01180 
01181 unsigned FastEmit_X86ISD_INC_MVT_i16_r(MVT RetVT, unsigned Op0) {
01182   if (RetVT.SimpleTy != MVT::i16)
01183     return 0;
01184   if ((!Subtarget->is64Bit())) {
01185     return FastEmitInst_r(X86::INC16r, X86::GR16RegisterClass, Op0);
01186   }
01187   if ((Subtarget->is64Bit())) {
01188     return FastEmitInst_r(X86::INC64_16r, X86::GR16RegisterClass, Op0);
01189   }
01190   return 0;
01191 }
01192 
01193 unsigned FastEmit_X86ISD_INC_MVT_i32_r(MVT RetVT, unsigned Op0) {
01194   if (RetVT.SimpleTy != MVT::i32)
01195     return 0;
01196   if ((!Subtarget->is64Bit())) {
01197     return FastEmitInst_r(X86::INC32r, X86::GR32RegisterClass, Op0);
01198   }
01199   if ((Subtarget->is64Bit())) {
01200     return FastEmitInst_r(X86::INC64_32r, X86::GR32RegisterClass, Op0);
01201   }
01202   return 0;
01203 }
01204 
01205 unsigned FastEmit_X86ISD_INC_MVT_i64_r(MVT RetVT, unsigned Op0) {
01206   if (RetVT.SimpleTy != MVT::i64)
01207     return 0;
01208   return FastEmitInst_r(X86::INC64r, X86::GR64RegisterClass, Op0);
01209 }
01210 
01211 unsigned FastEmit_X86ISD_INC_r(MVT VT, MVT RetVT, unsigned Op0) {
01212   switch (VT.SimpleTy) {
01213   case MVT::i8: return FastEmit_X86ISD_INC_MVT_i8_r(RetVT, Op0);
01214   case MVT::i16: return FastEmit_X86ISD_INC_MVT_i16_r(RetVT, Op0);
01215   case MVT::i32: return FastEmit_X86ISD_INC_MVT_i32_r(RetVT, Op0);
01216   case MVT::i64: return FastEmit_X86ISD_INC_MVT_i64_r(RetVT, Op0);
01217   default: return 0;
01218   }
01219 }
01220 
01221 // FastEmit functions for X86ISD::VZEXT_MOVL.
01222 
01223 unsigned FastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(MVT RetVT, unsigned Op0) {
01224   if (RetVT.SimpleTy != MVT::v2i64)
01225     return 0;
01226   if ((Subtarget->hasSSE2())) {
01227     return FastEmitInst_r(X86::MOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0);
01228   }
01229   return 0;
01230 }
01231 
01232 unsigned FastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(MVT RetVT, unsigned Op0) {
01233   if (RetVT.SimpleTy != MVT::v2f64)
01234     return 0;
01235   if ((Subtarget->hasSSE2())) {
01236     return FastEmitInst_r(X86::MOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0);
01237   }
01238   return 0;
01239 }
01240 
01241 unsigned FastEmit_X86ISD_VZEXT_MOVL_r(MVT VT, MVT RetVT, unsigned Op0) {
01242   switch (VT.SimpleTy) {
01243   case MVT::v2i64: return FastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(RetVT, Op0);
01244   case MVT::v2f64: return FastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(RetVT, Op0);
01245   default: return 0;
01246   }
01247 }
01248 
01249 // Top-level FastEmit function.
01250 
01251 unsigned FastEmit_r(MVT VT, MVT RetVT, ISD::NodeType Opcode, unsigned Op0) {
01252   switch (Opcode) {
01253   case ISD::ANY_EXTEND: return FastEmit_ISD_ANY_EXTEND_r(VT, RetVT, Op0);
01254   case ISD::BIT_CONVERT: return FastEmit_ISD_BIT_CONVERT_r(VT, RetVT, Op0);
01255   case ISD::BRIND: return FastEmit_ISD_BRIND_r(VT, RetVT, Op0);
01256   case ISD::BSWAP: return FastEmit_ISD_BSWAP_r(VT, RetVT, Op0);
01257   case ISD::FABS: return FastEmit_ISD_FABS_r(VT, RetVT, Op0);
01258   case ISD::FCOS: return FastEmit_ISD_FCOS_r(VT, RetVT, Op0);
01259   case ISD::FNEG: return FastEmit_ISD_FNEG_r(VT, RetVT, Op0);
01260   case ISD::FP_EXTEND: return FastEmit_ISD_FP_EXTEND_r(VT, RetVT, Op0);
01261   case ISD::FP_ROUND: return FastEmit_ISD_FP_ROUND_r(VT, RetVT, Op0);
01262   case ISD::FP_TO_SINT: return FastEmit_ISD_FP_TO_SINT_r(VT, RetVT, Op0);
01263   case ISD::FSIN: return FastEmit_ISD_FSIN_r(VT, RetVT, Op0);
01264   case ISD::FSQRT: return FastEmit_ISD_FSQRT_r(VT, RetVT, Op0);
01265   case ISD::SCALAR_TO_VECTOR: return FastEmit_ISD_SCALAR_TO_VECTOR_r(VT, RetVT, Op0);
01266   case ISD::SIGN_EXTEND: return FastEmit_ISD_SIGN_EXTEND_r(VT, RetVT, Op0);
01267   case ISD::SINT_TO_FP: return FastEmit_ISD_SINT_TO_FP_r(VT, RetVT, Op0);
01268   case ISD::TRUNCATE: return FastEmit_ISD_TRUNCATE_r(VT, RetVT, Op0);
01269   case ISD::ZERO_EXTEND: return FastEmit_ISD_ZERO_EXTEND_r(VT, RetVT, Op0);
01270   case X86ISD::BSF: return FastEmit_X86ISD_BSF_r(VT, RetVT, Op0);
01271   case X86ISD::BSR: return FastEmit_X86ISD_BSR_r(VT, RetVT, Op0);
01272   case X86ISD::CALL: return FastEmit_X86ISD_CALL_r(VT, RetVT, Op0);
01273   case X86ISD::DEC: return FastEmit_X86ISD_DEC_r(VT, RetVT, Op0);
01274   case X86ISD::EH_RETURN: return FastEmit_X86ISD_EH_RETURN_r(VT, RetVT, Op0);
01275   case X86ISD::FRCP: return FastEmit_X86ISD_FRCP_r(VT, RetVT, Op0);
01276   case X86ISD::FRSQRT: return FastEmit_X86ISD_FRSQRT_r(VT, RetVT, Op0);
01277   case X86ISD::INC: return FastEmit_X86ISD_INC_r(VT, RetVT, Op0);
01278   case X86ISD::VZEXT_MOVL: return FastEmit_X86ISD_VZEXT_MOVL_r(VT, RetVT, Op0);
01279   default: return 0;
01280   }
01281 }
01282 
01283 // FastEmit functions for ISD::ADD.
01284 
01285 unsigned FastEmit_ISD_ADD_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01286   if (RetVT.SimpleTy != MVT::i8)
01287     return 0;
01288   return FastEmitInst_ri(X86::ADD8ri, X86::GR8RegisterClass, Op0, imm1);
01289 }
01290 
01291 unsigned FastEmit_ISD_ADD_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01292   if (RetVT.SimpleTy != MVT::i16)
01293     return 0;
01294   return FastEmitInst_ri(X86::ADD16ri, X86::GR16RegisterClass, Op0, imm1);
01295 }
01296 
01297 unsigned FastEmit_ISD_ADD_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01298   if (RetVT.SimpleTy != MVT::i32)
01299     return 0;
01300   return FastEmitInst_ri(X86::ADD32ri, X86::GR32RegisterClass, Op0, imm1);
01301 }
01302 
01303 unsigned FastEmit_ISD_ADD_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01304   switch (VT.SimpleTy) {
01305   case MVT::i8: return FastEmit_ISD_ADD_MVT_i8_ri(RetVT, Op0, imm1);
01306   case MVT::i16: return FastEmit_ISD_ADD_MVT_i16_ri(RetVT, Op0, imm1);
01307   case MVT::i32: return FastEmit_ISD_ADD_MVT_i32_ri(RetVT, Op0, imm1);
01308   default: return 0;
01309   }
01310 }
01311 
01312 // FastEmit functions for ISD::ADDC.
01313 
01314 unsigned FastEmit_ISD_ADDC_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01315   if (RetVT.SimpleTy != MVT::i32)
01316     return 0;
01317   return FastEmitInst_ri(X86::ADD32ri, X86::GR32RegisterClass, Op0, imm1);
01318 }
01319 
01320 unsigned FastEmit_ISD_ADDC_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01321   switch (VT.SimpleTy) {
01322   case MVT::i32: return FastEmit_ISD_ADDC_MVT_i32_ri(RetVT, Op0, imm1);
01323   default: return 0;
01324   }
01325 }
01326 
01327 // FastEmit functions for ISD::ADDE.
01328 
01329 unsigned FastEmit_ISD_ADDE_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01330   if (RetVT.SimpleTy != MVT::i8)
01331     return 0;
01332   return FastEmitInst_ri(X86::ADC8ri, X86::GR8RegisterClass, Op0, imm1);
01333 }
01334 
01335 unsigned FastEmit_ISD_ADDE_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01336   if (RetVT.SimpleTy != MVT::i16)
01337     return 0;
01338   return FastEmitInst_ri(X86::ADC16ri, X86::GR16RegisterClass, Op0, imm1);
01339 }
01340 
01341 unsigned FastEmit_ISD_ADDE_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01342   if (RetVT.SimpleTy != MVT::i32)
01343     return 0;
01344   return FastEmitInst_ri(X86::ADC32ri, X86::GR32RegisterClass, Op0, imm1);
01345 }
01346 
01347 unsigned FastEmit_ISD_ADDE_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01348   switch (VT.SimpleTy) {
01349   case MVT::i8: return FastEmit_ISD_ADDE_MVT_i8_ri(RetVT, Op0, imm1);
01350   case MVT::i16: return FastEmit_ISD_ADDE_MVT_i16_ri(RetVT, Op0, imm1);
01351   case MVT::i32: return FastEmit_ISD_ADDE_MVT_i32_ri(RetVT, Op0, imm1);
01352   default: return 0;
01353   }
01354 }
01355 
01356 // FastEmit functions for ISD::AND.
01357 
01358 unsigned FastEmit_ISD_AND_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01359   if (RetVT.SimpleTy != MVT::i8)
01360     return 0;
01361   return FastEmitInst_ri(X86::AND8ri, X86::GR8RegisterClass, Op0, imm1);
01362 }
01363 
01364 unsigned FastEmit_ISD_AND_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01365   if (RetVT.SimpleTy != MVT::i16)
01366     return 0;
01367   return FastEmitInst_ri(X86::AND16ri, X86::GR16RegisterClass, Op0, imm1);
01368 }
01369 
01370 unsigned FastEmit_ISD_AND_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01371   if (RetVT.SimpleTy != MVT::i32)
01372     return 0;
01373   return FastEmitInst_ri(X86::AND32ri, X86::GR32RegisterClass, Op0, imm1);
01374 }
01375 
01376 unsigned FastEmit_ISD_AND_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01377   switch (VT.SimpleTy) {
01378   case MVT::i8: return FastEmit_ISD_AND_MVT_i8_ri(RetVT, Op0, imm1);
01379   case MVT::i16: return FastEmit_ISD_AND_MVT_i16_ri(RetVT, Op0, imm1);
01380   case MVT::i32: return FastEmit_ISD_AND_MVT_i32_ri(RetVT, Op0, imm1);
01381   default: return 0;
01382   }
01383 }
01384 
01385 // FastEmit functions for ISD::MUL.
01386 
01387 unsigned FastEmit_ISD_MUL_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01388   if (RetVT.SimpleTy != MVT::i16)
01389     return 0;
01390   return FastEmitInst_ri(X86::IMUL16rri, X86::GR16RegisterClass, Op0, imm1);
01391 }
01392 
01393 unsigned FastEmit_ISD_MUL_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01394   if (RetVT.SimpleTy != MVT::i32)
01395     return 0;
01396   return FastEmitInst_ri(X86::IMUL32rri, X86::GR32RegisterClass, Op0, imm1);
01397 }
01398 
01399 unsigned FastEmit_ISD_MUL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01400   switch (VT.SimpleTy) {
01401   case MVT::i16: return FastEmit_ISD_MUL_MVT_i16_ri(RetVT, Op0, imm1);
01402   case MVT::i32: return FastEmit_ISD_MUL_MVT_i32_ri(RetVT, Op0, imm1);
01403   default: return 0;
01404   }
01405 }
01406 
01407 // FastEmit functions for ISD::OR.
01408 
01409 unsigned FastEmit_ISD_OR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01410   if (RetVT.SimpleTy != MVT::i8)
01411     return 0;
01412   return FastEmitInst_ri(X86::OR8ri, X86::GR8RegisterClass, Op0, imm1);
01413 }
01414 
01415 unsigned FastEmit_ISD_OR_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01416   if (RetVT.SimpleTy != MVT::i16)
01417     return 0;
01418   return FastEmitInst_ri(X86::OR16ri, X86::GR16RegisterClass, Op0, imm1);
01419 }
01420 
01421 unsigned FastEmit_ISD_OR_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01422   if (RetVT.SimpleTy != MVT::i32)
01423     return 0;
01424   return FastEmitInst_ri(X86::OR32ri, X86::GR32RegisterClass, Op0, imm1);
01425 }
01426 
01427 unsigned FastEmit_ISD_OR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01428   switch (VT.SimpleTy) {
01429   case MVT::i8: return FastEmit_ISD_OR_MVT_i8_ri(RetVT, Op0, imm1);
01430   case MVT::i16: return FastEmit_ISD_OR_MVT_i16_ri(RetVT, Op0, imm1);
01431   case MVT::i32: return FastEmit_ISD_OR_MVT_i32_ri(RetVT, Op0, imm1);
01432   default: return 0;
01433   }
01434 }
01435 
01436 // FastEmit functions for ISD::ROTL.
01437 
01438 unsigned FastEmit_ISD_ROTL_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01439   if (RetVT.SimpleTy != MVT::i8)
01440     return 0;
01441   return FastEmitInst_ri(X86::ROL8ri, X86::GR8RegisterClass, Op0, imm1);
01442 }
01443 
01444 unsigned FastEmit_ISD_ROTL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01445   switch (VT.SimpleTy) {
01446   case MVT::i8: return FastEmit_ISD_ROTL_MVT_i8_ri(RetVT, Op0, imm1);
01447   default: return 0;
01448   }
01449 }
01450 
01451 // FastEmit functions for ISD::ROTR.
01452 
01453 unsigned FastEmit_ISD_ROTR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01454   if (RetVT.SimpleTy != MVT::i8)
01455     return 0;
01456   return FastEmitInst_ri(X86::ROR8ri, X86::GR8RegisterClass, Op0, imm1);
01457 }
01458 
01459 unsigned FastEmit_ISD_ROTR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01460   switch (VT.SimpleTy) {
01461   case MVT::i8: return FastEmit_ISD_ROTR_MVT_i8_ri(RetVT, Op0, imm1);
01462   default: return 0;
01463   }
01464 }
01465 
01466 // FastEmit functions for ISD::SHL.
01467 
01468 unsigned FastEmit_ISD_SHL_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01469   if (RetVT.SimpleTy != MVT::i8)
01470     return 0;
01471   return FastEmitInst_ri(X86::SHL8ri, X86::GR8RegisterClass, Op0, imm1);
01472 }
01473 
01474 unsigned FastEmit_ISD_SHL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01475   switch (VT.SimpleTy) {
01476   case MVT::i8: return FastEmit_ISD_SHL_MVT_i8_ri(RetVT, Op0, imm1);
01477   default: return 0;
01478   }
01479 }
01480 
01481 // FastEmit functions for ISD::SRA.
01482 
01483 unsigned FastEmit_ISD_SRA_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01484   if (RetVT.SimpleTy != MVT::i8)
01485     return 0;
01486   return FastEmitInst_ri(X86::SAR8ri, X86::GR8RegisterClass, Op0, imm1);
01487 }
01488 
01489 unsigned FastEmit_ISD_SRA_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01490   switch (VT.SimpleTy) {
01491   case MVT::i8: return FastEmit_ISD_SRA_MVT_i8_ri(RetVT, Op0, imm1);
01492   default: return 0;
01493   }
01494 }
01495 
01496 // FastEmit functions for ISD::SRL.
01497 
01498 unsigned FastEmit_ISD_SRL_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01499   if (RetVT.SimpleTy != MVT::i8)
01500     return 0;
01501   return FastEmitInst_ri(X86::SHR8ri, X86::GR8RegisterClass, Op0, imm1);
01502 }
01503 
01504 unsigned FastEmit_ISD_SRL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01505   switch (VT.SimpleTy) {
01506   case MVT::i8: return FastEmit_ISD_SRL_MVT_i8_ri(RetVT, Op0, imm1);
01507   default: return 0;
01508   }
01509 }
01510 
01511 // FastEmit functions for ISD::SUB.
01512 
01513 unsigned FastEmit_ISD_SUB_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01514   if (RetVT.SimpleTy != MVT::i8)
01515     return 0;
01516   return FastEmitInst_ri(X86::SUB8ri, X86::GR8RegisterClass, Op0, imm1);
01517 }
01518 
01519 unsigned FastEmit_ISD_SUB_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01520   if (RetVT.SimpleTy != MVT::i16)
01521     return 0;
01522   return FastEmitInst_ri(X86::SUB16ri, X86::GR16RegisterClass, Op0, imm1);
01523 }
01524 
01525 unsigned FastEmit_ISD_SUB_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01526   if (RetVT.SimpleTy != MVT::i32)
01527     return 0;
01528   return FastEmitInst_ri(X86::SUB32ri, X86::GR32RegisterClass, Op0, imm1);
01529 }
01530 
01531 unsigned FastEmit_ISD_SUB_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01532   switch (VT.SimpleTy) {
01533   case MVT::i8: return FastEmit_ISD_SUB_MVT_i8_ri(RetVT, Op0, imm1);
01534   case MVT::i16: return FastEmit_ISD_SUB_MVT_i16_ri(RetVT, Op0, imm1);
01535   case MVT::i32: return FastEmit_ISD_SUB_MVT_i32_ri(RetVT, Op0, imm1);
01536   default: return 0;
01537   }
01538 }
01539 
01540 // FastEmit functions for ISD::SUBC.
01541 
01542 unsigned FastEmit_ISD_SUBC_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01543   if (RetVT.SimpleTy != MVT::i32)
01544     return 0;
01545   return FastEmitInst_ri(X86::SUB32ri, X86::GR32RegisterClass, Op0, imm1);
01546 }
01547 
01548 unsigned FastEmit_ISD_SUBC_MVT_i64_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01549   if (RetVT.SimpleTy != MVT::i64)
01550     return 0;
01551   return FastEmitInst_ri(X86::SUB64ri32, X86::GR64RegisterClass, Op0, imm1);
01552 }
01553 
01554 unsigned FastEmit_ISD_SUBC_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01555   switch (VT.SimpleTy) {
01556   case MVT::i32: return FastEmit_ISD_SUBC_MVT_i32_ri(RetVT, Op0, imm1);
01557   case MVT::i64: return FastEmit_ISD_SUBC_MVT_i64_ri(RetVT, Op0, imm1);
01558   default: return 0;
01559   }
01560 }
01561 
01562 // FastEmit functions for ISD::SUBE.
01563 
01564 unsigned FastEmit_ISD_SUBE_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01565   if (RetVT.SimpleTy != MVT::i8)
01566     return 0;
01567   return FastEmitInst_ri(X86::SBB8ri, X86::GR8RegisterClass, Op0, imm1);
01568 }
01569 
01570 unsigned FastEmit_ISD_SUBE_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01571   if (RetVT.SimpleTy != MVT::i16)
01572     return 0;
01573   return FastEmitInst_ri(X86::SBB16ri, X86::GR16RegisterClass, Op0, imm1);
01574 }
01575 
01576 unsigned FastEmit_ISD_SUBE_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01577   if (RetVT.SimpleTy != MVT::i32)
01578     return 0;
01579   return FastEmitInst_ri(X86::SBB32ri, X86::GR32RegisterClass, Op0, imm1);
01580 }
01581 
01582 unsigned FastEmit_ISD_SUBE_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01583   switch (VT.SimpleTy) {
01584   case MVT::i8: return FastEmit_ISD_SUBE_MVT_i8_ri(RetVT, Op0, imm1);
01585   case MVT::i16: return FastEmit_ISD_SUBE_MVT_i16_ri(RetVT, Op0, imm1);
01586   case MVT::i32: return FastEmit_ISD_SUBE_MVT_i32_ri(RetVT, Op0, imm1);
01587   default: return 0;
01588   }
01589 }
01590 
01591 // FastEmit functions for ISD::XOR.
01592 
01593 unsigned FastEmit_ISD_XOR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01594   if (RetVT.SimpleTy != MVT::i8)
01595     return 0;
01596   return FastEmitInst_ri(X86::XOR8ri, X86::GR8RegisterClass, Op0, imm1);
01597 }
01598 
01599 unsigned FastEmit_ISD_XOR_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01600   if (RetVT.SimpleTy != MVT::i16)
01601     return 0;
01602   return FastEmitInst_ri(X86::XOR16ri, X86::GR16RegisterClass, Op0, imm1);
01603 }
01604 
01605 unsigned FastEmit_ISD_XOR_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01606   if (RetVT.SimpleTy != MVT::i32)
01607     return 0;
01608   return FastEmitInst_ri(X86::XOR32ri, X86::GR32RegisterClass, Op0, imm1);
01609 }
01610 
01611 unsigned FastEmit_ISD_XOR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01612   switch (VT.SimpleTy) {
01613   case MVT::i8: return FastEmit_ISD_XOR_MVT_i8_ri(RetVT, Op0, imm1);
01614   case MVT::i16: return FastEmit_ISD_XOR_MVT_i16_ri(RetVT, Op0, imm1);
01615   case MVT::i32: return FastEmit_ISD_XOR_MVT_i32_ri(RetVT, Op0, imm1);
01616   default: return 0;
01617   }
01618 }
01619 
01620 // FastEmit functions for X86ISD::ADD.
01621 
01622 unsigned FastEmit_X86ISD_ADD_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01623   if (RetVT.SimpleTy != MVT::i8)
01624     return 0;
01625   return FastEmitInst_ri(X86::ADD8ri, X86::GR8RegisterClass, Op0, imm1);
01626 }
01627 
01628 unsigned FastEmit_X86ISD_ADD_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01629   if (RetVT.SimpleTy != MVT::i16)
01630     return 0;
01631   return FastEmitInst_ri(X86::ADD16ri, X86::GR16RegisterClass, Op0, imm1);
01632 }
01633 
01634 unsigned FastEmit_X86ISD_ADD_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01635   if (RetVT.SimpleTy != MVT::i32)
01636     return 0;
01637   return FastEmitInst_ri(X86::ADD32ri, X86::GR32RegisterClass, Op0, imm1);
01638 }
01639 
01640 unsigned FastEmit_X86ISD_ADD_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01641   switch (VT.SimpleTy) {
01642   case MVT::i8: return FastEmit_X86ISD_ADD_MVT_i8_ri(RetVT, Op0, imm1);
01643   case MVT::i16: return FastEmit_X86ISD_ADD_MVT_i16_ri(RetVT, Op0, imm1);
01644   case MVT::i32: return FastEmit_X86ISD_ADD_MVT_i32_ri(RetVT, Op0, imm1);
01645   default: return 0;
01646   }
01647 }
01648 
01649 // FastEmit functions for X86ISD::CMP.
01650 
01651 unsigned FastEmit_X86ISD_CMP_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01652   if (RetVT.SimpleTy != MVT::isVoid)
01653     return 0;
01654   return FastEmitInst_ri(X86::CMP8ri, X86::GR8RegisterClass, Op0, imm1);
01655 }
01656 
01657 unsigned FastEmit_X86ISD_CMP_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01658   if (RetVT.SimpleTy != MVT::isVoid)
01659     return 0;
01660   return FastEmitInst_ri(X86::CMP16ri, X86::GR16RegisterClass, Op0, imm1);
01661 }
01662 
01663 unsigned FastEmit_X86ISD_CMP_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01664   if (RetVT.SimpleTy != MVT::isVoid)
01665     return 0;
01666   return FastEmitInst_ri(X86::CMP32ri, X86::GR32RegisterClass, Op0, imm1);
01667 }
01668 
01669 unsigned FastEmit_X86ISD_CMP_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01670   switch (VT.SimpleTy) {
01671   case MVT::i8: return FastEmit_X86ISD_CMP_MVT_i8_ri(RetVT, Op0, imm1);
01672   case MVT::i16: return FastEmit_X86ISD_CMP_MVT_i16_ri(RetVT, Op0, imm1);
01673   case MVT::i32: return FastEmit_X86ISD_CMP_MVT_i32_ri(RetVT, Op0, imm1);
01674   default: return 0;
01675   }
01676 }
01677 
01678 // FastEmit functions for X86ISD::SMUL.
01679 
01680 unsigned FastEmit_X86ISD_SMUL_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01681   if (RetVT.SimpleTy != MVT::i16)
01682     return 0;
01683   return FastEmitInst_ri(X86::IMUL16rri, X86::GR16RegisterClass, Op0, imm1);
01684 }
01685 
01686 unsigned FastEmit_X86ISD_SMUL_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01687   if (RetVT.SimpleTy != MVT::i32)
01688     return 0;
01689   return FastEmitInst_ri(X86::IMUL32rri, X86::GR32RegisterClass, Op0, imm1);
01690 }
01691 
01692 unsigned FastEmit_X86ISD_SMUL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01693   switch (VT.SimpleTy) {
01694   case MVT::i16: return FastEmit_X86ISD_SMUL_MVT_i16_ri(RetVT, Op0, imm1);
01695   case MVT::i32: return FastEmit_X86ISD_SMUL_MVT_i32_ri(RetVT, Op0, imm1);
01696   default: return 0;
01697   }
01698 }
01699 
01700 // FastEmit functions for X86ISD::SUB.
01701 
01702 unsigned FastEmit_X86ISD_SUB_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01703   if (RetVT.SimpleTy != MVT::i8)
01704     return 0;
01705   return FastEmitInst_ri(X86::SUB8ri, X86::GR8RegisterClass, Op0, imm1);
01706 }
01707 
01708 unsigned FastEmit_X86ISD_SUB_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01709   if (RetVT.SimpleTy != MVT::i16)
01710     return 0;
01711   return FastEmitInst_ri(X86::SUB16ri, X86::GR16RegisterClass, Op0, imm1);
01712 }
01713 
01714 unsigned FastEmit_X86ISD_SUB_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01715   if (RetVT.SimpleTy != MVT::i32)
01716     return 0;
01717   return FastEmitInst_ri(X86::SUB32ri, X86::GR32RegisterClass, Op0, imm1);
01718 }
01719 
01720 unsigned FastEmit_X86ISD_SUB_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01721   switch (VT.SimpleTy) {
01722   case MVT::i8: return FastEmit_X86ISD_SUB_MVT_i8_ri(RetVT, Op0, imm1);
01723   case MVT::i16: return FastEmit_X86ISD_SUB_MVT_i16_ri(RetVT, Op0, imm1);
01724   case MVT::i32: return FastEmit_X86ISD_SUB_MVT_i32_ri(RetVT, Op0, imm1);
01725   default: return 0;
01726   }
01727 }
01728 
01729 // FastEmit functions for X86ISD::TC_RETURN.
01730 
01731 unsigned FastEmit_X86ISD_TC_RETURN_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
01732   if (RetVT.SimpleTy != MVT::isVoid)
01733     return 0;
01734   return FastEmitInst_ri(X86::TCRETURNri, X86::GR32RegisterClass, Op0, imm1);
01735 }
01736 
01737 unsigned FastEmit_X86ISD_TC_RETURN_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
01738   switch (VT.SimpleTy) {
01739   case MVT::i32: return FastEmit_X86ISD_TC_RETURN_MVT_i32_ri(RetVT, Op0, imm1);
01740   default: return 0;
01741   }
01742 }
01743 
01744 // Top-level FastEmit function.
01745 
01746 unsigned FastEmit_ri(MVT VT, MVT RetVT, ISD::NodeType Opcode, unsigned Op0, uint64_t imm1) {
01747   switch (Opcode) {
01748   case ISD::ADD: return FastEmit_ISD_ADD_ri(VT, RetVT, Op0, imm1);
01749   case ISD::ADDC: return FastEmit_ISD_ADDC_ri(VT, RetVT, Op0, imm1);
01750   case ISD::ADDE: return FastEmit_ISD_ADDE_ri(VT, RetVT, Op0, imm1);
01751   case ISD::AND: return FastEmit_ISD_AND_ri(VT, RetVT, Op0, imm1);
01752   case ISD::MUL: return FastEmit_ISD_MUL_ri(VT, RetVT, Op0, imm1);
01753   case ISD::OR: return FastEmit_ISD_OR_ri(VT, RetVT, Op0, imm1);
01754   case ISD::ROTL: return FastEmit_ISD_ROTL_ri(VT, RetVT, Op0, imm1);
01755   case ISD::ROTR: return FastEmit_ISD_ROTR_ri(VT, RetVT, Op0, imm1);
01756   case ISD::SHL: return FastEmit_ISD_SHL_ri(VT, RetVT, Op0, imm1);
01757   case ISD::SRA: return FastEmit_ISD_SRA_ri(VT, RetVT, Op0, imm1);
01758   case ISD::SRL: return FastEmit_ISD_SRL_ri(VT, RetVT, Op0, imm1);
01759   case ISD::SUB: return FastEmit_ISD_SUB_ri(VT, RetVT, Op0, imm1);
01760   case ISD::SUBC: return FastEmit_ISD_SUBC_ri(VT, RetVT, Op0, imm1);
01761   case ISD::SUBE: return FastEmit_ISD_SUBE_ri(VT, RetVT, Op0, imm1);
01762   case ISD::XOR: return FastEmit_ISD_XOR_ri(VT, RetVT, Op0, imm1);
01763   case X86ISD::ADD: return FastEmit_X86ISD_ADD_ri(VT, RetVT, Op0, imm1);
01764   case X86ISD::CMP: return FastEmit_X86ISD_CMP_ri(VT, RetVT, Op0, imm1);
01765   case X86ISD::SMUL: return FastEmit_X86ISD_SMUL_ri(VT, RetVT, Op0, imm1);
01766   case X86ISD::SUB: return FastEmit_X86ISD_SUB_ri(VT, RetVT, Op0, imm1);
01767   case X86ISD::TC_RETURN: return FastEmit_X86ISD_TC_RETURN_ri(VT, RetVT, Op0, imm1);
01768   default: return 0;
01769   }
01770 }
01771 
01772 // FastEmit functions for ISD::ADD.
01773 
01774 unsigned FastEmit_ISD_ADD_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01775   if (RetVT.SimpleTy != MVT::i8)
01776     return 0;
01777   return FastEmitInst_rr(X86::ADD8rr, X86::GR8RegisterClass, Op0, Op1);
01778 }
01779 
01780 unsigned FastEmit_ISD_ADD_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01781   if (RetVT.SimpleTy != MVT::i16)
01782     return 0;
01783   return FastEmitInst_rr(X86::ADD16rr, X86::GR16RegisterClass, Op0, Op1);
01784 }
01785 
01786 unsigned FastEmit_ISD_ADD_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01787   if (RetVT.SimpleTy != MVT::i32)
01788     return 0;
01789   return FastEmitInst_rr(X86::ADD32rr, X86::GR32RegisterClass, Op0, Op1);
01790 }
01791 
01792 unsigned FastEmit_ISD_ADD_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01793   if (RetVT.SimpleTy != MVT::i64)
01794     return 0;
01795   return FastEmitInst_rr(X86::ADD64rr, X86::GR64RegisterClass, Op0, Op1);
01796 }
01797 
01798 unsigned FastEmit_ISD_ADD_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01799   if (RetVT.SimpleTy != MVT::v8i8)
01800     return 0;
01801   if ((Subtarget->hasMMX())) {
01802     return FastEmitInst_rr(X86::MMX_PADDBrr, X86::VR64RegisterClass, Op0, Op1);
01803   }
01804   return 0;
01805 }
01806 
01807 unsigned FastEmit_ISD_ADD_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01808   if (RetVT.SimpleTy != MVT::v16i8)
01809     return 0;
01810   if ((Subtarget->hasSSE2())) {
01811     return FastEmitInst_rr(X86::PADDBrr, X86::VR128RegisterClass, Op0, Op1);
01812   }
01813   return 0;
01814 }
01815 
01816 unsigned FastEmit_ISD_ADD_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01817   if (RetVT.SimpleTy != MVT::v4i16)
01818     return 0;
01819   if ((Subtarget->hasMMX())) {
01820     return FastEmitInst_rr(X86::MMX_PADDWrr, X86::VR64RegisterClass, Op0, Op1);
01821   }
01822   return 0;
01823 }
01824 
01825 unsigned FastEmit_ISD_ADD_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01826   if (RetVT.SimpleTy != MVT::v8i16)
01827     return 0;
01828   if ((Subtarget->hasSSE2())) {
01829     return FastEmitInst_rr(X86::PADDWrr, X86::VR128RegisterClass, Op0, Op1);
01830   }
01831   return 0;
01832 }
01833 
01834 unsigned FastEmit_ISD_ADD_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01835   if (RetVT.SimpleTy != MVT::v2i32)
01836     return 0;
01837   if ((Subtarget->hasMMX())) {
01838     return FastEmitInst_rr(X86::MMX_PADDDrr, X86::VR64RegisterClass, Op0, Op1);
01839   }
01840   return 0;
01841 }
01842 
01843 unsigned FastEmit_ISD_ADD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01844   if (RetVT.SimpleTy != MVT::v4i32)
01845     return 0;
01846   if ((Subtarget->hasSSE2())) {
01847     return FastEmitInst_rr(X86::PADDDrr, X86::VR128RegisterClass, Op0, Op1);
01848   }
01849   return 0;
01850 }
01851 
01852 unsigned FastEmit_ISD_ADD_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01853   if (RetVT.SimpleTy != MVT::v1i64)
01854     return 0;
01855   if ((Subtarget->hasMMX())) {
01856     return FastEmitInst_rr(X86::MMX_PADDQrr, X86::VR64RegisterClass, Op0, Op1);
01857   }
01858   return 0;
01859 }
01860 
01861 unsigned FastEmit_ISD_ADD_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01862   if (RetVT.SimpleTy != MVT::v2i64)
01863     return 0;
01864   if ((Subtarget->hasSSE2())) {
01865     return FastEmitInst_rr(X86::PADDQrr, X86::VR128RegisterClass, Op0, Op1);
01866   }
01867   return 0;
01868 }
01869 
01870 unsigned FastEmit_ISD_ADD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
01871   switch (VT.SimpleTy) {
01872   case MVT::i8: return FastEmit_ISD_ADD_MVT_i8_rr(RetVT, Op0, Op1);
01873   case MVT::i16: return FastEmit_ISD_ADD_MVT_i16_rr(RetVT, Op0, Op1);
01874   case MVT::i32: return FastEmit_ISD_ADD_MVT_i32_rr(RetVT, Op0, Op1);
01875   case MVT::i64: return FastEmit_ISD_ADD_MVT_i64_rr(RetVT, Op0, Op1);
01876   case MVT::v8i8: return FastEmit_ISD_ADD_MVT_v8i8_rr(RetVT, Op0, Op1);
01877   case MVT::v16i8: return FastEmit_ISD_ADD_MVT_v16i8_rr(RetVT, Op0, Op1);
01878   case MVT::v4i16: return FastEmit_ISD_ADD_MVT_v4i16_rr(RetVT, Op0, Op1);
01879   case MVT::v8i16: return FastEmit_ISD_ADD_MVT_v8i16_rr(RetVT, Op0, Op1);
01880   case MVT::v2i32: return FastEmit_ISD_ADD_MVT_v2i32_rr(RetVT, Op0, Op1);
01881   case MVT::v4i32: return FastEmit_ISD_ADD_MVT_v4i32_rr(RetVT, Op0, Op1);
01882   case MVT::v1i64: return FastEmit_ISD_ADD_MVT_v1i64_rr(RetVT, Op0, Op1);
01883   case MVT::v2i64: return FastEmit_ISD_ADD_MVT_v2i64_rr(RetVT, Op0, Op1);
01884   default: return 0;
01885   }
01886 }
01887 
01888 // FastEmit functions for ISD::ADDC.
01889 
01890 unsigned FastEmit_ISD_ADDC_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01891   if (RetVT.SimpleTy != MVT::i32)
01892     return 0;
01893   return FastEmitInst_rr(X86::ADD32rr, X86::GR32RegisterClass, Op0, Op1);
01894 }
01895 
01896 unsigned FastEmit_ISD_ADDC_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01897   if (RetVT.SimpleTy != MVT::i64)
01898     return 0;
01899   return FastEmitInst_rr(X86::ADD64rr, X86::GR64RegisterClass, Op0, Op1);
01900 }
01901 
01902 unsigned FastEmit_ISD_ADDC_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
01903   switch (VT.SimpleTy) {
01904   case MVT::i32: return FastEmit_ISD_ADDC_MVT_i32_rr(RetVT, Op0, Op1);
01905   case MVT::i64: return FastEmit_ISD_ADDC_MVT_i64_rr(RetVT, Op0, Op1);
01906   default: return 0;
01907   }
01908 }
01909 
01910 // FastEmit functions for ISD::ADDE.
01911 
01912 unsigned FastEmit_ISD_ADDE_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01913   if (RetVT.SimpleTy != MVT::i8)
01914     return 0;
01915   return FastEmitInst_rr(X86::ADC8rr, X86::GR8RegisterClass, Op0, Op1);
01916 }
01917 
01918 unsigned FastEmit_ISD_ADDE_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01919   if (RetVT.SimpleTy != MVT::i16)
01920     return 0;
01921   return FastEmitInst_rr(X86::ADC16rr, X86::GR16RegisterClass, Op0, Op1);
01922 }
01923 
01924 unsigned FastEmit_ISD_ADDE_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01925   if (RetVT.SimpleTy != MVT::i32)
01926     return 0;
01927   return FastEmitInst_rr(X86::ADC32rr, X86::GR32RegisterClass, Op0, Op1);
01928 }
01929 
01930 unsigned FastEmit_ISD_ADDE_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01931   if (RetVT.SimpleTy != MVT::i64)
01932     return 0;
01933   return FastEmitInst_rr(X86::ADC64rr, X86::GR64RegisterClass, Op0, Op1);
01934 }
01935 
01936 unsigned FastEmit_ISD_ADDE_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
01937   switch (VT.SimpleTy) {
01938   case MVT::i8: return FastEmit_ISD_ADDE_MVT_i8_rr(RetVT, Op0, Op1);
01939   case MVT::i16: return FastEmit_ISD_ADDE_MVT_i16_rr(RetVT, Op0, Op1);
01940   case MVT::i32: return FastEmit_ISD_ADDE_MVT_i32_rr(RetVT, Op0, Op1);
01941   case MVT::i64: return FastEmit_ISD_ADDE_MVT_i64_rr(RetVT, Op0, Op1);
01942   default: return 0;
01943   }
01944 }
01945 
01946 // FastEmit functions for ISD::AND.
01947 
01948 unsigned FastEmit_ISD_AND_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01949   if (RetVT.SimpleTy != MVT::i8)
01950     return 0;
01951   return FastEmitInst_rr(X86::AND8rr, X86::GR8RegisterClass, Op0, Op1);
01952 }
01953 
01954 unsigned FastEmit_ISD_AND_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01955   if (RetVT.SimpleTy != MVT::i16)
01956     return 0;
01957   return FastEmitInst_rr(X86::AND16rr, X86::GR16RegisterClass, Op0, Op1);
01958 }
01959 
01960 unsigned FastEmit_ISD_AND_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01961   if (RetVT.SimpleTy != MVT::i32)
01962     return 0;
01963   return FastEmitInst_rr(X86::AND32rr, X86::GR32RegisterClass, Op0, Op1);
01964 }
01965 
01966 unsigned FastEmit_ISD_AND_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01967   if (RetVT.SimpleTy != MVT::i64)
01968     return 0;
01969   return FastEmitInst_rr(X86::AND64rr, X86::GR64RegisterClass, Op0, Op1);
01970 }
01971 
01972 unsigned FastEmit_ISD_AND_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01973   if (RetVT.SimpleTy != MVT::v1i64)
01974     return 0;
01975   if ((Subtarget->hasMMX())) {
01976     return FastEmitInst_rr(X86::MMX_PANDrr, X86::VR64RegisterClass, Op0, Op1);
01977   }
01978   return 0;
01979 }
01980 
01981 unsigned FastEmit_ISD_AND_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
01982   if (RetVT.SimpleTy != MVT::v2i64)
01983     return 0;
01984   if ((Subtarget->hasSSE1())) {
01985     return FastEmitInst_rr(X86::ANDPSrr, X86::VR128RegisterClass, Op0, Op1);
01986   }
01987   if ((Subtarget->hasSSE2())) {
01988     return FastEmitInst_rr(X86::PANDrr, X86::VR128RegisterClass, Op0, Op1);
01989   }
01990   return 0;
01991 }
01992 
01993 unsigned FastEmit_ISD_AND_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
01994   switch (VT.SimpleTy) {
01995   case MVT::i8: return FastEmit_ISD_AND_MVT_i8_rr(RetVT, Op0, Op1);
01996   case MVT::i16: return FastEmit_ISD_AND_MVT_i16_rr(RetVT, Op0, Op1);
01997   case MVT::i32: return FastEmit_ISD_AND_MVT_i32_rr(RetVT, Op0, Op1);
01998   case MVT::i64: return FastEmit_ISD_AND_MVT_i64_rr(RetVT, Op0, Op1);
01999   case MVT::v1i64: return FastEmit_ISD_AND_MVT_v1i64_rr(RetVT, Op0, Op1);
02000   case MVT::v2i64: return FastEmit_ISD_AND_MVT_v2i64_rr(RetVT, Op0, Op1);
02001   default: return 0;
02002   }
02003 }
02004 
02005 // FastEmit functions for ISD::FADD.
02006 
02007 unsigned FastEmit_ISD_FADD_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02008   if (RetVT.SimpleTy != MVT::f32)
02009     return 0;
02010   if ((!Subtarget->hasSSE1())) {
02011     return FastEmitInst_rr(X86::ADD_Fp32, X86::RFP32RegisterClass, Op0, Op1);
02012   }
02013   if ((Subtarget->hasSSE1())) {
02014     return FastEmitInst_rr(X86::ADDSSrr, X86::FR32RegisterClass, Op0, Op1);
02015   }
02016   return 0;
02017 }
02018 
02019 unsigned FastEmit_ISD_FADD_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02020   if (RetVT.SimpleTy != MVT::f64)
02021     return 0;
02022   if ((!Subtarget->hasSSE2())) {
02023     return FastEmitInst_rr(X86::ADD_Fp64, X86::RFP64RegisterClass, Op0, Op1);
02024   }
02025   if ((Subtarget->hasSSE2())) {
02026     return FastEmitInst_rr(X86::ADDSDrr, X86::FR64RegisterClass, Op0, Op1);
02027   }
02028   return 0;
02029 }
02030 
02031 unsigned FastEmit_ISD_FADD_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02032   if (RetVT.SimpleTy != MVT::f80)
02033     return 0;
02034   return FastEmitInst_rr(X86::ADD_Fp80, X86::RFP80RegisterClass, Op0, Op1);
02035 }
02036 
02037 unsigned FastEmit_ISD_FADD_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02038   if (RetVT.SimpleTy != MVT::v4f32)
02039     return 0;
02040   if ((Subtarget->hasSSE1())) {
02041     return FastEmitInst_rr(X86::ADDPSrr, X86::VR128RegisterClass, Op0, Op1);
02042   }
02043   return 0;
02044 }
02045 
02046 unsigned FastEmit_ISD_FADD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02047   if (RetVT.SimpleTy != MVT::v2f64)
02048     return 0;
02049   if ((Subtarget->hasSSE2())) {
02050     return FastEmitInst_rr(X86::ADDPDrr, X86::VR128RegisterClass, Op0, Op1);
02051   }
02052   return 0;
02053 }
02054 
02055 unsigned FastEmit_ISD_FADD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02056   switch (VT.SimpleTy) {
02057   case MVT::f32: return FastEmit_ISD_FADD_MVT_f32_rr(RetVT, Op0, Op1);
02058   case MVT::f64: return FastEmit_ISD_FADD_MVT_f64_rr(RetVT, Op0, Op1);
02059   case MVT::f80: return FastEmit_ISD_FADD_MVT_f80_rr(RetVT, Op0, Op1);
02060   case MVT::v4f32: return FastEmit_ISD_FADD_MVT_v4f32_rr(RetVT, Op0, Op1);
02061   case MVT::v2f64: return FastEmit_ISD_FADD_MVT_v2f64_rr(RetVT, Op0, Op1);
02062   default: return 0;
02063   }
02064 }
02065 
02066 // FastEmit functions for ISD::FDIV.
02067 
02068 unsigned FastEmit_ISD_FDIV_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02069   if (RetVT.SimpleTy != MVT::f32)
02070     return 0;
02071   if ((!Subtarget->hasSSE1())) {
02072     return FastEmitInst_rr(X86::DIV_Fp32, X86::RFP32RegisterClass, Op0, Op1);
02073   }
02074   if ((Subtarget->hasSSE1())) {
02075     return FastEmitInst_rr(X86::DIVSSrr, X86::FR32RegisterClass, Op0, Op1);
02076   }
02077   return 0;
02078 }
02079 
02080 unsigned FastEmit_ISD_FDIV_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02081   if (RetVT.SimpleTy != MVT::f64)
02082     return 0;
02083   if ((!Subtarget->hasSSE2())) {
02084     return FastEmitInst_rr(X86::DIV_Fp64, X86::RFP64RegisterClass, Op0, Op1);
02085   }
02086   if ((Subtarget->hasSSE2())) {
02087     return FastEmitInst_rr(X86::DIVSDrr, X86::FR64RegisterClass, Op0, Op1);
02088   }
02089   return 0;
02090 }
02091 
02092 unsigned FastEmit_ISD_FDIV_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02093   if (RetVT.SimpleTy != MVT::f80)
02094     return 0;
02095   return FastEmitInst_rr(X86::DIV_Fp80, X86::RFP80RegisterClass, Op0, Op1);
02096 }
02097 
02098 unsigned FastEmit_ISD_FDIV_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02099   if (RetVT.SimpleTy != MVT::v4f32)
02100     return 0;
02101   if ((Subtarget->hasSSE1())) {
02102     return FastEmitInst_rr(X86::DIVPSrr, X86::VR128RegisterClass, Op0, Op1);
02103   }
02104   return 0;
02105 }
02106 
02107 unsigned FastEmit_ISD_FDIV_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02108   if (RetVT.SimpleTy != MVT::v2f64)
02109     return 0;
02110   if ((Subtarget->hasSSE2())) {
02111     return FastEmitInst_rr(X86::DIVPDrr, X86::VR128RegisterClass, Op0, Op1);
02112   }
02113   return 0;
02114 }
02115 
02116 unsigned FastEmit_ISD_FDIV_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02117   switch (VT.SimpleTy) {
02118   case MVT::f32: return FastEmit_ISD_FDIV_MVT_f32_rr(RetVT, Op0, Op1);
02119   case MVT::f64: return FastEmit_ISD_FDIV_MVT_f64_rr(RetVT, Op0, Op1);
02120   case MVT::f80: return FastEmit_ISD_FDIV_MVT_f80_rr(RetVT, Op0, Op1);
02121   case MVT::v4f32: return FastEmit_ISD_FDIV_MVT_v4f32_rr(RetVT, Op0, Op1);
02122   case MVT::v2f64: return FastEmit_ISD_FDIV_MVT_v2f64_rr(RetVT, Op0, Op1);
02123   default: return 0;
02124   }
02125 }
02126 
02127 // FastEmit functions for ISD::FMUL.
02128 
02129 unsigned FastEmit_ISD_FMUL_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02130   if (RetVT.SimpleTy != MVT::f32)
02131     return 0;
02132   if ((!Subtarget->hasSSE1())) {
02133     return FastEmitInst_rr(X86::MUL_Fp32, X86::RFP32RegisterClass, Op0, Op1);
02134   }
02135   if ((Subtarget->hasSSE1())) {
02136     return FastEmitInst_rr(X86::MULSSrr, X86::FR32RegisterClass, Op0, Op1);
02137   }
02138   return 0;
02139 }
02140 
02141 unsigned FastEmit_ISD_FMUL_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02142   if (RetVT.SimpleTy != MVT::f64)
02143     return 0;
02144   if ((!Subtarget->hasSSE2())) {
02145     return FastEmitInst_rr(X86::MUL_Fp64, X86::RFP64RegisterClass, Op0, Op1);
02146   }
02147   if ((Subtarget->hasSSE2())) {
02148     return FastEmitInst_rr(X86::MULSDrr, X86::FR64RegisterClass, Op0, Op1);
02149   }
02150   return 0;
02151 }
02152 
02153 unsigned FastEmit_ISD_FMUL_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02154   if (RetVT.SimpleTy != MVT::f80)
02155     return 0;
02156   return FastEmitInst_rr(X86::MUL_Fp80, X86::RFP80RegisterClass, Op0, Op1);
02157 }
02158 
02159 unsigned FastEmit_ISD_FMUL_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02160   if (RetVT.SimpleTy != MVT::v4f32)
02161     return 0;
02162   if ((Subtarget->hasSSE1())) {
02163     return FastEmitInst_rr(X86::MULPSrr, X86::VR128RegisterClass, Op0, Op1);
02164   }
02165   return 0;
02166 }
02167 
02168 unsigned FastEmit_ISD_FMUL_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02169   if (RetVT.SimpleTy != MVT::v2f64)
02170     return 0;
02171   if ((Subtarget->hasSSE2())) {
02172     return FastEmitInst_rr(X86::MULPDrr, X86::VR128RegisterClass, Op0, Op1);
02173   }
02174   return 0;
02175 }
02176 
02177 unsigned FastEmit_ISD_FMUL_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02178   switch (VT.SimpleTy) {
02179   case MVT::f32: return FastEmit_ISD_FMUL_MVT_f32_rr(RetVT, Op0, Op1);
02180   case MVT::f64: return FastEmit_ISD_FMUL_MVT_f64_rr(RetVT, Op0, Op1);
02181   case MVT::f80: return FastEmit_ISD_FMUL_MVT_f80_rr(RetVT, Op0, Op1);
02182   case MVT::v4f32: return FastEmit_ISD_FMUL_MVT_v4f32_rr(RetVT, Op0, Op1);
02183   case MVT::v2f64: return FastEmit_ISD_FMUL_MVT_v2f64_rr(RetVT, Op0, Op1);
02184   default: return 0;
02185   }
02186 }
02187 
02188 // FastEmit functions for ISD::FSUB.
02189 
02190 unsigned FastEmit_ISD_FSUB_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02191   if (RetVT.SimpleTy != MVT::f32)
02192     return 0;
02193   if ((!Subtarget->hasSSE1())) {
02194     return FastEmitInst_rr(X86::SUB_Fp32, X86::RFP32RegisterClass, Op0, Op1);
02195   }
02196   if ((Subtarget->hasSSE1())) {
02197     return FastEmitInst_rr(X86::SUBSSrr, X86::FR32RegisterClass, Op0, Op1);
02198   }
02199   return 0;
02200 }
02201 
02202 unsigned FastEmit_ISD_FSUB_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02203   if (RetVT.SimpleTy != MVT::f64)
02204     return 0;
02205   if ((!Subtarget->hasSSE2())) {
02206     return FastEmitInst_rr(X86::SUB_Fp64, X86::RFP64RegisterClass, Op0, Op1);
02207   }
02208   if ((Subtarget->hasSSE2())) {
02209     return FastEmitInst_rr(X86::SUBSDrr, X86::FR64RegisterClass, Op0, Op1);
02210   }
02211   return 0;
02212 }
02213 
02214 unsigned FastEmit_ISD_FSUB_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02215   if (RetVT.SimpleTy != MVT::f80)
02216     return 0;
02217   return FastEmitInst_rr(X86::SUB_Fp80, X86::RFP80RegisterClass, Op0, Op1);
02218 }
02219 
02220 unsigned FastEmit_ISD_FSUB_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02221   if (RetVT.SimpleTy != MVT::v4f32)
02222     return 0;
02223   if ((Subtarget->hasSSE1())) {
02224     return FastEmitInst_rr(X86::SUBPSrr, X86::VR128RegisterClass, Op0, Op1);
02225   }
02226   return 0;
02227 }
02228 
02229 unsigned FastEmit_ISD_FSUB_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02230   if (RetVT.SimpleTy != MVT::v2f64)
02231     return 0;
02232   if ((Subtarget->hasSSE2())) {
02233     return FastEmitInst_rr(X86::SUBPDrr, X86::VR128RegisterClass, Op0, Op1);
02234   }
02235   return 0;
02236 }
02237 
02238 unsigned FastEmit_ISD_FSUB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02239   switch (VT.SimpleTy) {
02240   case MVT::f32: return FastEmit_ISD_FSUB_MVT_f32_rr(RetVT, Op0, Op1);
02241   case MVT::f64: return FastEmit_ISD_FSUB_MVT_f64_rr(RetVT, Op0, Op1);
02242   case MVT::f80: return FastEmit_ISD_FSUB_MVT_f80_rr(RetVT, Op0, Op1);
02243   case MVT::v4f32: return FastEmit_ISD_FSUB_MVT_v4f32_rr(RetVT, Op0, Op1);
02244   case MVT::v2f64: return FastEmit_ISD_FSUB_MVT_v2f64_rr(RetVT, Op0, Op1);
02245   default: return 0;
02246   }
02247 }
02248 
02249 // FastEmit functions for ISD::MUL.
02250 
02251 unsigned FastEmit_ISD_MUL_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02252   if (RetVT.SimpleTy != MVT::i8)
02253     return 0;
02254   TII.copyRegToReg(*MBB, MBB->end(), X86::AL, Op0, TM.getRegisterInfo()->getPhysicalRegisterRegClass(X86::AL), MRI.getRegClass(Op0));
02255   return FastEmitInst_r(X86::MUL8r, X86::GR8RegisterClass, Op1);
02256 }
02257 
02258 unsigned FastEmit_ISD_MUL_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02259   if (RetVT.SimpleTy != MVT::i16)
02260     return 0;
02261   return FastEmitInst_rr(X86::IMUL16rr, X86::GR16RegisterClass, Op0, Op1);
02262 }
02263 
02264 unsigned FastEmit_ISD_MUL_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02265   if (RetVT.SimpleTy != MVT::i32)
02266     return 0;
02267   return FastEmitInst_rr(X86::IMUL32rr, X86::GR32RegisterClass, Op0, Op1);
02268 }
02269 
02270 unsigned FastEmit_ISD_MUL_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02271   if (RetVT.SimpleTy != MVT::i64)
02272     return 0;
02273   return FastEmitInst_rr(X86::IMUL64rr, X86::GR64RegisterClass, Op0, Op1);
02274 }
02275 
02276 unsigned FastEmit_ISD_MUL_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02277   if (RetVT.SimpleTy != MVT::v4i16)
02278     return 0;
02279   if ((Subtarget->hasMMX())) {
02280     return FastEmitInst_rr(X86::MMX_PMULLWrr, X86::VR64RegisterClass, Op0, Op1);
02281   }
02282   return 0;
02283 }
02284 
02285 unsigned FastEmit_ISD_MUL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02286   if (RetVT.SimpleTy != MVT::v8i16)
02287     return 0;
02288   if ((Subtarget->hasSSE2())) {
02289     return FastEmitInst_rr(X86::PMULLWrr, X86::VR128RegisterClass, Op0, Op1);
02290   }
02291   return 0;
02292 }
02293 
02294 unsigned FastEmit_ISD_MUL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02295   if (RetVT.SimpleTy != MVT::v4i32)
02296     return 0;
02297   if ((Subtarget->hasSSE41())) {
02298     return FastEmitInst_rr(X86::PMULLDrr, X86::VR128RegisterClass, Op0, Op1);
02299   }
02300   return 0;
02301 }
02302 
02303 unsigned FastEmit_ISD_MUL_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02304   switch (VT.SimpleTy) {
02305   case MVT::i8: return FastEmit_ISD_MUL_MVT_i8_rr(RetVT, Op0, Op1);
02306   case MVT::i16: return FastEmit_ISD_MUL_MVT_i16_rr(RetVT, Op0, Op1);
02307   case MVT::i32: return FastEmit_ISD_MUL_MVT_i32_rr(RetVT, Op0, Op1);
02308   case MVT::i64: return FastEmit_ISD_MUL_MVT_i64_rr(RetVT, Op0, Op1);
02309   case MVT::v4i16: return FastEmit_ISD_MUL_MVT_v4i16_rr(RetVT, Op0, Op1);
02310   case MVT::v8i16: return FastEmit_ISD_MUL_MVT_v8i16_rr(RetVT, Op0, Op1);
02311   case MVT::v4i32: return FastEmit_ISD_MUL_MVT_v4i32_rr(RetVT, Op0, Op1);
02312   default: return 0;
02313   }
02314 }
02315 
02316 // FastEmit functions for ISD::OR.
02317 
02318 unsigned FastEmit_ISD_OR_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02319   if (RetVT.SimpleTy != MVT::i8)
02320     return 0;
02321   return FastEmitInst_rr(X86::OR8rr, X86::GR8RegisterClass, Op0, Op1);
02322 }
02323 
02324 unsigned FastEmit_ISD_OR_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02325   if (RetVT.SimpleTy != MVT::i16)
02326     return 0;
02327   return FastEmitInst_rr(X86::OR16rr, X86::GR16RegisterClass, Op0, Op1);
02328 }
02329 
02330 unsigned FastEmit_ISD_OR_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02331   if (RetVT.SimpleTy != MVT::i32)
02332     return 0;
02333   return FastEmitInst_rr(X86::OR32rr, X86::GR32RegisterClass, Op0, Op1);
02334 }
02335 
02336 unsigned FastEmit_ISD_OR_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02337   if (RetVT.SimpleTy != MVT::i64)
02338     return 0;
02339   return FastEmitInst_rr(X86::OR64rr, X86::GR64RegisterClass, Op0, Op1);
02340 }
02341 
02342 unsigned FastEmit_ISD_OR_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02343   if (RetVT.SimpleTy != MVT::v1i64)
02344     return 0;
02345   if ((Subtarget->hasMMX())) {
02346     return FastEmitInst_rr(X86::MMX_PORrr, X86::VR64RegisterClass, Op0, Op1);
02347   }
02348   return 0;
02349 }
02350 
02351 unsigned FastEmit_ISD_OR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02352   if (RetVT.SimpleTy != MVT::v2i64)
02353     return 0;
02354   if ((Subtarget->hasSSE1())) {
02355     return FastEmitInst_rr(X86::ORPSrr, X86::VR128RegisterClass, Op0, Op1);
02356   }
02357   if ((Subtarget->hasSSE2())) {
02358     return FastEmitInst_rr(X86::PORrr, X86::VR128RegisterClass, Op0, Op1);
02359   }
02360   return 0;
02361 }
02362 
02363 unsigned FastEmit_ISD_OR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02364   switch (VT.SimpleTy) {
02365   case MVT::i8: return FastEmit_ISD_OR_MVT_i8_rr(RetVT, Op0, Op1);
02366   case MVT::i16: return FastEmit_ISD_OR_MVT_i16_rr(RetVT, Op0, Op1);
02367   case MVT::i32: return FastEmit_ISD_OR_MVT_i32_rr(RetVT, Op0, Op1);
02368   case MVT::i64: return FastEmit_ISD_OR_MVT_i64_rr(RetVT, Op0, Op1);
02369   case MVT::v1i64: return FastEmit_ISD_OR_MVT_v1i64_rr(RetVT, Op0, Op1);
02370   case MVT::v2i64: return FastEmit_ISD_OR_MVT_v2i64_rr(RetVT, Op0, Op1);
02371   default: return 0;
02372   }
02373 }
02374 
02375 // FastEmit functions for ISD::SUB.
02376 
02377 unsigned FastEmit_ISD_SUB_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02378   if (RetVT.SimpleTy != MVT::i8)
02379     return 0;
02380   return FastEmitInst_rr(X86::SUB8rr, X86::GR8RegisterClass, Op0, Op1);
02381 }
02382 
02383 unsigned FastEmit_ISD_SUB_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02384   if (RetVT.SimpleTy != MVT::i16)
02385     return 0;
02386   return FastEmitInst_rr(X86::SUB16rr, X86::GR16RegisterClass, Op0, Op1);
02387 }
02388 
02389 unsigned FastEmit_ISD_SUB_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02390   if (RetVT.SimpleTy != MVT::i32)
02391     return 0;
02392   return FastEmitInst_rr(X86::SUB32rr, X86::GR32RegisterClass, Op0, Op1);
02393 }
02394 
02395 unsigned FastEmit_ISD_SUB_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02396   if (RetVT.SimpleTy != MVT::i64)
02397     return 0;
02398   return FastEmitInst_rr(X86::SUB64rr, X86::GR64RegisterClass, Op0, Op1);
02399 }
02400 
02401 unsigned FastEmit_ISD_SUB_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02402   if (RetVT.SimpleTy != MVT::v8i8)
02403     return 0;
02404   if ((Subtarget->hasMMX())) {
02405     return FastEmitInst_rr(X86::MMX_PSUBBrr, X86::VR64RegisterClass, Op0, Op1);
02406   }
02407   return 0;
02408 }
02409 
02410 unsigned FastEmit_ISD_SUB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02411   if (RetVT.SimpleTy != MVT::v16i8)
02412     return 0;
02413   if ((Subtarget->hasSSE2())) {
02414     return FastEmitInst_rr(X86::PSUBBrr, X86::VR128RegisterClass, Op0, Op1);
02415   }
02416   return 0;
02417 }
02418 
02419 unsigned FastEmit_ISD_SUB_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02420   if (RetVT.SimpleTy != MVT::v4i16)
02421     return 0;
02422   if ((Subtarget->hasMMX())) {
02423     return FastEmitInst_rr(X86::MMX_PSUBWrr, X86::VR64RegisterClass, Op0, Op1);
02424   }
02425   return 0;
02426 }
02427 
02428 unsigned FastEmit_ISD_SUB_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02429   if (RetVT.SimpleTy != MVT::v8i16)
02430     return 0;
02431   if ((Subtarget->hasSSE2())) {
02432     return FastEmitInst_rr(X86::PSUBWrr, X86::VR128RegisterClass, Op0, Op1);
02433   }
02434   return 0;
02435 }
02436 
02437 unsigned FastEmit_ISD_SUB_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02438   if (RetVT.SimpleTy != MVT::v2i32)
02439     return 0;
02440   if ((Subtarget->hasMMX())) {
02441     return FastEmitInst_rr(X86::MMX_PSUBDrr, X86::VR64RegisterClass, Op0, Op1);
02442   }
02443   return 0;
02444 }
02445 
02446 unsigned FastEmit_ISD_SUB_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02447   if (RetVT.SimpleTy != MVT::v4i32)
02448     return 0;
02449   if ((Subtarget->hasSSE2())) {
02450     return FastEmitInst_rr(X86::PSUBDrr, X86::VR128RegisterClass, Op0, Op1);
02451   }
02452   return 0;
02453 }
02454 
02455 unsigned FastEmit_ISD_SUB_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02456   if (RetVT.SimpleTy != MVT::v1i64)
02457     return 0;
02458   if ((Subtarget->hasMMX())) {
02459     return FastEmitInst_rr(X86::MMX_PSUBQrr, X86::VR64RegisterClass, Op0, Op1);
02460   }
02461   return 0;
02462 }
02463 
02464 unsigned FastEmit_ISD_SUB_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02465   if (RetVT.SimpleTy != MVT::v2i64)
02466     return 0;
02467   if ((Subtarget->hasSSE2())) {
02468     return FastEmitInst_rr(X86::PSUBQrr, X86::VR128RegisterClass, Op0, Op1);
02469   }
02470   return 0;
02471 }
02472 
02473 unsigned FastEmit_ISD_SUB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02474   switch (VT.SimpleTy) {
02475   case MVT::i8: return FastEmit_ISD_SUB_MVT_i8_rr(RetVT, Op0, Op1);
02476   case MVT::i16: return FastEmit_ISD_SUB_MVT_i16_rr(RetVT, Op0, Op1);
02477   case MVT::i32: return FastEmit_ISD_SUB_MVT_i32_rr(RetVT, Op0, Op1);
02478   case MVT::i64: return FastEmit_ISD_SUB_MVT_i64_rr(RetVT, Op0, Op1);
02479   case MVT::v8i8: return FastEmit_ISD_SUB_MVT_v8i8_rr(RetVT, Op0, Op1);
02480   case MVT::v16i8: return FastEmit_ISD_SUB_MVT_v16i8_rr(RetVT, Op0, Op1);
02481   case MVT::v4i16: return FastEmit_ISD_SUB_MVT_v4i16_rr(RetVT, Op0, Op1);
02482   case MVT::v8i16: return FastEmit_ISD_SUB_MVT_v8i16_rr(RetVT, Op0, Op1);
02483   case MVT::v2i32: return FastEmit_ISD_SUB_MVT_v2i32_rr(RetVT, Op0, Op1);
02484   case MVT::v4i32: return FastEmit_ISD_SUB_MVT_v4i32_rr(RetVT, Op0, Op1);
02485   case MVT::v1i64: return FastEmit_ISD_SUB_MVT_v1i64_rr(RetVT, Op0, Op1);
02486   case MVT::v2i64: return FastEmit_ISD_SUB_MVT_v2i64_rr(RetVT, Op0, Op1);
02487   default: return 0;
02488   }
02489 }
02490 
02491 // FastEmit functions for ISD::SUBC.
02492 
02493 unsigned FastEmit_ISD_SUBC_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02494   if (RetVT.SimpleTy != MVT::i32)
02495     return 0;
02496   return FastEmitInst_rr(X86::SUB32rr, X86::GR32RegisterClass, Op0, Op1);
02497 }
02498 
02499 unsigned FastEmit_ISD_SUBC_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02500   if (RetVT.SimpleTy != MVT::i64)
02501     return 0;
02502   return FastEmitInst_rr(X86::SUB64rr, X86::GR64RegisterClass, Op0, Op1);
02503 }
02504 
02505 unsigned FastEmit_ISD_SUBC_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02506   switch (VT.SimpleTy) {
02507   case MVT::i32: return FastEmit_ISD_SUBC_MVT_i32_rr(RetVT, Op0, Op1);
02508   case MVT::i64: return FastEmit_ISD_SUBC_MVT_i64_rr(RetVT, Op0, Op1);
02509   default: return 0;
02510   }
02511 }
02512 
02513 // FastEmit functions for ISD::SUBE.
02514 
02515 unsigned FastEmit_ISD_SUBE_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02516   if (RetVT.SimpleTy != MVT::i8)
02517     return 0;
02518   return FastEmitInst_rr(X86::SBB8rr, X86::GR8RegisterClass, Op0, Op1);
02519 }
02520 
02521 unsigned FastEmit_ISD_SUBE_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02522   if (RetVT.SimpleTy != MVT::i16)
02523     return 0;
02524   return FastEmitInst_rr(X86::SBB16rr, X86::GR16RegisterClass, Op0, Op1);
02525 }
02526 
02527 unsigned FastEmit_ISD_SUBE_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02528   if (RetVT.SimpleTy != MVT::i32)
02529     return 0;
02530   return FastEmitInst_rr(X86::SBB32rr, X86::GR32RegisterClass, Op0, Op1);
02531 }
02532 
02533 unsigned FastEmit_ISD_SUBE_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02534   if (RetVT.SimpleTy != MVT::i64)
02535     return 0;
02536   return FastEmitInst_rr(X86::SBB64rr, X86::GR64RegisterClass, Op0, Op1);
02537 }
02538 
02539 unsigned FastEmit_ISD_SUBE_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02540   switch (VT.SimpleTy) {
02541   case MVT::i8: return FastEmit_ISD_SUBE_MVT_i8_rr(RetVT, Op0, Op1);
02542   case MVT::i16: return FastEmit_ISD_SUBE_MVT_i16_rr(RetVT, Op0, Op1);
02543   case MVT::i32: return FastEmit_ISD_SUBE_MVT_i32_rr(RetVT, Op0, Op1);
02544   case MVT::i64: return FastEmit_ISD_SUBE_MVT_i64_rr(RetVT, Op0, Op1);
02545   default: return 0;
02546   }
02547 }
02548 
02549 // FastEmit functions for ISD::XOR.
02550 
02551 unsigned FastEmit_ISD_XOR_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02552   if (RetVT.SimpleTy != MVT::i8)
02553     return 0;
02554   return FastEmitInst_rr(X86::XOR8rr, X86::GR8RegisterClass, Op0, Op1);
02555 }
02556 
02557 unsigned FastEmit_ISD_XOR_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02558   if (RetVT.SimpleTy != MVT::i16)
02559     return 0;
02560   return FastEmitInst_rr(X86::XOR16rr, X86::GR16RegisterClass, Op0, Op1);
02561 }
02562 
02563 unsigned FastEmit_ISD_XOR_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02564   if (RetVT.SimpleTy != MVT::i32)
02565     return 0;
02566   return FastEmitInst_rr(X86::XOR32rr, X86::GR32RegisterClass, Op0, Op1);
02567 }
02568 
02569 unsigned FastEmit_ISD_XOR_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02570   if (RetVT.SimpleTy != MVT::i64)
02571     return 0;
02572   return FastEmitInst_rr(X86::XOR64rr, X86::GR64RegisterClass, Op0, Op1);
02573 }
02574 
02575 unsigned FastEmit_ISD_XOR_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02576   if (RetVT.SimpleTy != MVT::v1i64)
02577     return 0;
02578   if ((Subtarget->hasMMX())) {
02579     return FastEmitInst_rr(X86::MMX_PXORrr, X86::VR64RegisterClass, Op0, Op1);
02580   }
02581   return 0;
02582 }
02583 
02584 unsigned FastEmit_ISD_XOR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02585   if (RetVT.SimpleTy != MVT::v2i64)
02586     return 0;
02587   if ((Subtarget->hasSSE1())) {
02588     return FastEmitInst_rr(X86::XORPSrr, X86::VR128RegisterClass, Op0, Op1);
02589   }
02590   if ((Subtarget->hasSSE2())) {
02591     return FastEmitInst_rr(X86::PXORrr, X86::VR128RegisterClass, Op0, Op1);
02592   }
02593   return 0;
02594 }
02595 
02596 unsigned FastEmit_ISD_XOR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02597   switch (VT.SimpleTy) {
02598   case MVT::i8: return FastEmit_ISD_XOR_MVT_i8_rr(RetVT, Op0, Op1);
02599   case MVT::i16: return FastEmit_ISD_XOR_MVT_i16_rr(RetVT, Op0, Op1);
02600   case MVT::i32: return FastEmit_ISD_XOR_MVT_i32_rr(RetVT, Op0, Op1);
02601   case MVT::i64: return FastEmit_ISD_XOR_MVT_i64_rr(RetVT, Op0, Op1);
02602   case MVT::v1i64: return FastEmit_ISD_XOR_MVT_v1i64_rr(RetVT, Op0, Op1);
02603   case MVT::v2i64: return FastEmit_ISD_XOR_MVT_v2i64_rr(RetVT, Op0, Op1);
02604   default: return 0;
02605   }
02606 }
02607 
02608 // FastEmit functions for X86ISD::ADD.
02609 
02610 unsigned FastEmit_X86ISD_ADD_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02611   if (RetVT.SimpleTy != MVT::i8)
02612     return 0;
02613   return FastEmitInst_rr(X86::ADD8rr, X86::GR8RegisterClass, Op0, Op1);
02614 }
02615 
02616 unsigned FastEmit_X86ISD_ADD_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02617   if (RetVT.SimpleTy != MVT::i16)
02618     return 0;
02619   return FastEmitInst_rr(X86::ADD16rr, X86::GR16RegisterClass, Op0, Op1);
02620 }
02621 
02622 unsigned FastEmit_X86ISD_ADD_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02623   if (RetVT.SimpleTy != MVT::i32)
02624     return 0;
02625   return FastEmitInst_rr(X86::ADD32rr, X86::GR32RegisterClass, Op0, Op1);
02626 }
02627 
02628 unsigned FastEmit_X86ISD_ADD_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02629   if (RetVT.SimpleTy != MVT::i64)
02630     return 0;
02631   return FastEmitInst_rr(X86::ADD64rr, X86::GR64RegisterClass, Op0, Op1);
02632 }
02633 
02634 unsigned FastEmit_X86ISD_ADD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02635   switch (VT.SimpleTy) {
02636   case MVT::i8: return FastEmit_X86ISD_ADD_MVT_i8_rr(RetVT, Op0, Op1);
02637   case MVT::i16: return FastEmit_X86ISD_ADD_MVT_i16_rr(RetVT, Op0, Op1);
02638   case MVT::i32: return FastEmit_X86ISD_ADD_MVT_i32_rr(RetVT, Op0, Op1);
02639   case MVT::i64: return FastEmit_X86ISD_ADD_MVT_i64_rr(RetVT, Op0, Op1);
02640   default: return 0;
02641   }
02642 }
02643 
02644 // FastEmit functions for X86ISD::BT.
02645 
02646 unsigned FastEmit_X86ISD_BT_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02647   if (RetVT.SimpleTy != MVT::isVoid)
02648     return 0;
02649   return FastEmitInst_rr(X86::BT16rr, X86::GR16RegisterClass, Op0, Op1);
02650 }
02651 
02652 unsigned FastEmit_X86ISD_BT_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02653   if (RetVT.SimpleTy != MVT::isVoid)
02654     return 0;
02655   return FastEmitInst_rr(X86::BT32rr, X86::GR32RegisterClass, Op0, Op1);
02656 }
02657 
02658 unsigned FastEmit_X86ISD_BT_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02659   if (RetVT.SimpleTy != MVT::isVoid)
02660     return 0;
02661   return FastEmitInst_rr(X86::BT64rr, X86::GR64RegisterClass, Op0, Op1);
02662 }
02663 
02664 unsigned FastEmit_X86ISD_BT_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02665   switch (VT.SimpleTy) {
02666   case MVT::i16: return FastEmit_X86ISD_BT_MVT_i16_rr(RetVT, Op0, Op1);
02667   case MVT::i32: return FastEmit_X86ISD_BT_MVT_i32_rr(RetVT, Op0, Op1);
02668   case MVT::i64: return FastEmit_X86ISD_BT_MVT_i64_rr(RetVT, Op0, Op1);
02669   default: return 0;
02670   }
02671 }
02672 
02673 // FastEmit functions for X86ISD::CMP.
02674 
02675 unsigned FastEmit_X86ISD_CMP_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02676   if (RetVT.SimpleTy != MVT::isVoid)
02677     return 0;
02678   return FastEmitInst_rr(X86::CMP8rr, X86::GR8RegisterClass, Op0, Op1);
02679 }
02680 
02681 unsigned FastEmit_X86ISD_CMP_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02682   if (RetVT.SimpleTy != MVT::isVoid)
02683     return 0;
02684   return FastEmitInst_rr(X86::CMP16rr, X86::GR16RegisterClass, Op0, Op1);
02685 }
02686 
02687 unsigned FastEmit_X86ISD_CMP_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02688   if (RetVT.SimpleTy != MVT::isVoid)
02689     return 0;
02690   return FastEmitInst_rr(X86::CMP32rr, X86::GR32RegisterClass, Op0, Op1);
02691 }
02692 
02693 unsigned FastEmit_X86ISD_CMP_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02694   if (RetVT.SimpleTy != MVT::isVoid)
02695     return 0;
02696   return FastEmitInst_rr(X86::CMP64rr, X86::GR64RegisterClass, Op0, Op1);
02697 }
02698 
02699 unsigned FastEmit_X86ISD_CMP_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02700   if (RetVT.SimpleTy != MVT::isVoid)
02701     return 0;
02702   if ((!Subtarget->hasSSE1())) {
02703     return FastEmitInst_rr(X86::UCOM_FpIr32, X86::RFP32RegisterClass, Op0, Op1);
02704   }
02705   if ((Subtarget->hasSSE1())) {
02706     return FastEmitInst_rr(X86::UCOMISSrr, X86::FR32RegisterClass, Op0, Op1);
02707   }
02708   return 0;
02709 }
02710 
02711 unsigned FastEmit_X86ISD_CMP_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02712   if (RetVT.SimpleTy != MVT::isVoid)
02713     return 0;
02714   if ((!Subtarget->hasSSE2())) {
02715     return FastEmitInst_rr(X86::UCOM_FpIr64, X86::RFP64RegisterClass, Op0, Op1);
02716   }
02717   if ((Subtarget->hasSSE2())) {
02718     return FastEmitInst_rr(X86::UCOMISDrr, X86::FR64RegisterClass, Op0, Op1);
02719   }
02720   return 0;
02721 }
02722 
02723 unsigned FastEmit_X86ISD_CMP_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02724   if (RetVT.SimpleTy != MVT::isVoid)
02725     return 0;
02726   return FastEmitInst_rr(X86::UCOM_FpIr80, X86::RFP80RegisterClass, Op0, Op1);
02727 }
02728 
02729 unsigned FastEmit_X86ISD_CMP_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02730   switch (VT.SimpleTy) {
02731   case MVT::i8: return FastEmit_X86ISD_CMP_MVT_i8_rr(RetVT, Op0, Op1);
02732   case MVT::i16: return FastEmit_X86ISD_CMP_MVT_i16_rr(RetVT, Op0, Op1);
02733   case MVT::i32: return FastEmit_X86ISD_CMP_MVT_i32_rr(RetVT, Op0, Op1);
02734   case MVT::i64: return FastEmit_X86ISD_CMP_MVT_i64_rr(RetVT, Op0, Op1);
02735   case MVT::f32: return FastEmit_X86ISD_CMP_MVT_f32_rr(RetVT, Op0, Op1);
02736   case MVT::f64: return FastEmit_X86ISD_CMP_MVT_f64_rr(RetVT, Op0, Op1);
02737   case MVT::f80: return FastEmit_X86ISD_CMP_MVT_f80_rr(RetVT, Op0, Op1);
02738   default: return 0;
02739   }
02740 }
02741 
02742 // FastEmit functions for X86ISD::COMI.
02743 
02744 unsigned FastEmit_X86ISD_COMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02745   if (RetVT.SimpleTy != MVT::isVoid)
02746     return 0;
02747   if ((Subtarget->hasSSE1())) {
02748     return FastEmitInst_rr(X86::Int_COMISSrr, X86::VR128RegisterClass, Op0, Op1);
02749   }
02750   return 0;
02751 }
02752 
02753 unsigned FastEmit_X86ISD_COMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02754   if (RetVT.SimpleTy != MVT::isVoid)
02755     return 0;
02756   if ((Subtarget->hasSSE2())) {
02757     return FastEmitInst_rr(X86::Int_COMISDrr, X86::VR128RegisterClass, Op0, Op1);
02758   }
02759   return 0;
02760 }
02761 
02762 unsigned FastEmit_X86ISD_COMI_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02763   switch (VT.SimpleTy) {
02764   case MVT::v4f32: return FastEmit_X86ISD_COMI_MVT_v4f32_rr(RetVT, Op0, Op1);
02765   case MVT::v2f64: return FastEmit_X86ISD_COMI_MVT_v2f64_rr(RetVT, Op0, Op1);
02766   default: return 0;
02767   }
02768 }
02769 
02770 // FastEmit functions for X86ISD::FAND.
02771 
02772 unsigned FastEmit_X86ISD_FAND_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02773   if (RetVT.SimpleTy != MVT::f32)
02774     return 0;
02775   if ((Subtarget->hasSSE1())) {
02776     return FastEmitInst_rr(X86::FsANDPSrr, X86::FR32RegisterClass, Op0, Op1);
02777   }
02778   return 0;
02779 }
02780 
02781 unsigned FastEmit_X86ISD_FAND_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02782   if (RetVT.SimpleTy != MVT::f64)
02783     return 0;
02784   if ((Subtarget->hasSSE2())) {
02785     return FastEmitInst_rr(X86::FsANDPDrr, X86::FR64RegisterClass, Op0, Op1);
02786   }
02787   return 0;
02788 }
02789 
02790 unsigned FastEmit_X86ISD_FAND_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02791   switch (VT.SimpleTy) {
02792   case MVT::f32: return FastEmit_X86ISD_FAND_MVT_f32_rr(RetVT, Op0, Op1);
02793   case MVT::f64: return FastEmit_X86ISD_FAND_MVT_f64_rr(RetVT, Op0, Op1);
02794   default: return 0;
02795   }
02796 }
02797 
02798 // FastEmit functions for X86ISD::FMAX.
02799 
02800 unsigned FastEmit_X86ISD_FMAX_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02801   if (RetVT.SimpleTy != MVT::f32)
02802     return 0;
02803   if ((Subtarget->hasSSE1())) {
02804     return FastEmitInst_rr(X86::MAXSSrr, X86::FR32RegisterClass, Op0, Op1);
02805   }
02806   return 0;
02807 }
02808 
02809 unsigned FastEmit_X86ISD_FMAX_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02810   if (RetVT.SimpleTy != MVT::f64)
02811     return 0;
02812   if ((Subtarget->hasSSE2())) {
02813     return FastEmitInst_rr(X86::MAXSDrr, X86::FR64RegisterClass, Op0, Op1);
02814   }
02815   return 0;
02816 }
02817 
02818 unsigned FastEmit_X86ISD_FMAX_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02819   if (RetVT.SimpleTy != MVT::v4f32)
02820     return 0;
02821   if ((Subtarget->hasSSE1())) {
02822     return FastEmitInst_rr(X86::MAXPSrr, X86::VR128RegisterClass, Op0, Op1);
02823   }
02824   return 0;
02825 }
02826 
02827 unsigned FastEmit_X86ISD_FMAX_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02828   if (RetVT.SimpleTy != MVT::v2f64)
02829     return 0;
02830   if ((Subtarget->hasSSE2())) {
02831     return FastEmitInst_rr(X86::MAXPDrr, X86::VR128RegisterClass, Op0, Op1);
02832   }
02833   return 0;
02834 }
02835 
02836 unsigned FastEmit_X86ISD_FMAX_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02837   switch (VT.SimpleTy) {
02838   case MVT::f32: return FastEmit_X86ISD_FMAX_MVT_f32_rr(RetVT, Op0, Op1);
02839   case MVT::f64: return FastEmit_X86ISD_FMAX_MVT_f64_rr(RetVT, Op0, Op1);
02840   case MVT::v4f32: return FastEmit_X86ISD_FMAX_MVT_v4f32_rr(RetVT, Op0, Op1);
02841   case MVT::v2f64: return FastEmit_X86ISD_FMAX_MVT_v2f64_rr(RetVT, Op0, Op1);
02842   default: return 0;
02843   }
02844 }
02845 
02846 // FastEmit functions for X86ISD::FMIN.
02847 
02848 unsigned FastEmit_X86ISD_FMIN_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02849   if (RetVT.SimpleTy != MVT::f32)
02850     return 0;
02851   if ((Subtarget->hasSSE1())) {
02852     return FastEmitInst_rr(X86::MINSSrr, X86::FR32RegisterClass, Op0, Op1);
02853   }
02854   return 0;
02855 }
02856 
02857 unsigned FastEmit_X86ISD_FMIN_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02858   if (RetVT.SimpleTy != MVT::f64)
02859     return 0;
02860   if ((Subtarget->hasSSE2())) {
02861     return FastEmitInst_rr(X86::MINSDrr, X86::FR64RegisterClass, Op0, Op1);
02862   }
02863   return 0;
02864 }
02865 
02866 unsigned FastEmit_X86ISD_FMIN_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02867   if (RetVT.SimpleTy != MVT::v4f32)
02868     return 0;
02869   if ((Subtarget->hasSSE1())) {
02870     return FastEmitInst_rr(X86::MINPSrr, X86::VR128RegisterClass, Op0, Op1);
02871   }
02872   return 0;
02873 }
02874 
02875 unsigned FastEmit_X86ISD_FMIN_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02876   if (RetVT.SimpleTy != MVT::v2f64)
02877     return 0;
02878   if ((Subtarget->hasSSE2())) {
02879     return FastEmitInst_rr(X86::MINPDrr, X86::VR128RegisterClass, Op0, Op1);
02880   }
02881   return 0;
02882 }
02883 
02884 unsigned FastEmit_X86ISD_FMIN_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02885   switch (VT.SimpleTy) {
02886   case MVT::f32: return FastEmit_X86ISD_FMIN_MVT_f32_rr(RetVT, Op0, Op1);
02887   case MVT::f64: return FastEmit_X86ISD_FMIN_MVT_f64_rr(RetVT, Op0, Op1);
02888   case MVT::v4f32: return FastEmit_X86ISD_FMIN_MVT_v4f32_rr(RetVT, Op0, Op1);
02889   case MVT::v2f64: return FastEmit_X86ISD_FMIN_MVT_v2f64_rr(RetVT, Op0, Op1);
02890   default: return 0;
02891   }
02892 }
02893 
02894 // FastEmit functions for X86ISD::FOR.
02895 
02896 unsigned FastEmit_X86ISD_FOR_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02897   if (RetVT.SimpleTy != MVT::f32)
02898     return 0;
02899   if ((Subtarget->hasSSE1())) {
02900     return FastEmitInst_rr(X86::FsORPSrr, X86::FR32RegisterClass, Op0, Op1);
02901   }
02902   return 0;
02903 }
02904 
02905 unsigned FastEmit_X86ISD_FOR_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02906   if (RetVT.SimpleTy != MVT::f64)
02907     return 0;
02908   if ((Subtarget->hasSSE2())) {
02909     return FastEmitInst_rr(X86::FsORPDrr, X86::FR64RegisterClass, Op0, Op1);
02910   }
02911   return 0;
02912 }
02913 
02914 unsigned FastEmit_X86ISD_FOR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02915   switch (VT.SimpleTy) {
02916   case MVT::f32: return FastEmit_X86ISD_FOR_MVT_f32_rr(RetVT, Op0, Op1);
02917   case MVT::f64: return FastEmit_X86ISD_FOR_MVT_f64_rr(RetVT, Op0, Op1);
02918   default: return 0;
02919   }
02920 }
02921 
02922 // FastEmit functions for X86ISD::FXOR.
02923 
02924 unsigned FastEmit_X86ISD_FXOR_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02925   if (RetVT.SimpleTy != MVT::f32)
02926     return 0;
02927   if ((Subtarget->hasSSE1())) {
02928     return FastEmitInst_rr(X86::FsXORPSrr, X86::FR32RegisterClass, Op0, Op1);
02929   }
02930   return 0;
02931 }
02932 
02933 unsigned FastEmit_X86ISD_FXOR_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02934   if (RetVT.SimpleTy != MVT::f64)
02935     return 0;
02936   if ((Subtarget->hasSSE2())) {
02937     return FastEmitInst_rr(X86::FsXORPDrr, X86::FR64RegisterClass, Op0, Op1);
02938   }
02939   return 0;
02940 }
02941 
02942 unsigned FastEmit_X86ISD_FXOR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02943   switch (VT.SimpleTy) {
02944   case MVT::f32: return FastEmit_X86ISD_FXOR_MVT_f32_rr(RetVT, Op0, Op1);
02945   case MVT::f64: return FastEmit_X86ISD_FXOR_MVT_f64_rr(RetVT, Op0, Op1);
02946   default: return 0;
02947   }
02948 }
02949 
02950 // FastEmit functions for X86ISD::PCMPEQB.
02951 
02952 unsigned FastEmit_X86ISD_PCMPEQB_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02953   if (RetVT.SimpleTy != MVT::v8i8)
02954     return 0;
02955   return FastEmitInst_rr(X86::MMX_PCMPEQBrr, X86::VR64RegisterClass, Op0, Op1);
02956 }
02957 
02958 unsigned FastEmit_X86ISD_PCMPEQB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02959   if (RetVT.SimpleTy != MVT::v16i8)
02960     return 0;
02961   return FastEmitInst_rr(X86::PCMPEQBrr, X86::VR128RegisterClass, Op0, Op1);
02962 }
02963 
02964 unsigned FastEmit_X86ISD_PCMPEQB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02965   switch (VT.SimpleTy) {
02966   case MVT::v8i8: return FastEmit_X86ISD_PCMPEQB_MVT_v8i8_rr(RetVT, Op0, Op1);
02967   case MVT::v16i8: return FastEmit_X86ISD_PCMPEQB_MVT_v16i8_rr(RetVT, Op0, Op1);
02968   default: return 0;
02969   }
02970 }
02971 
02972 // FastEmit functions for X86ISD::PCMPEQD.
02973 
02974 unsigned FastEmit_X86ISD_PCMPEQD_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02975   if (RetVT.SimpleTy != MVT::v2i32)
02976     return 0;
02977   return FastEmitInst_rr(X86::MMX_PCMPEQDrr, X86::VR64RegisterClass, Op0, Op1);
02978 }
02979 
02980 unsigned FastEmit_X86ISD_PCMPEQD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02981   if (RetVT.SimpleTy != MVT::v4i32)
02982     return 0;
02983   return FastEmitInst_rr(X86::PCMPEQDrr, X86::VR128RegisterClass, Op0, Op1);
02984 }
02985 
02986 unsigned FastEmit_X86ISD_PCMPEQD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
02987   switch (VT.SimpleTy) {
02988   case MVT::v2i32: return FastEmit_X86ISD_PCMPEQD_MVT_v2i32_rr(RetVT, Op0, Op1);
02989   case MVT::v4i32: return FastEmit_X86ISD_PCMPEQD_MVT_v4i32_rr(RetVT, Op0, Op1);
02990   default: return 0;
02991   }
02992 }
02993 
02994 // FastEmit functions for X86ISD::PCMPEQQ.
02995 
02996 unsigned FastEmit_X86ISD_PCMPEQQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
02997   if (RetVT.SimpleTy != MVT::v2i64)
02998     return 0;
02999   return FastEmitInst_rr(X86::PCMPEQQrr, X86::VR128RegisterClass, Op0, Op1);
03000 }
03001 
03002 unsigned FastEmit_X86ISD_PCMPEQQ_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03003   switch (VT.SimpleTy) {
03004   case MVT::v2i64: return FastEmit_X86ISD_PCMPEQQ_MVT_v2i64_rr(RetVT, Op0, Op1);
03005   default: return 0;
03006   }
03007 }
03008 
03009 // FastEmit functions for X86ISD::PCMPEQW.
03010 
03011 unsigned FastEmit_X86ISD_PCMPEQW_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03012   if (RetVT.SimpleTy != MVT::v4i16)
03013     return 0;
03014   return FastEmitInst_rr(X86::MMX_PCMPEQWrr, X86::VR64RegisterClass, Op0, Op1);
03015 }
03016 
03017 unsigned FastEmit_X86ISD_PCMPEQW_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03018   if (RetVT.SimpleTy != MVT::v8i16)
03019     return 0;
03020   return FastEmitInst_rr(X86::PCMPEQWrr, X86::VR128RegisterClass, Op0, Op1);
03021 }
03022 
03023 unsigned FastEmit_X86ISD_PCMPEQW_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03024   switch (VT.SimpleTy) {
03025   case MVT::v4i16: return FastEmit_X86ISD_PCMPEQW_MVT_v4i16_rr(RetVT, Op0, Op1);
03026   case MVT::v8i16: return FastEmit_X86ISD_PCMPEQW_MVT_v8i16_rr(RetVT, Op0, Op1);
03027   default: return 0;
03028   }
03029 }
03030 
03031 // FastEmit functions for X86ISD::PCMPGTB.
03032 
03033 unsigned FastEmit_X86ISD_PCMPGTB_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03034   if (RetVT.SimpleTy != MVT::v8i8)
03035     return 0;
03036   return FastEmitInst_rr(X86::MMX_PCMPGTBrr, X86::VR64RegisterClass, Op0, Op1);
03037 }
03038 
03039 unsigned FastEmit_X86ISD_PCMPGTB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03040   if (RetVT.SimpleTy != MVT::v16i8)
03041     return 0;
03042   return FastEmitInst_rr(X86::PCMPGTBrr, X86::VR128RegisterClass, Op0, Op1);
03043 }
03044 
03045 unsigned FastEmit_X86ISD_PCMPGTB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03046   switch (VT.SimpleTy) {
03047   case MVT::v8i8: return FastEmit_X86ISD_PCMPGTB_MVT_v8i8_rr(RetVT, Op0, Op1);
03048   case MVT::v16i8: return FastEmit_X86ISD_PCMPGTB_MVT_v16i8_rr(RetVT, Op0, Op1);
03049   default: return 0;
03050   }
03051 }
03052 
03053 // FastEmit functions for X86ISD::PCMPGTD.
03054 
03055 unsigned FastEmit_X86ISD_PCMPGTD_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03056   if (RetVT.SimpleTy != MVT::v2i32)
03057     return 0;
03058   return FastEmitInst_rr(X86::MMX_PCMPGTDrr, X86::VR64RegisterClass, Op0, Op1);
03059 }
03060 
03061 unsigned FastEmit_X86ISD_PCMPGTD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03062   if (RetVT.SimpleTy != MVT::v4i32)
03063     return 0;
03064   return FastEmitInst_rr(X86::PCMPGTDrr, X86::VR128RegisterClass, Op0, Op1);
03065 }
03066 
03067 unsigned FastEmit_X86ISD_PCMPGTD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03068   switch (VT.SimpleTy) {
03069   case MVT::v2i32: return FastEmit_X86ISD_PCMPGTD_MVT_v2i32_rr(RetVT, Op0, Op1);
03070   case MVT::v4i32: return FastEmit_X86ISD_PCMPGTD_MVT_v4i32_rr(RetVT, Op0, Op1);
03071   default: return 0;
03072   }
03073 }
03074 
03075 // FastEmit functions for X86ISD::PCMPGTQ.
03076 
03077 unsigned FastEmit_X86ISD_PCMPGTQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03078   if (RetVT.SimpleTy != MVT::v2i64)
03079     return 0;
03080   return FastEmitInst_rr(X86::PCMPGTQrr, X86::VR128RegisterClass, Op0, Op1);
03081 }
03082 
03083 unsigned FastEmit_X86ISD_PCMPGTQ_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03084   switch (VT.SimpleTy) {
03085   case MVT::v2i64: return FastEmit_X86ISD_PCMPGTQ_MVT_v2i64_rr(RetVT, Op0, Op1);
03086   default: return 0;
03087   }
03088 }
03089 
03090 // FastEmit functions for X86ISD::PCMPGTW.
03091 
03092 unsigned FastEmit_X86ISD_PCMPGTW_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03093   if (RetVT.SimpleTy != MVT::v4i16)
03094     return 0;
03095   return FastEmitInst_rr(X86::MMX_PCMPGTWrr, X86::VR64RegisterClass, Op0, Op1);
03096 }
03097 
03098 unsigned FastEmit_X86ISD_PCMPGTW_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03099   if (RetVT.SimpleTy != MVT::v8i16)
03100     return 0;
03101   return FastEmitInst_rr(X86::PCMPGTWrr, X86::VR128RegisterClass, Op0, Op1);
03102 }
03103 
03104 unsigned FastEmit_X86ISD_PCMPGTW_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03105   switch (VT.SimpleTy) {
03106   case MVT::v4i16: return FastEmit_X86ISD_PCMPGTW_MVT_v4i16_rr(RetVT, Op0, Op1);
03107   case MVT::v8i16: return FastEmit_X86ISD_PCMPGTW_MVT_v8i16_rr(RetVT, Op0, Op1);
03108   default: return 0;
03109   }
03110 }
03111 
03112 // FastEmit functions for X86ISD::PSHUFB.
03113 
03114 unsigned FastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03115   if (RetVT.SimpleTy != MVT::v16i8)
03116     return 0;
03117   if ((Subtarget->hasSSSE3())) {
03118     return FastEmitInst_rr(X86::PSHUFBrr128, X86::VR128RegisterClass, Op0, Op1);
03119   }
03120   return 0;
03121 }
03122 
03123 unsigned FastEmit_X86ISD_PSHUFB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03124   switch (VT.SimpleTy) {
03125   case MVT::v16i8: return FastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(RetVT, Op0, Op1);
03126   default: return 0;
03127   }
03128 }
03129 
03130 // FastEmit functions for X86ISD::PTEST.
03131 
03132 unsigned FastEmit_X86ISD_PTEST_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03133   if (RetVT.SimpleTy != MVT::isVoid)
03134     return 0;
03135   if ((Subtarget->hasSSE41())) {
03136     return FastEmitInst_rr(X86::PTESTrr, X86::VR128RegisterClass, Op0, Op1);
03137   }
03138   return 0;
03139 }
03140 
03141 unsigned FastEmit_X86ISD_PTEST_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03142   switch (VT.SimpleTy) {
03143   case MVT::v4f32: return FastEmit_X86ISD_PTEST_MVT_v4f32_rr(RetVT, Op0, Op1);
03144   default: return 0;
03145   }
03146 }
03147 
03148 // FastEmit functions for X86ISD::SMUL.
03149 
03150 unsigned FastEmit_X86ISD_SMUL_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03151   if (RetVT.SimpleTy != MVT::i16)
03152     return 0;
03153   return FastEmitInst_rr(X86::IMUL16rr, X86::GR16RegisterClass, Op0, Op1);
03154 }
03155 
03156 unsigned FastEmit_X86ISD_SMUL_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03157   if (RetVT.SimpleTy != MVT::i32)
03158     return 0;
03159   return FastEmitInst_rr(X86::IMUL32rr, X86::GR32RegisterClass, Op0, Op1);
03160 }
03161 
03162 unsigned FastEmit_X86ISD_SMUL_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03163   if (RetVT.SimpleTy != MVT::i64)
03164     return 0;
03165   return FastEmitInst_rr(X86::IMUL64rr, X86::GR64RegisterClass, Op0, Op1);
03166 }
03167 
03168 unsigned FastEmit_X86ISD_SMUL_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03169   switch (VT.SimpleTy) {
03170   case MVT::i16: return FastEmit_X86ISD_SMUL_MVT_i16_rr(RetVT, Op0, Op1);
03171   case MVT::i32: return FastEmit_X86ISD_SMUL_MVT_i32_rr(RetVT, Op0, Op1);
03172   case MVT::i64: return FastEmit_X86ISD_SMUL_MVT_i64_rr(RetVT, Op0, Op1);
03173   default: return 0;
03174   }
03175 }
03176 
03177 // FastEmit functions for X86ISD::SUB.
03178 
03179 unsigned FastEmit_X86ISD_SUB_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03180   if (RetVT.SimpleTy != MVT::i8)
03181     return 0;
03182   return FastEmitInst_rr(X86::SUB8rr, X86::GR8RegisterClass, Op0, Op1);
03183 }
03184 
03185 unsigned FastEmit_X86ISD_SUB_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03186   if (RetVT.SimpleTy != MVT::i16)
03187     return 0;
03188   return FastEmitInst_rr(X86::SUB16rr, X86::GR16RegisterClass, Op0, Op1);
03189 }
03190 
03191 unsigned FastEmit_X86ISD_SUB_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03192   if (RetVT.SimpleTy != MVT::i32)
03193     return 0;
03194   return FastEmitInst_rr(X86::SUB32rr, X86::GR32RegisterClass, Op0, Op1);
03195 }
03196 
03197 unsigned FastEmit_X86ISD_SUB_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03198   if (RetVT.SimpleTy != MVT::i64)
03199     return 0;
03200   return FastEmitInst_rr(X86::SUB64rr, X86::GR64RegisterClass, Op0, Op1);
03201 }
03202 
03203 unsigned FastEmit_X86ISD_SUB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03204   switch (VT.SimpleTy) {
03205   case MVT::i8: return FastEmit_X86ISD_SUB_MVT_i8_rr(RetVT, Op0, Op1);
03206   case MVT::i16: return FastEmit_X86ISD_SUB_MVT_i16_rr(RetVT, Op0, Op1);
03207   case MVT::i32: return FastEmit_X86ISD_SUB_MVT_i32_rr(RetVT, Op0, Op1);
03208   case MVT::i64: return FastEmit_X86ISD_SUB_MVT_i64_rr(RetVT, Op0, Op1);
03209   default: return 0;
03210   }
03211 }
03212 
03213 // FastEmit functions for X86ISD::UCOMI.
03214 
03215 unsigned FastEmit_X86ISD_UCOMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03216   if (RetVT.SimpleTy != MVT::isVoid)
03217     return 0;
03218   if ((Subtarget->hasSSE1())) {
03219     return FastEmitInst_rr(X86::Int_UCOMISSrr, X86::VR128RegisterClass, Op0, Op1);
03220   }
03221   return 0;
03222 }
03223 
03224 unsigned FastEmit_X86ISD_UCOMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
03225   if (RetVT.SimpleTy != MVT::isVoid)
03226     return 0;
03227   if ((Subtarget->hasSSE2())) {
03228     return FastEmitInst_rr(X86::Int_UCOMISDrr, X86::VR128RegisterClass, Op0, Op1);
03229   }
03230   return 0;
03231 }
03232 
03233 unsigned FastEmit_X86ISD_UCOMI_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
03234   switch (VT.SimpleTy) {
03235   case MVT::v4f32: return FastEmit_X86ISD_UCOMI_MVT_v4f32_rr(RetVT, Op0, Op1);
03236   case MVT::v2f64: return FastEmit_X86ISD_UCOMI_MVT_v2f64_rr(RetVT, Op0, Op1);
03237   default: return 0;
03238   }
03239 }
03240 
03241 // Top-level FastEmit function.
03242 
03243 unsigned FastEmit_rr(MVT VT, MVT RetVT, ISD::NodeType Opcode, unsigned Op0, unsigned Op1) {
03244   switch (Opcode) {
03245   case ISD::ADD: return FastEmit_ISD_ADD_rr(VT, RetVT, Op0, Op1);
03246   case ISD::ADDC: return FastEmit_ISD_ADDC_rr(VT, RetVT, Op0, Op1);
03247   case ISD::ADDE: return FastEmit_ISD_ADDE_rr(VT, RetVT, Op0, Op1);
03248   case ISD::AND: return FastEmit_ISD_AND_rr(VT, RetVT, Op0, Op1);
03249   case ISD::FADD: return FastEmit_ISD_FADD_rr(VT, RetVT, Op0, Op1);
03250   case ISD::FDIV: return FastEmit_ISD_FDIV_rr(VT, RetVT, Op0, Op1);
03251   case ISD::FMUL: return FastEmit_ISD_FMUL_rr(VT, RetVT, Op0, Op1);
03252   case ISD::FSUB: return FastEmit_ISD_FSUB_rr(VT, RetVT, Op0, Op1);
03253   case ISD::MUL: return FastEmit_ISD_MUL_rr(VT, RetVT, Op0, Op1);
03254   case ISD::OR: return FastEmit_ISD_OR_rr(VT, RetVT, Op0, Op1);
03255   case ISD::SUB: return FastEmit_ISD_SUB_rr(VT, RetVT, Op0, Op1);
03256   case ISD::SUBC: return FastEmit_ISD_SUBC_rr(VT, RetVT, Op0, Op1);
03257   case ISD::SUBE: return FastEmit_ISD_SUBE_rr(VT, RetVT, Op0, Op1);
03258   case ISD::XOR: return FastEmit_ISD_XOR_rr(VT, RetVT, Op0, Op1);
03259   case X86ISD::ADD: return FastEmit_X86ISD_ADD_rr(VT, RetVT, Op0, Op1);
03260   case X86ISD::BT: return FastEmit_X86ISD_BT_rr(VT, RetVT, Op0, Op1);
03261   case X86ISD::CMP: return FastEmit_X86ISD_CMP_rr(VT, RetVT, Op0, Op1);
03262   case X86ISD::COMI: return FastEmit_X86ISD_COMI_rr(VT, RetVT, Op0, Op1);
03263   case X86ISD::FAND: return FastEmit_X86ISD_FAND_rr(VT, RetVT, Op0, Op1);
03264   case X86ISD::FMAX: return FastEmit_X86ISD_FMAX_rr(VT, RetVT, Op0, Op1);
03265   case X86ISD::FMIN: return FastEmit_X86ISD_FMIN_rr(VT, RetVT, Op0, Op1);
03266   case X86ISD::FOR: return FastEmit_X86ISD_FOR_rr(VT, RetVT, Op0, Op1);
03267   case X86ISD::FXOR: return FastEmit_X86ISD_FXOR_rr(VT, RetVT, Op0, Op1);
03268   case X86ISD::PCMPEQB: return FastEmit_X86ISD_PCMPEQB_rr(VT, RetVT, Op0, Op1);
03269   case X86ISD::PCMPEQD: return FastEmit_X86ISD_PCMPEQD_rr(VT, RetVT, Op0, Op1);
03270   case X86ISD::PCMPEQQ: return FastEmit_X86ISD_PCMPEQQ_rr(VT, RetVT, Op0, Op1);
03271   case X86ISD::PCMPEQW: return FastEmit_X86ISD_PCMPEQW_rr(VT, RetVT, Op0, Op1);
03272   case X86ISD::PCMPGTB: return FastEmit_X86ISD_PCMPGTB_rr(VT, RetVT, Op0, Op1);
03273   case X86ISD::PCMPGTD: return FastEmit_X86ISD_PCMPGTD_rr(VT, RetVT, Op0, Op1);
03274   case X86ISD::PCMPGTQ: return FastEmit_X86ISD_PCMPGTQ_rr(VT, RetVT, Op0, Op1);
03275   case X86ISD::PCMPGTW: return FastEmit_X86ISD_PCMPGTW_rr(VT, RetVT, Op0, Op1);
03276   case X86ISD::PSHUFB: return FastEmit_X86ISD_PSHUFB_rr(VT, RetVT, Op0, Op1);
03277   case X86ISD::PTEST: return FastEmit_X86ISD_PTEST_rr(VT, RetVT, Op0, Op1);
03278   case X86ISD::SMUL: return FastEmit_X86ISD_SMUL_rr(VT, RetVT, Op0, Op1);
03279   case X86ISD::SUB: return FastEmit_X86ISD_SUB_rr(VT, RetVT, Op0, Op1);
03280   case X86ISD::UCOMI: return FastEmit_X86ISD_UCOMI_rr(VT, RetVT, Op0, Op1);
03281   default: return 0;
03282   }
03283 }
03284