LLVM API Documentation
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